AI Engineer Code 2025

Future-Proof Coding Agents

Loading slides…

Read the talk

Future-Proof Coding Agents

A coding agent depends on more than model intelligence: its tools, prompts, and runtime must fit the model’s habits without making every upgrade a rebuild.

From a talk by Bill Chen and Brian Fioca

Before you start: Familiarity with command-line tools, model tool calls, and basic software development workflows will help you follow the integration examples.

Why does a new model mean rebuilding the agent?

Why should a better coding model force you to rebuild the agent around it? That is the opening problem for Bill Chen and Brian Fioca, who work on coding agents on OpenAI’s Startups team. Software engineering can serve as a general medium for solving problems, which makes progress in coding especially consequential. But rapid model releases keep shifting the foundations beneath the applications built on them: prompts, tools, and orchestration that fit one model may need adjustment for the next.

The way through that problem starts by separating the model from the software that makes it an agent. From there, the practical questions are what Codex bundles together, which parts a product should reuse, and where a custom integration still adds value.

0:270:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:27 · section reference included

Interface, model, and harness

A coding agent has three main parts:

PartResponsibilityExamples
User interfaceLet people request and follow workCLI, IDE, cloud or background agent
ModelSupply reasoning and coding capabilityGPT-5.1 series, other providers’ models
HarnessConnect model inputs and outputs to actionsPrompts, tools, core agent loop

Chen’s model examples include GPT-5.1 and the then newly released GPT-5.1-Codex-Max. The harness is the collection of prompts and tools organized into the loop that lets the model keep working.

Slide with three columns listing user interface options, model examples, and harness elements including prompts, an agentic loop, and tools.Open full source frame
Coding agents have three core components: user interface, models, and harness.

The harness is the model’s interface to the working environment. It gives the model access to users, code, and actions through tools. It also supports the continuity needed to interpret a request, work over many turns, and produce changes. That layer can be a product’s differentiator, but owning it means owning the work required to keep it fitted to changing models.

2:062:19
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:06 · section reference included

Where the fit breaks down

An innovative tool is not automatically an effective tool for a model. It may be out of distribution: unlike the tools the model encountered during training. Even when the operation is familiar, the prompt may need tuning to the model’s learned behavior. A harness therefore has to account for more than whether a tool’s schema is valid. It has to make that tool usable by the particular model doing the work.

Several other responsibilities change with the model and its interfaces:

  • Latency and progress: Which tasks cause prolonged reasoning? Should instructions change, and what should the user see while the model works—direct communication or a summary of progress?
  • Context and compaction: What stays in the context window, and how does work continue when it fills? Fioca points to automatic compaction with Codex Max. That launch-era behavior applied to Codex applications using the model; it did not remove context-management responsibilities from arbitrary custom harnesses, and direct API access was still forthcoming.
  • API evolution: Moving among interfaces such as Completions and Responses changes the integration surface. The relevant question is which interface lets the model use its capabilities effectively.
4:394:55
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:39 · section reference included

When thorough instructions become unnecessary work

Fioca separates model behavior into intelligence and habits. Intelligence covers competence in programming languages, frameworks, and code generation. Habits are the learned ways of applying that competence: planning a solution, looking around the repository, gathering context, thinking before editing, and testing afterward. Effective prompting requires a feel for both. Instructions that seem helpful in isolation can conflict with, or amplify, behavior the model already learned.

At the launch of GPT-5, some developers transferred prompts from other models into their existing harnesses. Those prompts told the agent to examine the context very thoroughly, including inspecting every file before making an edit. OpenAI had already trained the model to gather context. The extra instructions pushed that habit further, and Fioca reports that the resulting work took a long time. Reducing the over-prompting let the model follow its usual behavior more effectively.

Fioca describes asking the model what he could change in the instructions to get to a satisfactory solution faster. Its answer identified the demand to inspect everything as the source of unnecessary work. This was an instruction-debugging anecdote, with no measured latency comparison supplied. Its practical lesson is to examine whether a prompt is compensating for a missing capability or duplicating a habit already present in the model. Joint development of the model and harness makes that interaction easier to understand; Fioca presents it as a reason Codex combines both.

5:596:15
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:59 · section reference included

What the Codex harness has to operate

Codex exposes that combined system across development surfaces. Fioca describes a VS Code plugin, a CLI, and cloud tasks invoked from the plugin or from ChatGPT on a phone. A specification or prompt becomes a plan, repository navigation, file edits, command execution, and runnable code. Slack invocation and GitHub pull-request review add other entry points to the same kind of work.

Those interfaces conceal substantial runtime machinery. When Fioca asked a Codex team member what belonged on the harness slide, the response was “It's way harder than you think.” The concrete responsibilities explain why:

  • Concurrent execution: Manage parallel tool calls and merge their threads of work.
  • Security and connectivity: Handle sandboxing, permissions, port forwarding, and port management.
  • Long-running context: Decide when to compact, when to reintroduce context, and how those choices affect cache efficiency.
  • Tool and media support: Implement MCP plumbing and choose image resolution and compression before sending images to the model.

Each capability also creates maintenance work as new features arrive.

8:268:31
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:26 · section reference included

The terminal extends the task boundary

Once the harness bundles those capabilities, the agent can write tools to address problems it encounters. Fioca calls the result a computer-use agent for the terminal. His description of safely generating tools depends on the execution boundary: sandboxing and permissions constrain what generated code can do, and human review remains necessary before deployment.

Chen connects this to an older way of using computers. Before graphical interfaces, writing programs and chaining commands were ordinary ways to get work done. A coding agent can use the same medium. Chen uses Codex to organize desktop photos into a folder; he also gives analysis of large collections of CSV files as an example. The task need not be software development if it can be accomplished through files and command-line tools.

Presenter beside a slide stating that even a non-coding task can use Codex if it can be accomplished by running tools from a command line.Open full source frame
Even non-coding tasks can use Codex when they can be accomplished through command-line tools.
10:0710:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:07 · section reference included

Use an agent inside your agent

That broader task boundary makes Codex useful as a component inside another agent. Drawing on work with customers such as Cursor and VS Code, Chen proposes the harness as an abstraction layer: a product integrates an agent whose prompts and tools are maintained alongside its models, instead of retuning those details for every upgrade. These are integration patterns, not a complete recipe for a coding startup.

Does that leave the product as merely a wrapper? Chen and Fioca reject the premise. Reusing infrastructure allows a team to spend more effort on the part customers experience as differentiated value. The architectural choice is where to own complexity: inside the model-facing runtime, or in the product built above it.

The programmable entry points include a TypeScript SDK, CLI invocation from programs such as Python scripts, and a GitHub Action for workflows such as resolving pull-request merge conflicts. Python invocation here means calling the CLI, not a native Python Codex SDK. A small TypeScript caller can use the same codex exec boundary to request analysis before making changes:

typescript

import { execFileSync } from "node:child_process";

const result = execFileSync(
  "codex",
  [
    "exec",
    "Inspect the current merge conflicts and explain a resolution plan. Do not edit files."
  ],
  {
    cwd: process.cwd(),
    encoding: "utf8",
    stdio: ["ignore", "pipe", "inherit"]
  }
);

process.stdout.write(result);

This call requests a plan; applying a resolution would be a separate task governed by the agent’s execution permissions.

A richer integration puts Codex behind a tool in an agent built with the Agents SDK, with MCP connectors back to the host product. Fioca describes a progression: first a chatbot can converse, then it can use tools, and then it can invoke a tool that creates tools it lacks. For enterprise software, that could mean generating a customer-specific API connector on demand—a task previously assigned to professional services. His concrete example is a DevDay Kanban board that he says could fix its own bugs.

Zed’s Codex integration illustrates a different division of responsibility. Through Agent Client Protocol and the codex-acp adapter, the editor provides the interface for user interaction and code changes while Codex supplies agent execution. That lets Zed concentrate on the editor rather than maintaining the entire underlying harness. Chen also cites GitHub as a partner integrating through the SDK, and describes using the SDK in CI/CD pipelines or for interaction between agents.

11:2411:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:24 · section reference included

Keeping a custom harness in distribution

Reusing the complete agent is not the only option. Chen describes working with Cursor to improve its integration with Codex the model, explicitly distinguishing that from Codex the agent. Cursor retained its own agent layer while aligning its tools with the model’s training distribution and its harness with the open-source Codex CLI implementation.

The distinction gives builders two meaningful levels of control: embed the maintained agent, or use the public implementation to inform a custom harness. The source is available to inspect, use, and fork. Choosing the latter preserves control over the agent layer while retaining responsibility for how its tools and prompts fit the model.

14:5515:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:55 · section reference included

Building for longer work and a broader SDK

At the time of the talk, Fioca describes Codex as less than a year old and calls it OpenAI’s fastest-growing model by usage. Fioca reports dozens of trillions of tokens served per week, with usage doubled since DevDay. Those are his usage claims; the passage does not specify the token accounting or precise product scope.

His forecast is that improving models will handle longer tasks without supervision and raise the level of work people trust them to perform. He describes already trusting them with harder work than he would have six months earlier. The target is increasingly demanding software environments: sprawling codebases, non-standard libraries, closed-source systems, and projects whose existing templates and practices must be followed.

The SDK is expected to evolve with those capabilities. Fioca anticipates support for learning during a task, avoiding repeated mistakes, and exposing more of a general agent’s ability to solve problems through code and a terminal. These are directions for future capability, with the SDK serving as the route through which products would gain access to them.

Slide with two columns: better agentic capabilities, longer horizon tasks, and SWE best practices; an extensible SDK and a more generally capable agent.Open full source frame
The Codex outlook combines smarter models with more extensible ways to use the agent.

The closing recommendation is to make a deliberate choice about who maintains that foundation. Codex offers an off-the-shelf harness and source code for teams that want to examine or adapt it. Building above that layer leaves the provider responsible for ongoing model compatibility while the product team applies the agent to useful work—including work outside coding.

15:3415:46
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:34 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…