Building and Shipping Codex: An AI-Powered Coding Agent Platform

openai · Tech · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.5 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: AI coding agent platform

OpenAI needed Codex to support both rapid interactive coding and longer-running delegated software work, while serving CLI, IDE, standalone-app, local, cloud, power-user, beginner, internal, and external developer workflows from a shared agent platform.

Constraints:

Architecture

Codex is built around a shared open-source Rust harness used by the CLI, IDE extension, and standalone app. The product routes work across model tiers: GPT 5.4 for complex migrations and large-codebase tasks, Codex Spark for fast interactive iteration, and intermediate fast modes for speed-quality control. The app dissociates work from a single workspace so users can manage multiple local or cloud agents, while plan mode, skills, and integrations let agents inspect code, pull context from tools like Figma, deploy to services, create Linear tasks, and execute delegated work. The team dogfoods Codex heavily, watches Slack, Twitter, community, and alpha feedback, and keeps advanced primitives configurable before progressively disclosing them to mainstream users.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  codex-app[Codex app] --> core-codex-harness[Core Codex harness]
  codex-cli[Codex CLI] --> core-codex-harness
  ide-extension[IDE extension] --> core-codex-harness
  codex-app --> model-router[Model router]
  model-router --> gpt-5-4[GPT 5.4]
  model-router --> codex-spark[Codex Spark]
  model-router --> fast-mode[Fast mode]
  codex-app --> plan-mode[Plan mode]
  plan-mode --> local-workspace[Local workspace]
  codex-app --> multi-agent-task-manager[Multi-agent task manager]
  multi-agent-task-manager --> local-workspace
  multi-agent-task-manager --> cloud-agent-runner[Cloud agent runner]
  core-codex-harness --> local-workspace
  core-codex-harness --> cloud-agent-runner
  codex-app --> skills-system[Skills system]
  core-codex-harness --> skills-system
  skills-system --> figma-skill[Figma skill]
  skills-system --> deployment-skills[Deployment skills]
  skills-system --> linear-skill[Linear skill]
  feedback-channels[Feedback channels] --> codex-app
Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component Role Interacts with
Codex app Standalone user interface for chat, plan mode, multiple delegated tasks, skills discovery, and multi-agent management. Core Codex harness, Model router, Plan mode, Multi-agent task manager, Skills system
Codex CLI Terminal interface that uses the shared harness for local agent workflows. Core Codex harness, Local workspace
IDE extension VS Code, Cursor, Windsurf, and related IDE integration that shares code with the app and uses the same harness. Core Codex harness, Local workspace
Core Codex harness Open-source Rust agent harness shared across the app, CLI, and IDE extension. Codex app, Codex CLI, IDE extension, Local workspace, Cloud agent runner, Skills system
Model router User-controlled model selection layer for frontier, fast, and intermediate model choices. Codex app, GPT 5.4, Codex Spark, Fast mode
GPT 5.4 Frontier model path for complex code analysis, migrations, and large-codebase tasks. Model router
Codex Spark Fast model path for near-instant interactive ideation and iteration. Model router
Fast mode Intermediate speed-quality option between the frontier and Spark paths. Model router
Plan mode Planning state that inspects the codebase, proposes next steps, and asks the user for guidance before execution. Codex app, Local workspace
Multi-agent task manager App layer for switching between and managing multiple delegated agent tasks across projects. Codex app, Cloud agent runner, Local workspace
Skills system Extensible integration surface for design, deployment, project management, and service tasks. Codex app, Core Codex harness, Figma skill, Deployment skills, Linear skill
Figma skill Design integration that pulls Figma details, React components, and variables into implementation tasks. Skills system
Deployment skills Integrations for deploying applications to Vercel, Cloudflare, Render, and similar platforms. Skills system
Linear skill Project-management integration used to create, track, complete, and cross off implementation tasks. Skills system
Local workspace Developer's configured code environment where local tools are available and the human can course-correct partial work. Codex CLI, IDE extension, Core Codex harness, Plan mode, Multi-agent task manager
Cloud agent runner Long-term delegation environment for independent agents working in the cloud. Core Codex harness, Multi-agent task manager
Feedback channels Slack, Linear, Twitter, alpha programs, open-source forks, ambassadors, and community experiments that inform quality and roadmap decisions. Codex app

Data flow

A user starts in the app, CLI, or IDE extension, sends a prompt by text or voice, and chooses a model tier based on task complexity and desired speed. For ambiguous work, Codex can enter plan mode, inspect the current project, propose options, and ask for guidance before execution. The shared Rust harness drives the agent across local workspaces or cloud runners, with the app managing multiple delegated tasks independently from one folder. Skills connect the agent to Figma, deployment platforms, Linear, and other services. Feedback from dogfooding, Slack summaries, Twitter, alpha users, open-source forks, and community experiments feeds issues, product decisions, and simplification of advanced primitives.

4 supporting quotes
“under the hood, both the app and the IDE extension talk to the same core Codex harness in Rust that is open source and that the CLI also uses”transcript, stated
“automatically understood that I'm trying to make a plan for what we should build next. And so if I simply do shift tab, it will enter plan mode and if I say like what should we build? Uh like I can use Codex as a brainstorming partner to plan. And in this plan mode,”transcript, stated
“can start discovering, "Oh, there's a sidebar. Oh, I can run multiple tasks. Oh, it's like really easy for me to click between them. Okay, now I'm like being really effective myself." And then it's like, "Oh, there's a skills tab. Let me like go into here." And so we try to like make it so you”transcript, stated
“Those skills are like right there and so you can just simply like tell Codex what to do and we'll basically connect to this ecosystem of tasks.”transcript, stated

Why this architecture

The app, CLI, and IDE extension share a harness because Codex needs consistent agent behavior across surfaces, while each surface serves a different developer rhythm. The standalone app exists because the team expects users to delegate to many agents across projects; IDEs and CLIs are still valuable, but they are tied to a specific workspace. The local-first path remains important because developers already have tools and can course-correct partial work, while cloud delegation is the long-term direction for agents that run independently for hours or days. The skills and open-source harness keep power users at the frontier, then the app progressively discloses advanced capabilities to beginners.

4 supporting quotes
“direction. So, for instance, in the case of the Codex app, like one of the strategic goals that we had was to dissociate ourselves from a specific workspace. Okay, so that's a bit abstract. What I mean is that like if you're using an an IDE like VS Code, which is my favorite IDE,”transcript, stated
“we know we need to get to a point where it feels really natural to be talking to like multiple agents at a time”transcript, stated
“if you start in cloud, it can be quite hard for the developer to get value because, you know, your tools aren't there”transcript, stated
“important part of the product is that it's like super configurable. Right? And so like for us, Codex, like the harness is open source. Like you can go deep in. Like whenever we're building a feature, we start getting complaints on Twitter that the feature, which by the way is like”transcript, stated

Models used: GPT 5.4 · Codex Spark · GPT-5 · GPT-5.2 Codex · GPT-4

Scale

Alternatives considered (roads not taken)

Focus only on the IDE extension or CLI

Rejected because: Those surfaces were popular, but the app was judged better for beginner-friendly multi-agent delegation across workspaces.

“should we even be building an app? Like the IDE extension is super popular. Should we just focus on that and improve the quality there? What about CLI?”transcript, stated
“having a bunch of terminal windows open. But like the decision to build the app was basically it's kind of like beginner-friendly and it's kind of like you you just play with it. It's like the best in interface to manage multiple agents at the same time. Yeah, I I would say like the way that”transcript, stated

Start the delegation experience in cloud

Rejected because: Cloud startup makes environment setup, partial credit, and course correction harder before the developer has value.

“agent that's like orchestrating multiple agents for you. However, we've also learned that if you start in cloud, it can be quite hard for the developer to get value because, you know, your tools aren't there, you got to do environment setup, it's like a little bit hard if like to get”transcript, stated
“maybe if the model goes halfway, you need to like jump in and course correct or just poke at things. So, we're like, "Okay, we need a local experience that is separated from a specific folder, but yet feels super intuitive to work with folders on your”transcript, stated

Keep Codex tied to one folder or workspace

Rejected because: The delegation vision required working with multiple independent agents rather than one checkout at a time.

“you're using Git work trees, you can only open it to like one Git work tree at a time. And so, you basically can only work on one thing at a time. Right? And the same is true for like a CLI as well. And like because we know we have this vision of like we want people”transcript, stated
“we want people to be working with agents that they're delegated to in the cloud that are just working independently”transcript, stated

Build only for cutting-edge power users

Rejected because: Power-user configurability is valuable, but the product would become nearly impossible for beginners without progressive disclosure.

“if you only build for that, you end up with this thing that's like nearly impossible to understand and you used to spend all day on Twitter like you were saying. And so we kind of have this view of like we are really careful about like what the core”transcript, stated
“use. Mhm. Um we learn from how people are using it and then from there we think about, "Okay, now how do we make that super simple for everyone else?" So like the Codex app is actually an example of this where around the time of like uh I would say like GPT um GPT 5.2 Codex”transcript, stated

Detailed medium-term roadmap

Rejected because: The team argues OpenAI frontier work is better planned as concrete near-term work plus long-term direction, because medium-term plans are brittle under model change.

“at Open AI you either plan near-term or long-term, but you can never plan medium-term. Mhm. Um it's just too difficult. So, near-term is like up to 8 weeks from now. 8 weeks being the absolute maximum. What is a concrete thing that you can like motivate a”transcript, stated
“the in-between thing is like a product roadmap. We just we basically don't really have those. We have the combination of like a a sort of long-term direction and like things that we think bring us in that direction. So, for instance, in the case of the Codex”transcript, stated

Patterns

model-routing (model-ops)

Codex lets users pick frontier or fast models based on task complexity, latency, and flow-state needs.

“On the left side you have GPT 5.4, right? I'm going to give it a head start. And on the right side you have Codex Spark.”transcript, stated
“frontier models like GPT 5.4 that can take on very complex tasks”transcript, stated

latency-optimization (performance)

Codex Spark is positioned for instant edit loops where speed matters more than frontier reasoning depth.

“And I'm going to send this task and in basically a handful of seconds, Codex Spark will be able to edit and we'll see the changes live.”transcript, stated
“you can reach for like the fast model even Codex Spark and you have this like insane speed of thought”transcript, stated

multi-agent-orchestration (agent-runtime)

The standalone app is designed around managing multiple delegated agents rather than a single terminal or IDE workspace.

“the best in interface to manage multiple agents at the same time”transcript, stated
“to get to a point where it feels really natural to be talking to like multiple agents at a time or even just one agent that's like orchestrating multiple agents for you. However, we've also learned that if you start in cloud, it can be quite hard for the developer to get value because, you know,”transcript, stated

tool-use-orchestration (agent-runtime)

Skills connect Codex agents to Figma, deployment providers, Linear, and other external systems so tasks can span design, code, deploy, and project management.

“turn on the Figma skill to kind of pull details directly for from the Figma files, all of the React components, the variables”transcript, stated
“Vercel or Cloudflare or Render. Those skills are like right there”transcript, stated

prompt-chaining (workflow)

Plan mode separates ambiguous planning and codebase exploration from execution, letting the user steer before work begins.

“Codex has automatically understood that I'm trying to make a plan for what we should build next”transcript, stated
“it's going to look at the code, it's going to look at where we are so far in the project, come up with ideas”transcript, stated

data-quality-loop (feedback)

Dogfooding, Slack summaries, Twitter, alpha users, open-source forks, and community events provide continuous product-quality and roadmap feedback.

“I use Codex a ton to understand like what is happening in Slack? Like what is the feedback we're getting?”transcript, stated
“We're very feedback oriented. Like when is there feedback from the community and like let's fix that”transcript, stated

human-in-the-loop-gate (quality)

Agent-generated code remains subject to human ownership, testing, quality thinking, and senior engineering responsibility for complex systems.

“the vast majority of code was generated by an agent but we still spend a lot of care and attention like thinking about the system”transcript, stated
“if there's a really complicated feature I often will make sure that there's like a more robust stable owner to own it”transcript, stated

agent-memory (personalization)

The broader personal-agent vision includes tools connected to calendars, Gmail, banking, YouTube, and other personal systems, with memory of conversations.

“because it has memory of our conversations, it gave me like a a a very vulgar pep talk for like 3 minutes”transcript, stated
“it has my banking information, it has like uh my YouTube information, it has like uh voices that I've activated, my my calendar, my Google stuff”transcript, stated

Tradeoffs

Surface strategy

Chose standalone app plus CLI and IDE extension on a shared harness over only improving one popular interface.

Rationale: The app is better for beginner-friendly multi-agent management, while CLI and IDE users keep familiar local workflows and the shared harness preserves common behavior.

“the decision to build the app was basically it's kind of like beginner-friendly”transcript, stated
“both the app and the IDE extension talk to the same core Codex harness in Rust that is open source and that the CLI also uses”transcript, stated

Execution environment

Chose local-first experience that can scale toward cloud over starting all agent work in cloud.

Rationale: Local work gives users their tools and easier course correction, while the product still aims toward independent cloud agents.

“So, we're like, "Okay, we need a local experience that is separated from a specific folder, but yet feels super intuitive to work with folders on your computer.”transcript, stated
“scale really well to cloud, and we want all of that to feel like ergonomic”transcript, stated

Product complexity

Chose progressive disclosure over exposing every advanced primitive at once.

Rationale: The team wants power-user configurability without making beginners learn hidden lore before they get value.

“It's just like a chat. It'll do work. But then you can start discovering, "Oh, there's a sidebar. Oh, I can run multiple tasks.”transcript, stated
“Okay, now I'm like being really effective myself." And then it's like, "Oh, there's a skills tab. Let me like go into here." And so we try to like make it so you it's almost like playing a game.”transcript, stated

Planning cadence

Chose near-term concrete plans plus long-term vision over medium-term roadmaps.

Rationale: Frontier model capabilities change too quickly for medium-term planning to remain reliable.

“near-term is like up to 8 weeks from now. 8 weeks being the absolute maximum.”transcript, stated
“the in-between thing is like a product roadmap. We just we basically don't really have those.”transcript, stated

Quality ownership

Chose agent-generated code with human ownership and review over vibe-coded production ownership.

Rationale: Agents produce most code, but the team still treats system design, testing, and durable ownership as human responsibilities.

“the vast majority of code was generated by an agent but we still spend a lot of care and attention”transcript, stated
“And so that's why for instance if there's a really complicated feature I often will make sure that there's like a more robust stable owner to own it.”transcript, stated

Gotchas (what bit them)

Cloud-first agents can fail to deliver value before the environment is usable.

Root cause: The developer's tools, setup, and ability to course-correct partial work are often local.

Resolution: Build a local experience that is separated from one folder while still feeling natural with local workspaces, then scale toward cloud delegation.

“if you start in cloud, it can be quite hard for the developer to get value because, you know, your tools aren't there”transcript, stated
“we need a local experience that is separated from a specific folder, but yet feels super intuitive to work with folders on your computer”transcript, stated

Building only for power users makes the product hard to understand.

Root cause: Developers love configurability and forking, but raw power-user surfaces can require constant Twitter-level lore to use.

Resolution: Design core primitives carefully, expose configurability, then progressively disclose advanced capabilities in a simple app.

“if you only build for that, you end up with this thing that's like nearly impossible to understand”transcript, stated
“we are really careful about like what the core primitives of what we're building are”transcript, stated

Model capability shifts can make an earlier product direction too early or newly viable.

Root cause: Codex Cloud launched before models could reliably handle the intended delegation workflow, while later GPT-5.2-era models changed the product surface that made sense.

Resolution: Pivot to what models can solve now, while maintaining long-term delegation architecture until models catch up.

“we launched this Codex Cloud product. It was a great idea. People were super People are still super excited about it. Um but it was a little early.”transcript, stated
“around August we shipped GPT-5, great interactive coding model. We were like, "All right, like let's go solve the problem that the models can solve right now.”transcript, stated

Agent-generated code does not remove the need for system ownership.

Root cause: Producing code is easier, but maintaining complex production systems still requires continuity, quality judgment, and accountable owners.

Resolution: Let PMs and designers prototype or make small changes, but assign robust owners to complicated features.

“Um but I feel like we're at a point now where like it's not about can you generate the code. Um like the agent is amazing you can delegate tasks to it.”transcript, stated
“you don't want a PM to like maintain a feature code that doesn't sound like a good idea”transcript, stated

Open-source power users can break or complain about unreleased features.

Root cause: The harness is open source, and users fork or modify code to enable features before production rollout.

Resolution: Treat that frontier behavior as valuable signal, while staging mainstream rollout and simplifying mature capabilities later.

“we start getting complaints on Twitter that the feature, which by the way is like not enabled in prod, is like broken”transcript, stated
“the cutting edge of your users are just absolutely living in the future with us and pulling us into that future”transcript, stated

Evaluation

Codex quality management is driven by dogfooding, Slack and Linear feedback loops, Twitter/community feedback, alpha programs, open-source power-user experiments, launch-oriented execution, and human review of agent-generated work. The team uses Codex itself to summarize feedback, inspect code state, create Linear issues, and test small changes before PRs.

Metrics: growth multiple · model speed · large-codebase task complexity · Slack feedback themes · Linear issues · Twitter complaints · alpha user feedback · community adoption · internal OpenAI usage · small-change PR quality · launch readiness · multi-agent task usability

4 supporting quotes
“Ship Codex CLI IDE extension." Growth started exploding then. And uh you know, I remember it was like we grew like 20 or 30 x in like a few months, which is awesome.”transcript, stated
“I use Codex a ton to understand like what is happening in Slack? Like what is the feedback we're getting?”transcript, stated
“coordinate like actually quite a wide alpha with like a bunch of users and like building with those users to get feedback”transcript, stated
“we still spend a lot of care and attention like thinking about the system and making sure it's really high quality”transcript, stated

Outcomes

The transcript reports 1,200-token-per-second Codex Spark output, frontier model tasks involving millions of lines of code, 10-bullet specs, growth of 20-30x over a few months, a team that grew from about eight people to 50-100, and broad OpenAI/internal plus millions-of-developers platform context.

4 supporting quotes
“And boom, you have like 1,200 in a second on average. This is insane speed.”transcript, stated
“And uh you know, I remember it was like we grew like 20 or 30 x in like a few months, which is awesome. Uh and then the second vibe shift was around December-January, where we actually could get back to this vision of like delegating to models.”transcript, stated
“the vast majority of OpenAI uses the Codex app even outside of technical works”transcript, stated
“the designers on the Codex team uh right like you know we like to share like more code now than like was written by an engineer like 6 months ago”transcript, stated