On March 14, 2026, OpenAI shipped Codex subagents to general availability — a production-ready system where one manager agent coordinates multiple specialized coding agents, each running in its own isolated cloud sandbox. It's not a research preview or a beta flag. It's the real thing: autonomous coding teams that execute complex, multi-file tasks while you sleep.

The architecture is fundamentally different from local-first tools like Claude Code. Every Codex subagent runs in a containerized environment with no access to your local machine. You describe the work, the manager decomposes it, subagents execute in parallel, and you get a pull request when it's done. Powered by GPT-5.4 with a 1M token context window, native computer use, and tool search, Codex represents OpenAI's bet that the future of AI coding is fully autonomous, cloud-native agents.

In this guide, we cover the full Codex subagent ecosystem: the manager-worker architecture, the Codex desktop app, Codex Security, the Symphony orchestration framework, API pricing, how it compares to Claude Code and Cursor, real-world workflows, and what to watch out for. Whether you're evaluating Codex for your team or already using it, this is the comprehensive reference.

1What Are Codex Subagents?

Codex subagents are OpenAI's production multi-agent coding system, shipped to GA on March 14, 2026. The core concept: instead of one AI agent working through your codebase sequentially, a manager agent decomposes your task into subtasks and spawns specialized worker agents that execute in parallel — each in its own isolated cloud sandbox.

Each subagent gets a full containerized environment: its own filesystem snapshot, installed dependencies, and tool access. They can read files, write code, run tests, execute shell commands, and search documentation. When they finish, results flow back to the manager agent, which validates the work, resolves conflicts, and assembles the final output — typically a pull request or a set of file changes.

The critical distinction from local-first tools: Codex subagents never touch your local machine. Everything runs in OpenAI's cloud infrastructure. This makes them ideal for fire-and-forget workflows — kick off a task, close your laptop, and review the PR in the morning. It also means your local development environment stays clean and unaffected.

2Architecture: Manager Agent + Specialized Workers

The Codex subagent architecture follows a manager-worker pattern. The manager agent is the orchestrator — it receives your task, creates an execution plan, spawns subagents, monitors progress, and assembles the final result. Worker subagents are specialized executors that handle individual subtasks within their sandboxed environments.

User Task: "Add user authentication with OAuth, 
  JWT tokens, and role-based access control"

Manager Agent
  ├── Analyzes codebase structure
  ├── Creates execution plan (4 subtasks)
  │
  ├── Spawns: Auth Worker [Sandbox A]
  │     └── OAuth provider integration, 
  │         callback handlers, token exchange
  │
  ├── Spawns: JWT Worker [Sandbox B]
  │     └── Token generation, validation 
  │         middleware, refresh logic
  │
  ├── Spawns: RBAC Worker [Sandbox C]
  │     └── Role definitions, permission 
  │         guards, admin middleware
  │
  └── Spawns: Test Worker [Sandbox D]
        └── Unit tests, integration tests, 
            E2E auth flow tests

Manager Agent
  ├── Collects results from all workers
  ├── Resolves file conflicts (3 workers 
  │   touched middleware/auth.ts)
  └── Opens PR with consolidated changes

3Codex Desktop App: The Command Center

In February 2026, OpenAI released the Codex desktop app for macOS — positioned as the "command center for agents." It's a native application that provides a visual interface for managing Codex subagent workflows, monitoring task progress, and reviewing results without switching between browser tabs and terminal windows.

The desktop app isn't just a wrapper around the web interface. It integrates directly with your local Git repositories, provides real-time progress visualization for running subagents, and offers a unified view of all active and completed tasks. Think of it as a project management dashboard specifically designed for AI agent workflows.

• Repository integration — Connect local Git repos and trigger Codex tasks directly from the app. The app handles repo snapshotting and upload to cloud sandboxes automatically.
• Live agent monitoring — Watch subagents work in real time with streaming logs, file change previews, and test execution results. Each subagent gets its own panel showing current activity.
• Task queue management — Queue multiple tasks, prioritize them, and let Codex work through your backlog autonomously. Review completed tasks and approve or reject changes at your own pace.
• PR review interface — Built-in diff viewer for reviewing subagent output before merging. Includes inline commenting and the ability to request revisions from the manager agent.
• Cost tracking — Real-time token usage and cost estimates for each task and subagent. Helps teams stay within budget on multi-agent workflows.

4Codex Security: Automated Vulnerability Detection

Codex Security launched in March 2026 as a dedicated application security product built on the subagent architecture. Instead of general-purpose coding tasks, Codex Security deploys specialized subagents that scan your codebase for vulnerabilities — each agent focusing on a different category of security concern.

The approach goes beyond traditional static analysis tools like Snyk or SonarQube. Because each subagent has full code comprehension through GPT-5.4, it can understand business logic context, trace data flows across files, and identify vulnerabilities that pattern-matching tools miss. The subagents don't just flag issues — they generate fix suggestions with full code diffs.

5Symphony Framework: Elixir-Based Agent Orchestration

In March 2026, OpenAI published the Symphony framework on GitHub — an Elixir-based agent orchestration system that provides the building blocks for creating custom multi-agent workflows. Symphony is the same framework that powers Codex subagents internally, now available for developers to build their own agent systems.

The choice of Elixir is deliberate. The BEAM virtual machine (Erlang's runtime) excels at managing thousands of lightweight concurrent processes with built-in fault tolerance — exactly what you need for orchestrating multiple AI agents. Each agent runs as an Elixir process with its own state, message queue, and supervision tree. If an agent crashes, the supervisor restarts it without affecting other agents.

defmodule MyApp.CodingTeam do
  use Symphony.Orchestrator

  def run(task_description, repo_path) do
    # Define specialized agents
    agents = [
      %Symphony.Agent{
        role: :frontend,
        model: "gpt-5.4",
        system_prompt: "You are a React/TypeScript specialist.",
        tools: [:file_read, :file_write, :shell, :test_run]
      },
      %Symphony.Agent{
        role: :backend,
        model: "gpt-5.4",
        system_prompt: "You are a Node.js/Express API specialist.",
        tools: [:file_read, :file_write, :shell, :db_query]
      },
      %Symphony.Agent{
        role: :testing,
        model: "gpt-5.4",
        system_prompt: "You are a QA engineer writing tests.",
        tools: [:file_read, :file_write, :test_run, :coverage]
      }
    ]

    # Manager decomposes task and assigns to agents
    Symphony.Orchestrator.execute(
      task: task_description,
      repo: repo_path,
      agents: agents,
      strategy: :parallel,
      conflict_resolution: :manager_merge
    )
  end
end

Symphony provides several key primitives for building multi-agent systems:

• Agent definitions — Typed structs for defining agent roles, model selection, system prompts, and available tools. Agents are composable and reusable across different orchestration workflows.
• Orchestration strategies — Built-in patterns for parallel execution, sequential pipelines, fan-out/fan-in, and hierarchical delegation. Custom strategies can be defined as Elixir behaviours.
• Conflict resolution — Automatic handling of file conflicts when multiple agents modify the same files. Supports manager-merge (manager resolves), last-write-wins, and custom resolution functions.
• Supervision trees — Leverages OTP supervisors for fault tolerance. If an agent process crashes, it gets restarted with its last known state. The orchestrator can reassign failed tasks to new agents.
• Telemetry & observability — Built-in telemetry events for monitoring agent activity, token usage, task progress, and error rates. Integrates with standard Elixir observability tools.

6API Integration & Pricing

Codex subagents are powered by GPT-5.4, which brings a 1M token context window, native computer use capabilities, and tool search to every agent. The API is available through the standard OpenAI endpoints, making integration straightforward for teams already using the OpenAI platform.

import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Create a Codex task with subagents
const task = await openai.codex.tasks.create({
  repo: "github.com/myorg/myapp",
  branch: "main",
  description: `
    Add a user notification system:
    - WebSocket real-time notifications
    - Email digest (daily summary)
    - In-app notification center component
    - Database schema for notification storage
    - Full test coverage
  `,
  model: "gpt-5.4",
  subagents: {
    strategy: "parallel",
    max_workers: 4,
    sandbox_config: {
      runtime: "node:20",
      install_command: "npm ci",
      test_command: "npm test"
    }
  }
});

// Poll for completion or use webhooks
console.log(`Task ${task.id} started with ${task.subagent_count} subagents`);
console.log(`Estimated completion: ${task.estimated_minutes} minutes`);

A typical multi-agent session with 3–4 subagents costs between $0.50 and $3.00 depending on task complexity and codebase size. The cost scales with the number of subagents and the amount of code each one needs to read and generate. For teams running Codex on a daily basis, expect monthly costs in the $50–$500 range depending on usage intensity.

7Codex vs Claude Code vs Cursor

The AI coding landscape in 2026 has three distinct paradigms: Codex (autonomous cloud agents), Claude Code (local-first interactive agents), and Cursor (AI-enhanced IDE). Each serves a different workflow and developer preference. Here's how they compare:

The decision framework comes down to workflow preference. Codex is for teams that want to describe work and walk away — it's the autonomous agent that works while you sleep. Claude Code is for developers who want an AI collaborator that works alongside them in real time with deep codebase understanding. Cursor is for developers who want AI assistance integrated directly into their editor for real-time pair programming.

Many teams use all three. Codex handles overnight batch tasks and large refactors. Claude Code handles complex, interactive development sessions where real-time feedback matters. Cursor handles day-to-day coding with inline completions and quick edits. They're complementary tools, not competitors.

8Real-World Workflows

Here are concrete scenarios where Codex subagents deliver measurable value over single-agent or interactive workflows:

# Queue multiple tasks before leaving for the day
codex task create \
  --repo ./my-app \
  --description "Convert all API routes from Express to Hono" \
  --subagents 4 \
  --notify slack:#dev-channel

codex task create \
  --repo ./my-app \
  --description "Add comprehensive error handling to all service files" \
  --subagents 3 \
  --notify slack:#dev-channel

codex task create \
  --repo ./my-app \
  --description "Write missing unit tests for utils/ directory" \
  --subagents 2 \
  --notify slack:#dev-channel

# Check status in the morning
codex task list --status completed
# → 3/3 tasks completed, 3 PRs ready for review

9Limitations & Known Issues

Codex subagents are production-ready, but they're not magic. Here are the current limitations and known issues to factor into your evaluation:

• No local machine access — Subagents run entirely in cloud sandboxes. They can't access local services, databases, or APIs that aren't publicly reachable. If your development workflow depends on local Docker containers or VPN-only services, Codex can't reach them.
• Async-only workflow — There's no real-time interactive mode. You describe the task, Codex executes, and you review the result. If the output isn't right, you iterate with a new task. This is slower for exploratory work where you need rapid back-and-forth.
• Merge conflict complexity — When multiple subagents modify the same files, the manager agent resolves conflicts. For simple conflicts this works well, but complex semantic conflicts (like two agents implementing different approaches to the same problem) may produce suboptimal merges.
• Repository size limits — Very large monorepos (10GB+) can be slow to snapshot and upload to cloud sandboxes. OpenAI recommends using sparse checkouts or submodule-based repos for large codebases.
• No persistent state between tasks — Each task starts fresh. Subagents don't remember previous tasks or learn from past interactions with your codebase. Every task re-reads and re-analyzes the relevant code from scratch.
• Desktop app is macOS-only — The Codex desktop app released in February 2026 is currently limited to macOS. Windows and Linux users must use the web interface or CLI.
• Cost unpredictability — Multi-agent tasks can consume significantly more tokens than expected, especially when subagents encounter errors and retry. Setting token budgets per task is recommended but not yet granular at the per-subagent level.

The sweet spot for Codex subagents is well-defined, parallelizable tasks on codebases with good test coverage (so subagents can validate their own work). Tasks that require deep contextual understanding of undocumented business logic or real-time human feedback are better suited to interactive tools like Claude Code or Cursor.

10Why Lushbinary for AI Development

At Lushbinary, we help teams integrate autonomous AI coding agents into their development workflows — from Codex subagents to Claude Code to custom orchestration systems. We've been building with these tools since their early previews, and we know where they excel and where they fall short.