# The Golden Age of AI Engineering Alexander Embiricos, Romain Huet & Peter Steinberger, OpenAI | AI Engineer World's Fair 2026 | 25:13 Source: https://www.youtube.com/watch?v=pMggiOb18tc Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/the-golden-age-of-ai-engineering Published: 2026-07-09 Tags: agents, coding-agents, human-in-the-loop, multi-agent, open-source ## TL;DR - AI engineering is becoming more valuable as models take on implementation work and engineers spend more time solving problems, making decisions, and shaping products. - Codex is built from the same Responses API, open-source harness, AGENTS.md format, app server, and plugins that OpenAI makes available to developers. - The next step is managing long-running agent loops, where people set direction and review results while agents investigate issues, write code, run tests, and prepare pull requests. ## Summary Alexander Embiricos and Romain Huet describe how quickly AI engineering has changed, from models that generated code without testing it to agents that can pursue long-running tasks. They argue that this does not remove the need for engineers. It gives engineers more room to solve problems, exercise judgment, prototype ideas, and work directly with users. They explain Codex's product shape as a mix of conversation and a hands-on interface, with the user able to inspect and steer work when needed. They also describe an open stack built from the Responses API, an open-source harness, AGENTS.md, an app server, and plugins. The talk then turns to cost, speed, and where agents run. Peter Steinberger describes moving from ten terminal sessions to a long-running manager that delegates work to agents. His example shows a manager turning an open-source issue into a tested pull request while the human reviews only the decisions that need attention. ## Key ideas ### AI engineering shifts attention from writing code to solving problems [01:10](https://www.youtube.com/watch?v=pMggiOb18tc&t=70s) Alexander Embiricos argues that engineers are not going away as coding becomes more abstracted. Engineering, in his view, has always involved solving problems and combining science with design, taste, judgment, and imagination. AI engineers are figuring out how new capabilities reach other people. He describes this as a return to engineering's roots rather than its end. The claim matters because the work changes even when models write more of the implementation. Engineers still decide what to build, how it should work, and whether it is useful. ### Models moved from code completion to testing and long-running goals [02:14](https://www.youtube.com/watch?v=pMggiOb18tc&t=134s) The speakers describe several stages in their recent experience: completion, inline prediction, command-based edits, models that test their work, and models that pursue difficult goals until they finish. Romain Huet recalls using an o1 preview model at Dev Day 2024 to build a small drone interface. The model could not run the code or verify the result, so Huet had to hope the live demo worked. By Dev Day 2025, he trusted the model enough to control a camera and lighting system live because it could test its own work. ### Agents become more useful when they connect the whole work loop [04:03](https://www.youtube.com/watch?v=pMggiOb18tc&t=243s) Huet says Codex and other agents can now handle tasks that a person can do on a computer. Their role can include the work before coding, the coding itself, and the work after coding, such as review and deployment. Connecting an agent to the reason a task exists helps it begin more work. Connecting it to the review and deployment steps helps it finish more work. Embiricos also says this changes product decisions because the team can prototype more ideas and spend more time with users. ### The desired product combines conversation with hands-on control [05:30](https://www.youtube.com/watch?v=pMggiOb18tc&t=330s) Embiricos describes two ways of working with an agent. One is chat, where a person asks for help and lets the agent work. The other is a collaborative interface for inspecting, steering, and shaping the result. He compares this to working with a team: people usually talk while teammates work, then dive into details when a problem needs joint attention. The Codex app follows this idea with a chat interface that lets users point to a specific part of a result, ask for a change, or make the change themselves. ### Codex exposes the same building blocks that OpenAI uses internally [09:44](https://www.youtube.com/watch?v=pMggiOb18tc&t=584s) Huet says OpenAI uses the Responses API to build the Codex app, and tries to add capabilities to the API before using them in Codex. He gives context compaction as an example for long-running tasks. The Codex harness is open source, can be inspected or forked, and is not hard-coded to OpenAI models. AGENTS.md provides a shared instruction-file format that other agents can use. The app server is also open source and powers OpenAI's own products, including the connection between the harness and applications such as the VS Code extension and Codex app. ### Cost and inference speed change what an agent can attempt [14:20](https://www.youtube.com/watch?v=pMggiOb18tc&t=860s) The speakers frame model progress around getting useful value from agents. They cite GPT 5.6 Terra as offering GPT 5.5-level intelligence at half the cost, and say Luna reaches $1 per million input tokens and $6 per million output tokens in the example they show. They also describe GPT 5.6 Soul running on Cerebras at 750 tokens per second. At that speed, Huet says a substantial pull request could be written in about ten seconds. An agent could use the time to try several approaches in parallel and choose among them. ### The local and cloud boundary should disappear for users [16:51](https://www.youtube.com/watch?v=pMggiOb18tc&t=1011s) Huet says people currently keep computers open so agents can continue working, but the intended experience is different. Users should be able to shut their computers and run many isolated tasks in parallel. Instead of deciding whether a task is local or in the cloud, a person should talk to an agent and let it choose the right environment. The agent would use whatever machine or cloud resource the work requires. Huet presents this as a direction for Codex Cloud and for future agent products. ### Long-running managers move humans from orchestration to decisions [18:56](https://www.youtube.com/watch?v=pMggiOb18tc&t=1136s) Peter Steinberger describes replacing ten terminal windows with a long-running manager that delegates to a team of agents. Three changes made this practical: server-side compaction for persistent context, coordination so one thread can create and steer projects, and automation that wakes the manager when events occur. His constraint then moved from tokens to compute and finally to human attention. In his open-source example, a manager reads an issue, decides whether it fits the project's goals, creates a worker, oversees implementation and tests, and returns a pull request for human review. ## Notable quotes - "Engineering has always been about solving problems for yourself and for other people as well." (01:31) - "We want to make it so that you can retain this feeling of mastery of the work that we're doing." (07:42) - "I thought I was orchestrating. Really, I was polling." (19:14) - "The future is not 20 terminals. It's better loops." (24:32) ## Tools & references mentioned - OpenAI - Codex - o1 preview - GPT 5.6 - GPT 5.6 Terra - GPT 5.6 Soul - GPT 5.5 - GPT 5.3 - Cerebras - Responses API - Codex harness - AGENTS.md - Codex app - Codex Cloud - Codex Monitor - Codex for iOS - Open Code - Pi - Droids - Open Claw - Xcode - JetBrains - VS Code - Paul - Theo ## Who should watch - You are building developer tools around coding agents and need to decide how much of the agent loop to expose to users. - Your team is choosing between a terminal-first interface and a collaborative product where people can inspect and steer work. - You want a practical model for running long-lived agents across local machines and cloud test environments.