Why humans are AI's biggest bottleneck (and what's coming in 2026) | Alexander Embiricos (OpenAI)

Codex is envisioned not merely as a coding tool, but as the beginning of a software engineering teammate. Today, it operates like a brilliant intern who is incredibly capable but lacks context—it “refuses to read Slack” and “doesn’t check DataDog unless you ask it to.” The ultimate goal is to evolve this into a proactive agent that participates across the entire software development lifecycle, from ideation and planning to validation, deployment, and maintenance.

The Vision of Proactive Assistance

A major goal for Codex is to achieve proactivity. Current AI products are difficult to use effectively because they are reactive; a user must consciously decide when and how to prompt the model for help. An intelligent entity could potentially provide value thousands of times per day, but users only prompt them a few dozen times. The future is an AI teammate that is helpful by default, anticipating needs and offering assistance without being explicitly asked.

This vision extends beyond just coding. The core learning is that for an AI to do things in the world, it is most effective when it can use a computer. The best way for an AI to use a computer is by writing code. Therefore, any powerful agent, even for non-technical users, should be a coding agent at its core. Coding becomes a fundamental competency for any “super assistant,” including ChatGPT.

Unlocking 20x Growth

Codex has seen explosive—20x—growth since August, serving trillions of tokens weekly. This was unlocked by a key product shift. The initial version of Codex was a cloud-based agent that users could delegate tasks to asynchronously. While powerful and heavily used within OpenAI, it was too far ahead of the curve for the general market, requiring complex environment setup and a new way of thinking.

The key unlock was meeting developers where they are.

• Integrated Experience: The team launched an IDE extension (for VS Code) and a CLI tool that works interactively on a user’s local machine. This removed the friction of setup and allowed developers to get value immediately within their existing workflows.
• The “Teammate” On-ramp: This interactive pairing model serves as an on-ramp. As a user works with Codex, they naturally configure it and provide it with context (e.g., permissions, commands), gradually building the trust and setup required for more autonomous, delegated tasks down the line.

This progress is also driven by a tightly integrated product and research team that iterates on the entire agent stack simultaneously:

1. Model: Continuously improving the core intelligence, like the recent GPT-5.11 Codex Max.
2. API: Building features that expose new model capabilities.
3. Harness: The client-side software (IDE extension, CLI) that interacts with the API.

A feature like compaction, which allows Codex to run for extended periods (e.g., 24+ hours) without exceeding its context window, required innovation at all three layers of this stack.

The Shifting Bottleneck: From Writing to Reviewing

With AI generating vast amounts of code, the primary bottleneck in software development is shifting from writing code to reviewing it. While writing code is often a creative and enjoyable task for engineers, reviewing AI-generated code can be less engaging.

The focus for the Codex team is now on making this new reality more empowering. This involves:

• Building a Better Review Experience: Shipping features that help developers build confidence in the AI-written code more quickly.
• Improving Self-Validation: Enabling the agent to better validate its own work by running tests and previewing changes.
• Empowering the Human: Making micro-decisions in the UI that prioritize human understanding, such as showing a visual preview of a web page change before showing the code diff.

Real-World Impact at OpenAI Speed

Codex has become a massive accelerator for OpenAI’s internal teams, compressing the talent stack and blurring the lines between roles like product, design, and engineering.

• The Sora Android App: The team built and shipped a completely new, number-one-ranked app in a stunningly short timeframe.
  • 18 days from zero to an internal employee launch.
  • 28 days total to public launch.
  • This was accomplished by a small team of two or three engineers. Codex was particularly effective at porting logic from the existing iOS app to the new Android codebase.
• The Atlas Browser: For complex features that would have previously taken 2-3 engineers 2-3 weeks, the team now sees one engineer completing the work in one week.
• Ubiquitous “Throwaway” Code: Codex makes it trivial to write code for tasks that were previously too annoying to justify, such as building an interactive data viewer for a one-off analysis or creating a custom animation editor to design a single animation.

The Human Bottleneck and the Path to AGI

When considering the timeline to AGI, the most underappreciated limiting factor is not model capability, but human interaction speed. The bottleneck is the time it takes for a human to type prompts and, more importantly, to manually validate all the work the AI produces.

The path forward involves rebuilding systems to make the agent more autonomous and “default useful.” We will see productivity “hockey stick” curves emerge not as a single binary event, but progressively. Startups building on modern stacks will experience it first, followed by larger enterprises that must gradually update legacy systems to allow agents to handle more work end-to-end. The feedback loop from this accelerated productivity flowing back into AI research labs will be a key driver toward AGI.

• Tags:
• AI Agents
• Software Engineering
• Product Management
• Developer Productivity
• OpenAI
• AGI
• Codex