How OpenAI’s Open‑Source Symphony Redefines AI‑Driven Code Orchestration

Why Symphony is needed: the AI coding bottleneck shifted

Six months ago OpenAI ran an aggressive experiment: a productivity‑tool project where every line of code was generated by Codex instead of being hand‑written. To make this work they redesigned the engineering process, built an agent‑friendly repository layout, added automated tests and safeguards, and treated Codex as a real teammate.

As Codex grew stronger, the real bottleneck moved from code generation to managing the agents. Engineers had to juggle three to five concurrent Codex sessions, track which agent was doing what, which PR needed review, and which tests failed, incurring high context‑switch costs. Agents acted like highly capable junior engineers while senior engineers still had to monitor each session.

How Symphony works: turning Linear into an agent orchestrator

Symphony shifts the paradigm from “humans watch sessions” to “a task system drives agents”. Instead of organizing work around code sessions and PRs, teams work around tasks, issues, and milestones. Symphony turns a task‑management system such as Linear into the control plane for coding agents.

Each open Linear issue is mapped to an independent agent workspace. Symphony continuously watches the board, guarantees an active agent for every active task, restarts agents that crash, and automatically claims new tasks. Linear becomes a state machine: an issue moves from open to in progress, then to review and merging, with each state triggering the next agent action.

One‑sentence principle: every open task must have an agent running in its own workspace.

This abstraction lets a single issue spawn multiple PRs across repositories, or simply perform research, analysis, or planning without modifying code.

Concrete example and agent‑generated work

For a React upgrade that depends on a Vite migration, the agent first completes the Vite migration and then proceeds with the React upgrade, respecting the dependency DAG. Agents can also create new work: they may discover performance problems, refactoring opportunities, or better architectural directions, and automatically open follow‑up issues for the team to evaluate.

Impact on productivity

OpenAI reports that in some teams Symphony increased the number of merged PRs by 500 % in the first three weeks. More importantly, engineers no longer spend time supervising Codex sessions; they create tasks and let agents explore, dramatically lowering the perceived cost of experimentation.

Product managers and designers can submit feature requests directly in Symphony, receiving a review packet that may include a video demo of the feature running in the product, without needing to checkout the repository.

In large monorepos Symphony continuously monitors CI, rebases when needed, resolves conflicts, retries flaky checks, and escorts changes to the merging state, giving the team higher confidence before integration.

Limitations and lessons learned

Highly ambiguous problems that require strong judgment and expert experience still benefit from direct human‑Codex interaction. Symphony excels at routine implementation, migration, bug‑fix, verification, and exploratory tasks, freeing engineers to focus on truly difficult problems.

Early experience showed that agents should not be treated as rigid state‑machine nodes. Codex can create multiple PRs, read review feedback, use tools such as the gh CLI, read CI logs, and perform work far beyond simple code writing.

Core specifications and workflow

The heart of Symphony is a SPEC.md file that defines the problem and expected solution. Reference implementations are in Elixir because of its concurrency strengths, but the idea is language‑agnostic; OpenAI also generated versions in TypeScript, Go, Rust, Java, and Python to surface ambiguities in the spec.

The development process is codified in WORKFLOW.md, describing how to claim an issue, checkout the repo, move states, create PRs, enter review, and attach video proof. This explicit process replaces tacit knowledge that teams previously relied on.

Technically, a headless Codex App Server exposes a JSON‑RPC API that allows programmatic calls such as starting threads, responding to turns, and integrating external systems. Dynamic tool calls like linear_graphql let sub‑agents safely issue Linear requests without exposing access tokens.

Next steps for teams

Rather than copying Symphony verbatim, ordinary teams should first document their own workflow: how tasks enter development, how PRs are reviewed, how CI is handled, how results are verified, and how failures are retried. When these processes are written as clear specifications, agents can be integrated into daily engineering work instead of remaining in ad‑hoc chat windows.

For every open task, guarantee that an agent is running in its own workspace.

References

An open‑source spec for Codex orchestration: Symphony [1]

OpenAI Symphony [2]

Reference links:

[1] https://openai.com/index/open-source-codex-orchestration-symphony/

[2] https://github.com/openai/symphony