# The Golden Age of AI Engineering

Alexander Embiricos, OpenAI · Romain Huet, OpenAI · Peter Steinberger

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/pMggiOb18tc-golden-age-ai-engineering) · [Video](https://www.youtube.com/watch?v=pMggiOb18tc)

## The Golden Age of AI Engineering

As agents move from generating code to running sustained workflows, engineering shifts toward better interfaces, shared infrastructure and loops that reserve human attention for consequential decisions.

### Making the future tangible

[0:19](https://www.youtube.com/watch?v=pMggiOb18tc&t=19s)

A World’s Fair makes an improbable future tangible: people can see it, walk into it and begin to believe in it because someone built it in public. Opening the [AI Engineer World’s Fair](https://ai.engineer/worldsfair/2026), Romain Huet applies that idea to the engineers building with AI. He describes more than 7,000 AI engineers in the room, making capabilities usable faster than many people expected.

That activity sits awkwardly beside headlines predicting the disappearance of software engineers. If AI abstracts away coding, does engineering disappear with it? Romain’s answer follows the progression from software eating the world, to AI eating software, to AI engineers extending what can be built. **Engineering is problem-solving, not merely code production.** Its work combines science with design, taste, judgment and imagination to make something useful for other people. Automating more of the implementation can therefore return engineering to its roots.

![Four prominent headline clippings discuss AI coding and the future of software engineers, with a speaker inset at lower left.](https://ai.engineer/api/talk-essay-media/1fd1d856c22343c6ca207fd8c1053ca831eed3646df642b95ed43a6db280297b)

Headlines question the future of software engineering as AI writes code.

### From suggested code to verified execution

[2:08](https://www.youtube.com/watch?v=pMggiOb18tc&t=128s)

Alexander Embiricos describes a release cadence that has accelerated from roughly one model every fifteen months to roughly one every six weeks. The [**GPT-5.6** series preview](https://openai.com/index/previewing-gpt-5-6-sol/) had launched the preceding week. For a developer, that acceleration appears as successive changes in what can be delegated: first completion, then inline prediction, then Command-K edits that did not test their work, then models that did test, and finally agents pursuing long, difficult goals until completion. Each transition initially feels extraordinary; soon it becomes the baseline for getting work done.

The difference becomes concrete in Romain’s live demos. At DevDay 2024, he used **o1 in preview** to build a mini-drone interface from scratch. The model could neither run the generated code nor verify its work, leaving him to take the stage with an interface he expected to work most of the time. It did work. By DevDay 2025, models could test their own work, and he felt confident enough to demonstrate control of an entire camera and lighting system live.

Alexander jokes that, before a demo, Romain might report that it worked “three times out of four” and receive little more than a good-luck wish. That exchange captures the earlier experience: generating plausible code left the presenter carrying the verification burden. Closing the build-and-test loop changed what he was willing to attempt.

### Connect the work before and after coding

[4:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=249s)

The Codex app, Goal Mode and Remote are Alexander’s examples of product changes that alter the experience of working. The team uses Codex to build Codex, but his broader claim is that agents can undertake any task a person can do on their computer. That expands the useful surface beyond writing code to the work that precedes and follows it.

Connecting an agent to **why work is needed** helps it identify and initiate work. Connecting it to review and deployment helps it finish and land that work. The opportunity is larger than faster implementation: Alexander says the team can prototype more ideas and spend more time with users, improving decisions about what deserves to be built in the first place.

### Chat first, then reach into the work

[5:30](https://www.youtube.com/watch?v=pMggiOb18tc&t=330s)

Alexander offers a personal comparison: given equal time on an average, medium-length computer task, he expects the model would probably do a better job than he would. That raises a product question. If agents are increasingly capable, how should people work with them? He connects this to the mission of AGI benefiting humanity through two questions: what agents can do and where they run, and what the human experience around them should feel like. The goal he sets is to empower engineers.

His proposed interface has two complementary modes:

- **Chat:** one entity you can ask for help with anything, wherever you are.
- **Hands-on collaboration:** a powerful interface for inspecting, steering and shaping the work yourself.

A Codex-generated illustration supplies the workbench analogy. With a teammate, most coordination happens through conversation; you do not stand over their shoulder for every task. Occasionally, you need to examine a problem together in detail. The interface should make that transition easy enough to preserve a feeling of mastery, including the ability to take the work apart.

The Codex app puts that sequence into a product: start with a conversation, then go as deep as necessary. The example on screen is Romain’s prediction for an upcoming World Cup match. A user can point to a particular element and ask for a change, or make the change directly. Conversation and manipulation belong to the same workspace.

Some developers initially told Alexander they would never leave their terminal, Vim or Emacs for this kind of app; he says those same people now use it. The internal debate was similar: why add another surface when developers already liked the CLI and IDE? His answer is about the order of interaction.

| Surface | Starting point | Limit in Alexander’s design argument |
| --- | --- | --- |
| CLI | Mostly conversation | Limited collaborative surface for arbitrary work |
| IDE | Code | Begins in the details before delegation |
| Codex app | Conversation | Opens the details when inspection or steering is needed |

The app’s purpose is to support teammate-style collaboration across kinds of work, with direct access to the artifact when the conversation alone is insufficient.

![Codex app icon beside an application window showing a sidebar and a France versus Sweden prediction page with a 3–0 score.](https://ai.engineer/api/talk-essay-media/f1f76af9fcd92c630f8a0c2e7e6779e985e5fb69fdc4729c513bbf004f25af38)

The Codex app displays a football prediction interface beside its conversation sidebar.

### Build on the same models, API and harness

[9:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=549s)

The product is also shaped by developers discovering uses its builders did not anticipate. Romain describes seeing community experiments, personal tools and team workflows that reveal what Codex can do and what it should support next. For that feedback loop to work, Codex cannot be a closed product that only OpenAI can improve. Its architecture needs layers other developers can build on.

The first layer is the model, accessed through the **Responses API**. Romain says the Codex app uses the same models through the same API offered to developers, with an intent to put new primitives into the API first when Codex needs them. Context compaction is his example: long-running tasks needed a way to compact long contexts, so that capability became an API primitive available to other agents.

Above the API sits the [open-source Codex harness](https://github.com/openai/codex), which developers can inspect, fork and adapt. The `AGENTS.md` convention follows the same interoperability principle: choose an instruction-file name other agents can use rather than invent a Codex-only format. OpenAI models are defaults in the harness, Romain says, rather than hard-coded requirements; an open model can use the same agent loop. He also describes bringing the harness into model post-training so models learn tool use and environment navigation in an environment whose implementation developers can inspect.

OpenCode provides a concrete example of why that visibility matters. Its developers could examine the reference implementation, reuse useful parts and make different decisions elsewhere. Romain specifically mentions their investigation of sign-in with ChatGPT. Reading the implementation provides a more direct foundation for integration than reverse engineering a launched product.

### Expose the product integration layers

[11:43](https://www.youtube.com/watch?v=pMggiOb18tc&t=703s)

An application needs more than an agent loop: it needs a way to control that loop and let people sign in with an existing Codex subscription. OpenAI faced that problem when building its VS Code extension and Codex app. The resulting open-source `app-server` is the integration path used by those products, not a separate community adapter.

Thomas used `app-server` to build the native CodexMonitor application. Romain says it preceded the official Codex app, and that Thomas subsequently joined the team and built Codex for iOS. The example illustrates what a reusable product integration layer enables: another developer can build a different client around the same underlying agent.

At the application layer, the extension primitives include the in-app browser and plugins. Romain says `browser_use` and `computer_use` were themselves built as plugins using the extension points available to developers. Open-source role-specific plugins extend that approach to work such as data science and design, giving developers implementations they can inspect and adapt.

![Six stacked boxes labeled Plugins, App, App Server, Codex Harness, Responses API, and Models. Plugins and App are highlighted blue.](https://ai.engineer/api/talk-essay-media/522b675947678924431b75d087763647743c9fe69431be283d20a16d5b20122b)

Plugins and App sit atop the stack under the message “Build an open ecosystem.”

The ecosystem also extends where an existing subscription can be used. Romain names OpenCode, Pi, Droid, OpenClaw, Xcode and JetBrains. Across these layers, his architectural commitment is consistent: **OpenAI uses the system it gives developers**, rather than keeping a richer internal system and exposing a simplified substitute. Forks of the harness and discoveries at the edge of model capabilities become inputs to further improvement.

### Value comes from useful intelligence

[14:25](https://www.youtube.com/watch?v=pMggiOb18tc&t=865s)

Once agents become useful, the question becomes how much value an organization can extract from them. Alexander calls this “value maxing,” contrasting it with maximizing token consumption. Cost efficiency is the first recurring theme in his conversations with engineering leaders: they want frontier capability, but also as much useful intelligence as their budget can buy.

On the displayed Terminal-Bench evaluation, Alexander identifies **GPT-5.6 Sol** as the frontier choice. His comparisons for the smaller models are:

| Model | Alexander’s reported comparison | Cost claim |
| --- | --- | --- |
| **GPT-5.6 Terra** | **GPT-5.5**-level intelligence | Half the cost |
| **GPT-5.6 Luna** | Beats some unnamed notable models on the displayed evaluation | $1 per million input tokens; $6 per million output tokens |

These are comparisons around the displayed evaluation, whose precise settings and scores are not specified in the spoken explanation. The Terra claim does not establish half the total cost of completing a task, and Luna’s token prices apply to Luna rather than the entire family.

Speed is the next dimension. **GPT-5.3-Codex-Spark** had already shown what fast generation could unlock, but Romain emphasizes the desire to combine that speed with frontier capability. Romain presents GPT-5.6 Sol on Cerebras at an advertised rate of up to 750 tokens per second, with access anticipated the following month. That is generation throughput, not the elapsed time to implement, test and land a change.

His comparison is a substantial pull request written in roughly ten seconds—an illustration of the generation rate, rather than a measured delivery result. More interesting than a single faster answer is the possibility of exploring several answers: an agent could try five or six approaches in parallel, then select the best, within a waiting period that previously constrained it to less than one. Faster inference could change the search strategy as well as the responsiveness of the interface.

### Let the agent choose where to work

[16:51](https://www.youtube.com/watch?v=pMggiOb18tc&t=1011s)

A familiar office scene exposes another limitation: laptops left open so agents can keep working. The desired outcome is straightforward—close the computer while multiple tasks continue, each isolated on its own machine. Alexander points back to Codex Cloud as the first major launch and promises substantial upgrades, but the longer-term product goal goes beyond a better cloud task queue.

Users should not have to classify every request as local or cloud work. They should be able to talk to one agent, which determines what needs doing, chooses an appropriate available environment and uses it. When Romain asks about a displayed prediction from Theo, Alexander expects its general direction much sooner than six months, while explicitly stopping short of endorsing its exact details. The direction is a unified agent whose execution location follows the task.

### Stop being the scheduler

[18:17](https://www.youtube.com/watch?v=pMggiOb18tc&t=1097s)

Instead of another live demo, Romain introduces Peter Steinberger, the “Clawfather,” to describe a changing way of working. Peter recalls juggling ten or more terminal windows, waiting for one agent to finish so he could steer it and queue more work. In January, that felt like peak productivity. Looking back, he sees a different division of labor: he was polling, and serving as the scheduler, router and memory for the whole system.

Pairing with one agent had become managing ten direct reports. Peter’s new default is to talk to a long-running manager that delegates to a team. He can still pair directly with a worker on a difficult problem, but he no longer needs to supervise each worker’s routine progress.

Three capabilities make that shift possible:

- **Persistent context:** server-side compaction made long-running tasks reliable enough in Peter’s experience that he stopped organizing his work around fresh sessions.
- **Delegation:** coordination lets one thread create and steer the appropriate projects.
- **Triggers:** automation wakes the same manager when something happens.

Together, these let an event resume an ongoing relationship with project context and delegated work, rather than requiring a person to reconstruct the situation and dispatch every next action. Compaction supports that continuity; it does not imply lossless memory or guaranteed completion.

### The bottleneck moves to attention

[20:32](https://www.youtube.com/watch?v=pMggiOb18tc&t=1232s)

Once the loop works, its bottleneck moves. Peter was initially constrained by tokens. He jokes that joining OpenAI fixed that problem, immediately acknowledging that the strategy does not scale. Compute became the next constraint: concurrent threads made his MacBook sound like a jet engine. Separate test boxes, where agents could run tests on another machine, mostly addressed that contention.

Now the scarce resource is attention. Unlike tokens or compute, Peter cannot simply add more of it, so deciding where to spend it becomes a central engineering skill. Watching an agent’s code stream can consume attention without changing the outcome. Earlier models often needed that supervision: spot an unwanted direction, press Escape and steer them back. Peter’s judgment is that newer models understand intent well enough to make constant observation a poor default.

### Bring the human a reviewable result

[22:08](https://www.youtube.com/watch?v=pMggiOb18tc&t=1328s)

Peter’s illustrative workflow begins with someone filing an issue on an open-source project. The manager wakes up and evaluates the issue against the project’s goals, notes and vision. If it appears to fit, the manager creates a worker. That worker investigates, implements and tests the change; another agent can review the result. The human does not need to consume every intermediate message.

The handoff happens when there is something consequential to inspect:

1. Return a pull request together with the original issue and proposed diff.
2. Include richer evidence when useful: a video, or a running build the human can enter through VNC.
3. Let the human review, leave a note or approve.
4. Continue the loop; the change can land after the checks pass.

**The agent owns the inner execution loop; the human owns direction and decisions in the outer loop.** Generating a diff is not itself permission to land it.

A small TypeScript predicate can make the review boundary explicit in an implementation of this proposed workflow. It answers whether a reviewed change is eligible to land; it does not perform the merge:

```typescript
type ReviewDecision = "pending" | "changes-requested" | "approved";
type CheckStatus = "pending" | "failed" | "passed";

type ChangeReview = {
  pullRequest: string;
  decision: ReviewDecision;
  checks: CheckStatus;
};

function canLand(change: ChangeReview): boolean {
  return change.decision === "approved" && change.checks === "passed";
}

const proposedChange: ChangeReview = {
  pullRequest: "Fix empty search results",
  decision: "pending",
  checks: "passed",
};

const eligibleToLand = canLand(proposedChange); // false
```

Passing checks leaves this proposed change awaiting the human decision. A request for changes likewise keeps it in the execution-and-review loop.

Peter cites Paul Salt as already running a version of the manager pattern: a pinned chief-of-staff agent wakes every ten minutes to coordinate GitHub work. It creates threads in the sidebar so Paul can enter a particular workstream when it needs additional steering. The manager supplies continuity while preserving access to individual workers.

### A manager beyond the laptop

[23:34](https://www.youtube.com/watch?v=pMggiOb18tc&t=1414s)

A long-lived manager makes attachment to a single laptop feel increasingly arbitrary. Peter notes that Codex can already move work between hosts and that [OpenClaw has a gateway and nodes](https://docs.openclaw.ai/nodes), but he considers neither the final form. The thread should outlast the machine on which a person happens to be working.

![Black slide with centered white text reading “The thread is no longer bound to the machine,” alongside a small speaker inset.](https://ai.engineer/api/talk-essay-media/e3b9ef21cf657a182b33243a9e16c3451611b18d0c9197eaf1d91de70d4bd901)

“The thread is no longer bound to the machine.”

The desired agent can connect to the user’s machines and distinguish work suitable for the cloud from work requiring local access. Its manager should be reachable by text or Slack, rather than trapped inside an application session. Peter pushes the aspiration further: why not ask the agent to design the whole loop itself?

That system remains unfinished. Models are advancing faster than the harnesses and organizations built around them, leaving the design of those harnesses and organizations as the next engineering problem. Peter closes with the direction of travel: “The future is not twenty terminals. It’s better loops.”

## Resources

- [GPT-5.6 preview announcement](https://openai.com/index/previewing-gpt-5-6-sol/) — The June 2026 model-family announcement covers evaluations, token pricing and the planned Cerebras speed offering.
- [Inside the Codex agent loop](https://openai.com/index/unrolling-the-codex-agent-loop/) — An architectural explanation of Responses API interactions, context management and automatic compaction.
- [Codex source repository](https://github.com/openai/codex) — Source code and installation instructions for the Codex coding agent.
- [How the Codex App Server works](https://openai.com/index/unlocking-the-codex-harness/) — Explains how clients control Codex threads through a shared protocol, receive progress events and handle approvals.
- [Ultrafast mode preview](https://openai.com/index/previewing-ultrafast/) — The August 2026 preview describes Cerebras-powered GPT-5.6 Sol generating up to 750 output tokens per second.
- [OpenClaw nodes](https://docs.openclaw.ai/nodes) — Documentation for connecting machines to an OpenClaw Gateway, exposing capabilities and managing execution approvals.

## Slides

### World's Fair restoration

A scaffolded rotunda stands across a lagoon as the speaker compares the event to the World's Fair: both bring people together to build the future in public.

[0:53](https://www.youtube.com/watch?v=pMggiOb18tc&t=53s) [Historic photograph of a scaffolded rotunda across a lagoon.](https://assets.ai.engineer/sites/aiecode2025/sha256/4662848b6f558f30bc286a0b4531dfc3d4aec42e0ef076cf0f7248f0b81ec25a.webp)

Gordon Peters / San Francisco Chronicle, 1964

### Headlines about software engineering

Headlines question whether AI will make software engineers obsolete. The speaker challenges that argument, which assumes that abstracting away coding will eliminate the need for engineers.

[1:08](https://www.youtube.com/watch?v=pMggiOb18tc&t=68s) [A collage of headlines questioning the future of software engineers.](https://assets.ai.engineer/sites/aiecode2025/sha256/c46935d1d20f5523667f11171d20d199283a2bd4311750bfbcfd084c2cf262f6.webp)

Software engineering may no longer be a lifetime career (seangoedecke.com)
Hacker News

AI writes the code now. What’s left for software engineers?
The San Francisco Standard

‘It’s going to be painful for a lot of people’: Software engineers could go extinct this year, says Claude Code creator
FORTUNE

Coding After Coders: The End of Computer Programming as We Know It
The New York Times

Interface text:
498 points by movis 48 days ago | hide | past | favorite | 764 comments

### AI ate software

The speaker challenges predictions that engineers will disappear, framing AI’s impact on software as the next shift after software “ate the world.”

[1:24](https://www.youtube.com/watch?v=pMggiOb18tc&t=84s) [The words AI ate Software beneath a globe icon and circular outlines.](https://assets.ai.engineer/sites/aiecode2025/sha256/0dcb27229cb3bc9bf0c27bb62f3d72f2314749b16003ff1607a56c06380ba215.webp)

AI ate Software

### AI engineers are eating the world

The speaker argues that AI engineers are pushing the frontier and figuring out how new capabilities can reach everyone.

[1:28](https://www.youtube.com/watch?v=pMggiOb18tc&t=88s) [The words AI engineers are eating the world over concentric circles and a globe icon.](https://assets.ai.engineer/sites/aiecode2025/sha256/46820bd7ae92fd15b351f4abea2b9c744d277b309b02f470050e63eedf81d3a7.webp)

AI engineers are eating the world

### Historical engineering

A woman stands beside a stack of papers, alongside a mission control scene. The speaker frames AI engineering as a return to engineering’s roots: combining science, design, judgment and imagination to solve problems.

[1:41](https://www.youtube.com/watch?v=pMggiOb18tc&t=101s) [A woman beside a tall stack of papers and a crowded mission control room.](https://assets.ai.engineer/sites/aiecode2025/sha256/901eb83e8f83a6776337633e74a9cadfa4ebb67e6d68075c3ef757bbb38099c8.webp)

### OpenAI model and product timeline

A rising curve traces models and products from OpenAI’s founding to GPT-5.6. The speaker says model releases accelerated from roughly every 15 months to roughly every six weeks.

[2:14](https://www.youtube.com/watch?v=pMggiOb18tc&t=134s) [Timeline of OpenAI models and products from 2015 through GPT-5.6.](https://assets.ai.engineer/sites/aiecode2025/sha256/18a0ec12281908a75c29cd49b05b3522121c85ff0c174d25adc74413ea91a2f7.webp)

OpenAI Founded
GPT-1
GPT-2
GPT-3
GPT-4
Sora
GPT-4o
o1-preview
GPT-5
GPT-5.2
GPT-5.3
GPT-5.4
GPT-5.5
GPT-5.6
Sol · Terra · Luna

API
Custom Instructions
DALL-E 2
Voice
ChatGPT
DALL-E 3
Advanced Data Analysis
ChatGPT Enterprise
Custom GPTs
GPT Store
Memory
Ecosystem connectors
Advanced GPT workflows
Internal knowledge search
Data warehouse connectors
Codex CLI
Realtime API
Vision fine tuning
Canvas
Responses API
Codex
Deep research
Open models
Sora 2
Image Gen 1.5
Company knowledge
ChatGPT Atlas
ChatGPT for Excel
Codex app

Timeline: 2015, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025, 2026

### Complete the symbol

The 2000s example shows a code editor offering function suggestions, with getUser(id) selected and Tab available to accept it.

[2:41](https://www.youtube.com/watch?v=pMggiOb18tc&t=161s) [A 2000s code editor suggests symbols to complete a function call.](https://assets.ai.engineer/sites/aiecode2025/sha256/92c18d1906de69a96dcea9f91a1fe6988cc0dd3f512810678949f07cb7923828.webp)

2000s
Complete the symbol

function loadProfile(id) {
const user =
return user.pro[illegible]
}

ƒ getUser(id)
ƒ getUsers()
ƒ getUserById(id)

TAB TO ACCEPT

async function fetchProfile(id) {
const response = await fetch(`/api/users/${id}`)
[illegible]

### Generate the block

The 2022 example shows inline prediction suggesting a profile-fetching block, including an error check and JSON return, with four lines offered for acceptance by Tab.

[2:49](https://www.youtube.com/watch?v=pMggiOb18tc&t=169s) [A 2022 code editor suggests a block of code for fetching a user profile.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d4a09a362c71283e1058c2d40ad3f4b45cf266ea15ba69c4c54b1193c169b07.webp)

2022
Generate the block

async function fetchProfile(id) {
const response = await fetch(`/api/users/${id}`)
  if (!response.ok) throw new Error("User not found")
  return response.json()
}

Interface text:
TAB TO ACCEPT
TAB ACCEPT 4 LINES

function saveUser(user) {
db.users.insert(user)
⌘ K EDIT SELECTION
Validate the email and handle

### Draft the change

In 2023, Command-K let users ask a model to edit selected code. Here it proposes handling duplicate users; the speaker says it did not test the work.

[2:53](https://www.youtube.com/watch?v=pMggiOb18tc&t=173s) [A 2023 editor prompts for email validation and shows a proposed code change.](https://assets.ai.engineer/sites/aiecode2025/sha256/3a9fbf79d980ab70312f2affc9a1308d62fa8b29130b5a42368c55766e03d210.webp)

2023
Draft the change

12  function saveUser(user) {
13    db.users.insert(user)
14  }

⌘ K EDIT SELECTION
Validate the email and handle duplicate users gracefully.
GENERATE

− db.users.insert(user)
+ await validateAndSave(user)

Interface text:
TAB ACCEPT 4 LINES
AGENT PLAN
✓ Run user tests
✓ Inspect failure
TERMINAL
$ npm test
FAIL duplicate email returns 500

### Test the change

The 2024 example shows an agent investigating a duplicate-email test that returned 500 instead of 409, editing the code, and rerunning the tests successfully.

[2:57](https://www.youtube.com/watch?v=pMggiOb18tc&t=177s) [A 2024 agent plan and terminal show a failed test, an edit, and a passing test run.](https://assets.ai.engineer/sites/aiecode2025/sha256/7235ecee570c68d6ba3c933a68cc4c40d12beccbdb786aab76837458a20d4bcb.webp)

2024
Test the change

AGENT PLAN
✓ Run user tests
✓ Inspect failure
✓ Update error handling
✓ Rerun tests

TERMINAL
$ npm test
FAIL duplicate email returns 500
Expected 409, received 500
Agent: inspecting stack trace…
edited src/users.ts
$ npm test
PASS 48 tests

Other visible text:
− db.users.insert(user)
+ await validateAndSave(user)
$ codex exec "fix dup user registration"
1. inspected the registration flow
2. added duplicate-email handling
VERIFIED

### Delegate the task

The 2025 example delegates a duplicate-registration fix to Codex, which reports a 409 response, regression tests, 48 passing tests and a successful build, ready for review.

[3:01](https://www.youtube.com/watch?v=pMggiOb18tc&t=181s) [A 2025 Codex example summarizes a registration fix, passing tests, and a successful build.](https://assets.ai.engineer/sites/aiecode2025/sha256/2aa359d98f705a2171c800091af705ae37a677b60faba51afae3996492281299.webp)

2025
Delegate the task

$ codex exec "fix dup user registration"

1. inspected the registration flow
2. added duplicate-email handling
3. returned 409 for existing users
4. added regression tests

Ready to review.

VERIFIED
✓ 48 tests passed
✓ build succeeded

Faded text:
edited src/users.ts
$ npm test
PASS 48 tests

### Building a drone interface

At DevDay 2024, the presenter used o1 preview to build a drone interface. The model could write the code, but could not run it or verify its own work, leaving the live demo uncertain.

[3:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=189s) [A presenter shows a code editor and an assistant prompt for a drone interface.](https://assets.ai.engineer/sites/aiecode2025/sha256/50abfe03e4908cafede42a30cae84acf5718bc1082e0343e80c7899f02a0fbc4.webp)

CommandInterface.js

// src/CommandInterface.js
import React from 'react';

// Importing External Icons
import UpIcon from './icons/UpIcon';
import DownIcon from './icons/DownIcon';
import LeftIcon from './icons/LeftIcon';
import RightIcon from './icons/RightIcon';
import DirectionLeftIcon from './icons/DirectionLeftIcon';
import DirectionRightIcon from './icons/DirectionRightIcon';
import AltitudeUpIcon from './icons/AltitudeUpIcon';
import AltitudeDownIcon from './icons/AltitudeDownIcon';

const CommandInterface = ({ isFlying }) => {
  return (
    <div className="flex flex-col mt-4 space-y-4 items-center text-center">
      {/* Position Controls */}
      <h2 className="font-semibold">Position</h2>
      <div className="flex flex-col items-center space-y-4">
        <div className="relative w-60 h-40">
          {/* Up Button */}
          <button
            className="btn-command absolute top-0 left-1/2 transform -translate-x-1/2[illegible]
          >
            <UpIcon />
          </button>

          {/* Left Button */}
          <button
            className="btn-command absolute left-0 top-1/3 transform -translate-y-1/2[illegible]
          >
            <LeftIcon />

Chat prompt:
I have a Tello drone that I want to interface with in JavaScript, but not sure how to program it!

I built the interface in @App.js with some controls in @CommandInterface.js.

Help me build the whole Node @server.js to make it work, and interface it with all the buttons in the @CommandInterface.js by keeping my layout intact. Wire up the work you started in @video.js based on the sample video I sent you.

Let's use a WebSocket connection to send commands instantly. Do not change anything else in the HTML, just the click events.

Interface text:
TELLO-DEMO
backend
node_modules
server.js
video.js
frontend
public
src
icons
App.js
App.test.js
CommandInterface.js
FlightPaths.js
index.css
index.js
logo.svg
reportWebVitals.js
setupTests.js
VideoControls.js
VideoStream.js
.gitignore
package-lock.json
package.json
README.md
tailwind.config.js
CHAT
Cancel generation
Ask followup

### Drone control demonstration

The live drone demo worked even though the model could not run or verify its own code. The interface pairs a camera feed with flight and landing controls.

[3:40](https://www.youtube.com/watch?v=pMggiOb18tc&t=220s) [A projected drone interface shows a video feed and controls for position, direction, altitude and landing.](https://assets.ai.engineer/sites/aiecode2025/sha256/9d1ccb300bf1a6bc866ce8c2e9f29a299a847390e5b9169908ef0775049f95e9.webp)

Position
↑
← →
↓

Direction
↶ ↷

Altitude
⌃
⌄

Land
Battery Level: 89%

Stop Video

Interface text:
Arc  File  Edit  View  Spaces  Tabs  Archive  Extensions  Window  Help

### 2026 Codex releases

The speaker highlights the Codex app, Goal Mode and Remote from a selection of releases shipped so far in 2026, saying they change how work feels.

[4:06](https://www.youtube.com/watch?v=pMggiOb18tc&t=246s) [A 2026 slide lists Codex releases and features in three columns.](https://assets.ai.engineer/sites/aiecode2025/sha256/abd341e38ef24497d00fe45b66233d423940a3adea21f8cb422f629d093cedf2.webp)

2026

Team config
Codex app for macOS
GPT-5.3-Codex
GPT-5.3-Codex-Spark
Codex app for Windows
GPT-5.4
Fast mode
Automations GA

/goal
100+ plugins in Codex
Sub agents
Computer use
Image gen in Codex
Rich file previews
In-app browser use
Auto review

GPT-5.5
Codex Chrome extension
Codex on AWS
Codex mobile
Remote SSH
Deploy sites with Codex
Role-based plugins
In-app annotations

### Plan, Build, Review, Deploy

The speaker connects Codex to the whole workflow: understanding why work is needed helps agents begin more work, while review and deployment help them land it.

[4:19](https://www.youtube.com/watch?v=pMggiOb18tc&t=259s) [Four blue boxes show the workflow: Plan, Build, Review, and Deploy.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ef4cc78956b1a4c10e44a5dc854ea443014c86f8032813050be9bc91c9e99cc.webp)

Plan
Build
Review
Deploy

### AGI that benefits all of humanity

The speaker uses the mission to frame questions about what agents can do, where they run, and how people use them. The product goal is to empower engineers.

[5:59](https://www.youtube.com/watch?v=pMggiOb18tc&t=359s) [Gray text on black reads: AGI that benefits all of humanity.](https://assets.ai.engineer/sites/aiecode2025/sha256/54a79c3a18c1de1c142ce568d00eb7e5ce855d0d18fe36ccda3a92c3a6823fac.webp)

AGI that benefits all of humanity

### Chat and hands-on

The speaker envisions two ways to work with AI: chat for help anywhere, and a collaborative interface for inspecting, steering and shaping work yourself.

[6:45](https://www.youtube.com/watch?v=pMggiOb18tc&t=405s) [Black slide with the words “Chat” and “Hands on.”](https://assets.ai.engineer/sites/aiecode2025/sha256/9933d1128713ae6f20ae4cbaf2560c57f05d11b1854b9db93103f1b8b80e23a8.webp)

Chat

Hands on

### Working together at a workbench

The workbench illustrates the speaker’s team analogy: usually you talk and let teammates work; occasionally you dig into a problem together.

[7:11](https://www.youtube.com/watch?v=pMggiOb18tc&t=431s) [Black-and-white illustration of two people discussing machinery at a workbench.](https://assets.ai.engineer/sites/aiecode2025/sha256/3c60284aa77a7c5f212af801b3956280f5147c39704ac310d8529cb41d21082b.webp)

### Codex app prediction demo

In a France–Sweden prediction app, the score is selected and annotated with a request to animate it when updating. The demo shows how to point at a specific element and ask for a change.

[8:13](https://www.youtube.com/watch?v=pMggiOb18tc&t=493s) [Codex app displaying a France versus Sweden prediction interface with a score selected for annotation.](https://assets.ai.engineer/sites/aiecode2025/sha256/99fcbed69aa509febaed4c7430db0a3d737f179a36f1c8188b665a7694d685d7.webp)

PREDICTIONS

France vs Sweden
Tuesday, June 30 · 21:00 · Kansas City Stadium

France 3 – 0 Sweden
Animate score when updating!
Submit my prediction

Activity
Tibo — France 2 1 Sweden
Katia — France 3 0 Sweden
Alexander — France 1 0 Sweden
Thomas — France 2 0 Sweden
Peter — France 3 2 Sweden

All Matches
From the group stage to the final
104 matches
Upcoming  Groups  Knockout  Past
28 shown
TUESDAY, JUNE 30
ROUND OF 32
M77  France 3 – 0 Sweden  Submit

Standings
1 Tibo — 1,240 pts
2 Alexander — 1,180 pts
3 Romain — 1,095 pts
View full standings

Interface text:
Pronostic — Co[illegible]
localhost:3000
Annotating
Romain
New chat
Search
Sites
Plugins
Automations
Pinned
Chief of Staff
EOD Missed Replies
Morning Market Brief
Projects
AI Engineer World's Fair
Create GPT-7 demo
Write Goblin keynote
World Cup
Update game tabs and flagship
Improve World Cup app
Prepare World Cup Pronostic
Last Shot
Build penalty shootout game
Hudson Bank iOS
Run app in Simulator
OpenAI France
Chatbot Example
Playground
Settings
Latest turn
Ask for follow-up changes
5.6 Medium

### Build an open ecosystem

Codex uses the same models and Responses API available to developers. The speaker cites context compaction for long-running tasks as a capability added to the API.

[10:11](https://www.youtube.com/watch?v=pMggiOb18tc&t=611s) [Six layers from Models to Plugins beside the phrase “Build an open ecosystem.”](https://assets.ai.engineer/sites/aiecode2025/sha256/1de14428ad86da39815246631ced722ab84acc31a85652941326db402022bcd1.webp)

Build an open ecosystem

Plugins
App
App Server
Codex Harness
Responses API
Models

### Codex Harness

The open-source Codex Harness sits between the app server and Responses API. Developers can inspect or adapt it, and swap the default OpenAI models while keeping the agent loop.

[10:52](https://www.youtube.com/watch?v=pMggiOb18tc&t=652s) [The ecosystem stack with Codex Harness highlighted in blue.](https://assets.ai.engineer/sites/aiecode2025/sha256/20aeeb1bc9bc46954dff7970aabb72d0ce9c3d9b8b5ea6d0a975076ce7a520ac.webp)

Build an open ecosystem

Plugins
App
App Server
Codex Harness
Responses API
Models

### OpenCode example

OpenCode could inspect the Codex Harness reference implementation, reuse parts, or make different choices. The speaker cites ChatGPT sign-in as something the team wanted to learn from the code.

[11:16](https://www.youtube.com/watch?v=pMggiOb18tc&t=676s) [The ecosystem stack highlights Codex Harness beside an OpenCode website screenshot.](https://assets.ai.engineer/sites/aiecode2025/sha256/bc1ea0013f1110dbfff1d17642fe0558893b2ae2dbe399bbe989bab952dc1b17.webp)

Plugins
App
App Server
Codex Harness
Responses API
Models

New Desktop app available in beta on macOS, Windows, and Linux. Download now

The open source AI coding agent

Free models included or connect any model from any provider, including Claude, GPT, Gemini and more.

curl
npm
bun
brew
paru

curl -fsSL https://opencode.ai/install | bash

Interface text:
opencode
GitHub
Docs
Data
Zen
Go
Enterprise
Download

### App Server

App Server provides a unified way to control the Codex harness in apps. It is open source and is also the path OpenAI uses for its own products.

[12:02](https://www.youtube.com/watch?v=pMggiOb18tc&t=722s) [The ecosystem stack with App Server highlighted in blue.](https://assets.ai.engineer/sites/aiecode2025/sha256/b020077678910135a41a351594be556cbadd38fefe63f0c09050096179c02326.webp)

Build an open ecosystem

Plugins
App
App Server
Codex Harness
Responses API
Models

## Full transcript

[0:00](https://www.youtube.com/watch?v=pMggiOb18tc&t=0s) [on-hold music] Good morning, everyone. I'm Romain.

[0:17](https://www.youtube.com/watch?v=pMggiOb18tc&t=17s) Hey, everyone. I'm Alexander.

[0:19](https://www.youtube.com/watch?v=pMggiOb18tc&t=19s) Wow, this room is incredible. There's open-- there's over seven thousand AI engineers here today with us. And, you know, it's not just about who's talking about this technology. It's also about who's actually using it and pushing the frontier every day.

[0:34](https://www.youtube.com/watch?v=pMggiOb18tc&t=34s) So we couldn't be more proud to be here with all of you today. And when we were thinking about this event with Alex, we kept coming back to the World's Fair.

[0:42](https://www.youtube.com/watch?v=pMggiOb18tc&t=42s) And the World's Fair made actually the future visible to everyone by building it in public, you know? Ideas that previously sounded impossible were actually suddenly there. People could see them, they could walk into them, and they could even start to believe in them.

[0:57](https://www.youtube.com/watch?v=pMggiOb18tc&t=57s) And honestly, this event has the exact same energy. The future of engineering is not arriving from somewhere else. It's really being built here by the people in this room and much faster than most expected.

[1:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=69s) And that's why it's a little surprising that people keep saying that engineers are going away. The argument is that coding is, you know, abstracted away and therefore, eventually, we won't need engineers.

[1:18](https://www.youtube.com/watch?v=pMggiOb18tc&t=78s) Well, in fact, we think it's quite the opposite. You know, software ate the world, and then AI ate software. But now what we're here to say is that the AI engineers are eating the world.

[1:31](https://www.youtube.com/watch?v=pMggiOb18tc&t=91s) AI engineers are the people here pushing the frontier. Yes. [audience applauding]

[1:37](https://www.youtube.com/watch?v=pMggiOb18tc&t=97s) And you all are figuring out how this new capability can reach everyone. And there has never been a better time to be an engineer, in fact, because engineering was never about writing code.

[1:47](https://www.youtube.com/watch?v=pMggiOb18tc&t=107s) Engineering has always been about solving problems for yourself and for other people as well. It's about taking the latest science and combining it with design, with taste, with judgment, and most of all, imagination, to make something that people can actually use.

[2:02](https://www.youtube.com/watch?v=pMggiOb18tc&t=122s) And in that sense, it's not the end of engineering. We think it's a return to the roots of engineering.

[2:08](https://www.youtube.com/watch?v=pMggiOb18tc&t=128s) And the technology we're building on is accelerating, getting faster and faster. For example, we used to ship a new model every fifteen months or so, and now it's about roughly every six weeks.

[2:21](https://www.youtube.com/watch?v=pMggiOb18tc&t=141s) And in case you missed it, last week, we launched a preview of the 5.6 series, and we're super excited to get it into all of your hands. Now, building on top of all these models, the rate of product progress is relentless, and as a result, I don't have to tell you, engi-- the engineering feels completely different.

[2:40](https://www.youtube.com/watch?v=pMggiOb18tc&t=160s) So just to go over a couple years of what, for me, were successive, like, mind-blowing experiences. You know, obviously, for a long time we've had, you know, completion. And then we went to inline prediction.

[2:50](https://www.youtube.com/watch?v=pMggiOb18tc&t=170s) And then finally we had, then we had Command-K, where you could ask the model to make a change, but they wouldn't test the work. Then models started testing the work.

[2:57](https://www.youtube.com/watch?v=pMggiOb18tc&t=177s) And now we have models taking on long, hard goals until they're done. And for me, each of these phases, I remember the first time was just mind-blowing. And then obviously afterwards, you just get used to it, and you're trying to get your work done.

[3:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=189s) Yeah. In fact, like, I can't believe that build and test loop was not even part of the models just two years ago. This was a picture of me at DevDay 2024, and I used o1 in preview at the time to build a mini drone in, drone interface from scratch.

[3:22](https://www.youtube.com/watch?v=pMggiOb18tc&t=202s) And the slightly insane part is the model could not actually run the code or verify its own work. And I knew the demo would work most of the time, but surely not all of the time.

[3:31](https://www.youtube.com/watch?v=pMggiOb18tc&t=211s) So I had to cross my fingers. You can kinda see here that I was pretty nervous, but hey, that's me. I only do live demos, so I never know what's actually gonna happen each time.

[3:40](https://www.youtube.com/watch?v=pMggiOb18tc&t=220s) Luckily, it did work, and by DevDay of last year in 2025, I was confident enough now the models could test their own work to kind of control an entire camera system and lighting system live.

[3:50](https://www.youtube.com/watch?v=pMggiOb18tc&t=230s) But yeah, we've come a long way.

[3:51](https://www.youtube.com/watch?v=pMggiOb18tc&t=231s) Yeah. So we refer to Romain as the demo god. And, you know, before the demo, like, I'll ask him, "So hey, how often does demo work?" And he'll be like, "You know, three times out of four."

[3:59](https://www.youtube.com/watch?v=pMggiOb18tc&t=239s) And we're like, "All right. Good luck." [laughs] Um, obviously we've come miles since then. And this year alone has been crazy. So what we're putting up here are all the things that we've shipped so far-- and actually not even all.

[4:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=249s) A selection of the things that we've shipped so far this year. Uh, my favorite things that we've shipped are like Codex app, Goal Mode, Remote. These are things that really changes how it feels to do work.

[4:20](https://www.youtube.com/watch?v=pMggiOb18tc&t=260s) You know, obviously, we couldn't do these things if we didn't use Codex to build Codex. But I think to me, what is most interesting is that now Codex can do, and agents can do any task that you can do on your own computer.

[4:31](https://www.youtube.com/watch?v=pMggiOb18tc&t=271s) And so that means they're not just helping you with the coding, but they're helping you with what happens before the coding, and they're helping you with what happens after the coding.

[4:39](https://www.youtube.com/watch?v=pMggiOb18tc&t=279s) And this is really key, right? I think there's been a lot of talk, there will be a lot of talk today about loops. And if you can connect the agent to not only the work that you have to do, but why it has to be done, that's how you can get the agent to start to begin much

[4:50](https://www.youtube.com/watch?v=pMggiOb18tc&t=290s) more work. And then if you can connect it to what you do afterwards, review and deploy, that's how you help it land much more work. So with all of this, of course, we can move much faster.

[4:59](https://www.youtube.com/watch?v=pMggiOb18tc&t=299s) But to me, as a product person, the most exciting thing is actually that we make better decisions around what to build. For instance, we try, we prototype many more ideas, and we spend much more time with users.

[5:10](https://www.youtube.com/watch?v=pMggiOb18tc&t=310s) So yes, that's all of you. So wanted to pause and just give you all a big thank you, both for the love and the constructive feedback. I would say it's safe to say that we, Codex, and actually the entire industry wouldn't be here without you.

[5:25](https://www.youtube.com/watch?v=pMggiOb18tc&t=325s) Yeah. Thank you so much for all the feedback. We're constantly listening to all of you. [audience applauding] Thank you.

[5:30](https://www.youtube.com/watch?v=pMggiOb18tc&t=330s) Okay. So the models are getting really good. I would say if you pick like a medium-length computer task and you give me and the model the same amount of time to get that task done, probably, at least in my case, the model will do a better job than me for the average task.

[5:48](https://www.youtube.com/watch?v=pMggiOb18tc&t=348s) And so, okay, we're, we're getting these models, you know, in some ways they're smarter than us. They can do almost anything. How should we shape that? What should the products that we use feel like?

[5:57](https://www.youtube.com/watch?v=pMggiOb18tc&t=357s) And so to answer that, we look to our mission. The part of it here that I've got up is, you know, AGI that benefits all of humanity. And I think in order to do this, there are two main questions that I think about now.

[6:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=369s) One is, how do we set up the agents to actually do things in the world? So what can they do? You know, gradually agents are getting connected to more and more things.

[6:16](https://www.youtube.com/watch?v=pMggiOb18tc&t=376s) Then where do they run? More on that later. And then the other question is: how do we use these agents? For us, you know, what, what should the product feel like around them?

[6:24](https://www.youtube.com/watch?v=pMggiOb18tc&t=384s) And for us, the goal is squarely not to automate engineers. Instead, the, the product shape that we want is one that maximally empowers engineers. So, you know, if we think about what that product shape is, we actually think it's pretty simple.

[6:38](https://www.youtube.com/watch?v=pMggiOb18tc&t=398s) I, I read a lot of sci-fi and, you know, watch superhero movies, and I actually think that the, the simple ideas in there are approximately right. So there are two modalities, roughly.

[6:48](https://www.youtube.com/watch?v=pMggiOb18tc&t=408s) Chat. I actually think-- I know some people think chat is dead. I think chat is underrated. Uh, and some kind of hands-on experience. So what you want is a single entity that you can ask for help with anything, anywhere, and then you want a si-- a powerful, collaborative UI that you can use when you want to inspect,

[7:07](https://www.youtube.com/watch?v=pMggiOb18tc&t=427s) steer, or shape things yourself. And so I had Codex image gen me an illustration of this to help understand when you might wanna use these things. And so my analogy for you-- Yeah, I hope you like the image gen.

[7:19](https://www.youtube.com/watch?v=pMggiOb18tc&t=439s) Uh, my analogy for you would be it's just like working with a team. Most of the time, you're just talking about stuff, and your team is just doing stuff.

[7:27](https://www.youtube.com/watch?v=pMggiOb18tc&t=447s) You don't actually wanna watch over the shoulder or, like, have to walk over to the workbench of your teammate for every single unit of work. Mostly, you just wanna talk and let them cook.

[7:35](https://www.youtube.com/watch?v=pMggiOb18tc&t=455s) And then every now and then, you wanna dig in and really dig in all the way to the weeds of things and dig into that problem together. And for us, as we build product, we have this idea that we want to make it so that you can retain this feeling of mastery of the work that we're doing,

[7:49](https://www.youtube.com/watch?v=pMggiOb18tc&t=469s) because that's really powerful. We don't want to make it feel like, actually, it's really hard to, like, get to the details and, like, you know, disassemble the hardware in this case.

[7:57](https://www.youtube.com/watch?v=pMggiOb18tc&t=477s) So the way that we're bringing to this to life is just the beginning, but this is why we built the Codex app. You get a very simple chat interface that you can use for coding and for anything else, and, you know, you can have a conversation and then go as deep as you want.

[8:10](https://www.youtube.com/watch?v=pMggiOb18tc&t=490s) So in the case here, we have Romain's predicted score of this upcoming World Cup match.

[8:15](https://www.youtube.com/watch?v=pMggiOb18tc&t=495s) I hope I'm right. [chuckles] I hope I'm right. We'll see. [chuckles]

[8:19](https://www.youtube.com/watch?v=pMggiOb18tc&t=499s) Okay. Um, and what you can do here is you could go in and you can point at a very specific thing and say, "Hey, I want you to make this change," or you can make this change yourself.

[8:27](https://www.youtube.com/watch?v=pMggiOb18tc&t=507s) And a fun story here is that actually, I remember pitching some of you who I know are in the audience, uh, this idea before we started, and I was told squarely, like, "We-- I will never use such a tool.

[8:38](https://www.youtube.com/watch?v=pMggiOb18tc&t=518s) I will never leave my terminal, uh, or Vim or Emacs." Um, but actually, those people are now using it. And even internally, like, within our team, there were a lot of questions like, "Why should we build this?"

[8:49](https://www.youtube.com/watch?v=pMggiOb18tc&t=529s) People love the CLI, they love the IDE, and it's a little subtle, but our take is that you can't really build that collaborative interface for any kind of work in a CLI.

[8:58](https://www.youtube.com/watch?v=pMggiOb18tc&t=538s) It's mostly chat. And then in IDE, the order is wrong, so you're starting with the code, but now it's time to transition to, like, working with teammates where you chat first, then you dig in when you need it.

[9:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=549s) Totally. And we're moving really fast on this, on the product surface and the model layer, of course, but we're also trying to keep pace with all of you, right?

[9:17](https://www.youtube.com/watch?v=pMggiOb18tc&t=557s) Honestly, half the time I open X, I see someone in this room doing something that I had not realized Codex could actually do. And honestly, this is what pioneers do.

[9:26](https://www.youtube.com/watch?v=pMggiOb18tc&t=566s) You guys experiment, you set up tools for yourself, for your team, and in turn, we get inspired. We learn from you, and eventually, everyone benefits. And so we are helping-- uh, uh, you are helping us figure out, like, what to, uh, what to build next and also what the future of engineering should look like.

[9:42](https://www.youtube.com/watch?v=pMggiOb18tc&t=582s) But for that to work, one thing that we, we really care about is that Codex cannot be a closed product that only OpenAI can improve. So we've intentionally designed Codex as a set of layers that anyone can build on.

[9:54](https://www.youtube.com/watch?v=pMggiOb18tc&t=594s) And we wanna show you a little bit of that stack today and how it, it, it manifests.

[9:59](https://www.youtube.com/watch?v=pMggiOb18tc&t=599s) First, it starts with the model, and Alexander showed how quickly we're progressing on models. And you guys use these models through the Responses API, and guess what? This is how we build the Codex app, right?

[10:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=609s) We use the same models and through the same API. And we actually are building on the same thing that we give to developers, and when Codex needs something new, we always try to bake it into the API first so you can benefit as well.

[10:22](https://www.youtube.com/watch?v=pMggiOb18tc&t=622s) One example recently was compaction. Codex needed a way to compact long contexts for long-running tasks, and so we built that into the API. So that means your agents can use the same primitives that we build for ourselves.

[10:35](https://www.youtube.com/watch?v=pMggiOb18tc&t=635s) Moving on to the next layer, the Codex Harness is also open source, so you can inspect it, you can fork it, you can adapt it, and we also took the same approach with AGENTS.md.

[10:45](https://www.youtube.com/watch?v=pMggiOb18tc&t=645s) Instead of reinventing a new file format, uh, for Codex for, to follow instructions, we thought, let's pick a name that other agents can actually use as well. The models are the de-default in the, in the harness, the models from OpenAI, but they are not hard-coded in there, so if you wanna use an open model and keep the

[11:01](https://www.youtube.com/watch?v=pMggiOb18tc&t=661s) same agent loop, you can. And we also bring this Codex Harness into the post-training process of our models, so that means the models can learn to call tools and navigate an environment that's actually something that's open source.

[11:15](https://www.youtube.com/watch?v=pMggiOb18tc&t=675s) Now, take the OpenCode team, for instance. They actually were able to inspect how we have this, like, reference implementation, and they could reuse the parts that make sense to them or change entirely all the rest and make different choices.

[11:28](https://www.youtube.com/watch?v=pMggiOb18tc&t=688s) I know, for instance, they were trying to see how we did, like, sign-in with ChatGPT, and so they could look at the code a-and-and learn from it. And we think it's better than having developers reverse engineering how we build, uh, w- and, and how we launch.

[11:43](https://www.youtube.com/watch?v=pMggiOb18tc&t=703s) But now let's say, speaking of subscriptions, that we wanna go a level higher, and how you bring this harness into an app, and how do you let people sign in with their existing Codex subscription, for instance?

[11:53](https://www.youtube.com/watch?v=pMggiOb18tc&t=713s) Well, it turns out we had the same problem ourselves 'cause we wanted to build a VS Code extension and the Codex app, and we wanted to have a unified way to, like, actually control this harness.

[12:02](https://www.youtube.com/watch?v=pMggiOb18tc&t=722s) So we built app-server, and we also made that open source. And the app-server is not kind of a, a community adapter. It's really the path that we use for our own products, and you can use it too.

[12:13](https://www.youtube.com/watch?v=pMggiOb18tc&t=733s) Uh, Thomas, for instance, here, uh, AKA [REDACTED:username] on X, uh, he built his own native app for, uh, Codex called Codex Monitor before we even launched the Codex app, 'cause he could build that, uh, using the App Server.

[12:25](https://www.youtube.com/watch?v=pMggiOb18tc&t=745s) And now he works on our team, and he actually built, uh, Codex, uh, for iOS.

[12:31](https://www.youtube.com/watch?v=pMggiOb18tc&t=751s) And moving up the stack at the app layer, we also wanna make sure that innovation is not blocked on our own ideas. And so we build extensible primitives here, uh, like the in-app browser that we showed on the screen and plugins.

[12:44](https://www.youtube.com/watch?v=pMggiOb18tc&t=764s) So if you take, for instance, browser_use and computer_use, these were built as plugins using the same extension points that we have available for, for all of you. And lastly, we also recently built role-specific plugins for Codex, say, to make it easier to, to customize for people who work in data science or design, for instance.

[13:04](https://www.youtube.com/watch?v=pMggiOb18tc&t=784s) And these plugins are also open source, so you can see under the hood and get inspired from them if that's useful. Our goal is really to keep making this as open and flexible as we can, and the best part is people can use their existing subscription in more and more places, from OpenCode, Pi, Droid, OpenClaw, to

[13:21](https://www.youtube.com/watch?v=pMggiOb18tc&t=801s) even Xcode and JetBrains as IDEs. And you can see how they're becoming quite a meaningful part of how people use these tools, and that's really why we wanna care about building this open ecosystem with all of you.

[13:33](https://www.youtube.com/watch?v=pMggiOb18tc&t=813s) So really, if there's one thing I want you to take away from this section and this stack, it's this: we're not building one system for OpenAI and a second system that's simplified for developers.

[13:43](https://www.youtube.com/watch?v=pMggiOb18tc&t=823s) At every layer, we actually use the thing that we give to you. And we want to thank all of you, 'cause every time you fork the harness, every time you find the edge of capabilities of the models, it means we get to learn and improve.

[13:55](https://www.youtube.com/watch?v=pMggiOb18tc&t=835s) And honestly, with seven thousand of the finest AI engineers in this room today, I'm confident that all of you will define a lot of how we, uh, will experience AI and how the world will experience AI in the future.

[14:07](https://www.youtube.com/watch?v=pMggiOb18tc&t=847s) So thank you. [audience applauding]

[14:14](https://www.youtube.com/watch?v=pMggiOb18tc&t=854s) I wanna give a shout-out to whoever over there is injecting energy. [laughs] That's you? Okay, thank you so much. Um, so with all of your help, we are making agents explosively useful.

[14:25](https://www.youtube.com/watch?v=pMggiOb18tc&t=865s) Um, and so now the question is: how do we get value out of them? And, you know, that's not token maxing. We have a term for this that maybe you use as well.

[14:34](https://www.youtube.com/watch?v=pMggiOb18tc&t=874s) I don't know, is it on screen? Value maxing. So, you know, when we talk to engineering leaders, most of the conversation is about some themes relating to the idea of value maxing.

[14:43](https://www.youtube.com/watch?v=pMggiOb18tc&t=883s) So we're gonna walk you through a few common topics that come up, some things where we've already made a lot of progress, and some things where actually there's a lot more progress to still be made.

[14:51](https://www.youtube.com/watch?v=pMggiOb18tc&t=891s) So the first one of these is cost efficiency. Everyone wants frontier intelligence. Pick your favorite eval. You want the best model. So with Terminal-Bench here, for instance, that's GPT-5.6 Sol, and like I said, we can't wait for you to have it.

[15:07](https://www.youtube.com/watch?v=pMggiOb18tc&t=907s) But okay, you also want as much intelligence as you can get, and that's where efficiency comes in. Cost efficiency has been a focus for us for quite some time, and the results are continuing to pay off.

[15:18](https://www.youtube.com/watch?v=pMggiOb18tc&t=918s) So for example, GPT-5.6 Terra, I think it's in like dark blue in there, brings GPT-5.5-level intelligence but at half the cost. And Luna there beats some pretty notable models in this eval, but at only $1 per million input tokens and $6 per million output tokens.

[15:37](https://www.youtube.com/watch?v=pMggiOb18tc&t=937s) I'll leave it up to you to compare those costs, but that is insane value.

[15:41](https://www.youtube.com/watch?v=pMggiOb18tc&t=941s) Yeah, we re- we really can't wait to, uh, to see all of you build, uh, with GPT-5.6 and these new family of models. Now, the next thing I wanna touch on is speed, right?

[15:49](https://www.youtube.com/watch?v=pMggiOb18tc&t=949s) GPT-5.3-Codex-Spark showed you what speed can unlock, but we also know that you all want frontier intelligence. You don't wanna have a model that's, like, not as great as what you can operate at the very best.

[16:01](https://www.youtube.com/watch?v=pMggiOb18tc&t=961s) Well, this is GPT-5.6 Sol running on Cerebras, the frontier intelligence at now 750 tokens a second. We can't wait to see what you can build with this next month.

[16:12](https://www.youtube.com/watch?v=pMggiOb18tc&t=972s) And honestly, to put that in perspective, this is kind of like having a pretty substantial PR written in like 10 seconds. And it's not just about getting one answer faster, right?

[16:22](https://www.youtube.com/watch?v=pMggiOb18tc&t=982s) It's about what can you do with that speed. You can think about an agent taking different approaches, maybe like five or six in parallel, maybe like, you know, coming back and picking the best one in the time it would have taken to not even generate just one.

[16:36](https://www.youtube.com/watch?v=pMggiOb18tc&t=996s) So we really can't wait to see what that can unlock when you have frontier intelligence, the very best at that speed. It really starts to feel less like waiting for an AI to respond and much more like a coworker that's, like, already showing you the results as it goes.

[16:51](https://www.youtube.com/watch?v=pMggiOb18tc&t=1011s) Speaking of working with coworkers, um, can I get a show of hands, who, who is familiar with this kind of sight in offices?

[16:59](https://www.youtube.com/watch?v=pMggiOb18tc&t=1019s) Okay. Okay, wow, a lot of you are very well-behaved. At least some people up front. Um, so yeah. A lot of people are keeping their laptops open so that agents can keep working.

[17:09](https://www.youtube.com/watch?v=pMggiOb18tc&t=1029s) And this is funny, but, you know, what we really want is to be able to shut our computers, um, and we wanna be able to run many tasks in parallel, isolated on their own box.

[17:20](https://www.youtube.com/watch?v=pMggiOb18tc&t=1040s) Now, we've been actually aiming at this from the start. Our first major launch was Codex Cloud, and it is due for some major upgrades coming soon. But better yet, as we think about this, the future shouldn't have this awkward distinction between, like, a local task and a cloud task, and you have to decide where to run everything.

[17:40](https://www.youtube.com/watch?v=pMggiOb18tc&t=1060s) Really, what you should have is kinda going back to what I was saying earlier. You should just have an agent, you talk to it wherever, whenever, about anything, and it should figure out, "Okay, what do I need to do?

[17:50](https://www.youtube.com/watch?v=pMggiOb18tc&t=1070s) Which environment is right for my work?" And use whatever is available.

[17:53](https://www.youtube.com/watch?v=pMggiOb18tc&t=1073s) In fact, Theo made this prediction over the weekend on this very topic, and it's a pretty acute tweet. Like, Alex, what do you think? Sooner or later than six months?

[18:02](https://www.youtube.com/watch?v=pMggiOb18tc&t=1082s) I think the-- not, maybe not the exact details, but the vibe of this tweet, much sooner than six months.

[18:07](https://www.youtube.com/watch?v=pMggiOb18tc&t=1087s) Yeah, I mean, at, at the pace at which everything is go- is going, I would not be surprised if it's sooner indeed. Um, well, so now- You might be wondering, where's the live demo today?

[18:17](https://www.youtube.com/watch?v=pMggiOb18tc&t=1097s) Uh, well, for this AI Engineer, we wanted to do something a little different this time around. And we think it's a very unique moment for all of us to kinda reimagine how we work and how we build.

[18:29](https://www.youtube.com/watch?v=pMggiOb18tc&t=1109s) And so we wanted to bring a special guest who has bent what's possible with agents and really has pushed us to be more AGI-pilled, uh, at OpenAI. So with that, please welcome to the stage, the Clawfather, Peter Steinberger. [audience cheering and applauding]

[18:50](https://www.youtube.com/watch?v=pMggiOb18tc&t=1130s) Peter, take it away.

[18:51](https://www.youtube.com/watch?v=pMggiOb18tc&t=1131s) Thank you, all. [audience cheering] Good morning, everyone. You know, I love this picture because it reminds me just how much has changed in a few months. I was juggling ten or more terminal windows, always waiting for one of them to finish so I could steer the agent and queue new work.

[19:16](https://www.youtube.com/watch?v=pMggiOb18tc&t=1156s) In, in January, that felt like peak productivity. Today, it feels a little bit silly. I thought I was orchestrating. Really, I was polling. I was the scheduler, the router, and the memory.

[19:33](https://www.youtube.com/watch?v=pMggiOb18tc&t=1173s) You know, at first, I paired with one agent. With ten terminals, I was no longer pairing. I was managing ten direct reports. Now, I mostly talk to a long-running manager, which delegates work to a team.

[19:50](https://www.youtube.com/watch?v=pMggiOb18tc&t=1190s) For tricky work, I can still drop down and pair directly with a worker, but my default changed. I manage the manager of a small company of agents.

[20:02](https://www.youtube.com/watch?v=pMggiOb18tc&t=1202s) Three changes made that possible. Number one, server-side compaction made long-running tasks reliable enough that I stopped optimizing around fresh se- sessions.

[20:16](https://www.youtube.com/watch?v=pMggiOb18tc&t=1216s) Coordination lets one thread create and steer the right projects. And third, automation can wake the same manager when something happens. So we have persistent context, delegation, and triggers.

[20:32](https://www.youtube.com/watch?v=pMggiOb18tc&t=1232s) There's your loop. And once the loop starts working, you discover the next problem. The bottleneck keeps moving. You know, last year, I was primarily constrained by tokens.

[20:49](https://www.youtube.com/watch?v=pMggiOb18tc&t=1249s) Now, I fixed that by joining OpenAI. [audience laughing] I know, I know, this strategy does not scale.

[20:58](https://www.youtube.com/watch?v=pMggiOb18tc&t=1258s) Then my constraint shifted to token, uh, compute.

[21:04](https://www.youtube.com/watch?v=pMggiOb18tc&t=1264s) All these threads run at the same time, and my MacBook starts sounding like a jet engine. That's mostly fixed by using test boxes, so agents can run tests on a separate machine.

[21:19](https://www.youtube.com/watch?v=pMggiOb18tc&t=1279s) Now, I'm primarily constrained by attention. And unlike tokens or compute, I can't simply add more of it. So the most important skill is today is deciding where to spend it.

[21:36](https://www.youtube.com/watch?v=pMggiOb18tc&t=1296s) Are you still staring at the agent while the code flies by?

[21:41](https://www.youtube.com/watch?v=pMggiOb18tc&t=1301s) Yeah. [laughs]

[21:43](https://www.youtube.com/watch?v=pMggiOb18tc&t=1303s) I know, I know it's, it, it feels cool, but- [laughing]

[21:47](https://www.youtube.com/watch?v=pMggiOb18tc&t=1307s) With the earlier models, this was necessary. You know, you, you, you, you see the agent going a direction you don't like, you hit Escape, you steer it, you steer it back.

[21:57](https://www.youtube.com/watch?v=pMggiOb18tc&t=1317s) But the latest generation of models is so good at understanding intent that it's a little bit of a waste of time to watch the agent generate code.

[22:08](https://www.youtube.com/watch?v=pMggiOb18tc&t=1328s) Imagine someone files an issue on one of my open source projects. The manager wakes up, reads it against the project's goals, notes, and vision, and decides whether it might be a fit.

[22:23](https://www.youtube.com/watch?v=pMggiOb18tc&t=1343s) If it does, it creates a worker. That worker investigates, implements the change, runs the tests, and another agent can review the result. I don't need to watch those agents work or consume every intermediary message.

[22:43](https://www.youtube.com/watch?v=pMggiOb18tc&t=1363s) When the manager needs me, it returns a PR, the original issue, the proposed diff, maybe a video or even a, a running build I can VNC into. I review once, I re- leave a note, I maybe approve.

[23:00](https://www.youtube.com/watch?v=pMggiOb18tc&t=1380s) The loop continues, and it can land after the checks pass. The agent runs the inner execution loop. I set the direction, and I make decisions in the outer loop.

[23:14](https://www.youtube.com/watch?v=pMggiOb18tc&t=1394s) You know, Paul, Paul Salt is already running a version of this. He pinned his chief of staff. It wakes up every ten minutes, and it coordinates his GitHub work.

[23:26](https://www.youtube.com/watch?v=pMggiOb18tc&t=1406s) The agent creates threads in the sidebar so Paul can jump in whenever the work needs additional steering.

[23:34](https://www.youtube.com/watch?v=pMggiOb18tc&t=1414s) And you know, once the manager is long-lived, tying it to a laptop just feels wrong. Codex can already move work between hosts. OpenClaw has a gateway and nodes. But neither feels like the final form.

[23:54](https://www.youtube.com/watch?v=pMggiOb18tc&t=1434s) I don't even wanna think where I work. My agent should be able to connect to any of my machines. They should know which work can be done

[24:07](https://www.youtube.com/watch?v=pMggiOb18tc&t=1447s) in the cloud or which work requires my local machine.

[24:13](https://www.youtube.com/watch?v=pMggiOb18tc&t=1453s) The manager shouldn't be a session trapped inside your app. It should be an agent that I can text, steer from Slack, or hear from wherever I am. Really, why can't I talk to my agent and have it design the whole loop for me?

[24:32](https://www.youtube.com/watch?v=pMggiOb18tc&t=1472s) We haven't solved that yet. Models are advancing faster than the harnesses and organizations around them. Designing those things is the next engineering problem, and that's where all of you come in.

[24:49](https://www.youtube.com/watch?v=pMggiOb18tc&t=1489s) The future is not twenty terminals. It's better loops. Let's build them. Thank you. [audience applauding] [outro music]
