OpenAI launches Symphony for coding agent workflows

OpenAI has released Symphony, an open-source specification for orchestrating coding agents around software tasks. It links project-management boards to continuous agent workflows.

Symphony is designed to turn an issue tracker such as Linear into what OpenAI describes as a control plane for coding agents. In this setup, each open task is assigned to a dedicated agent workspace, while the system monitors progress, restarts stalled agents and keeps work running until the task is complete.

The release reflects a change in how OpenAI manages software development with Codex. Engineers had been using several interactive coding sessions at once, but that created a bottleneck because staff had to keep switching context between tasks, terminals and reviews.

Rather than centring work on coding sessions or individual pull requests, Symphony is organised around tickets and task states. That allows agents to handle a wider range of work, including investigations and analysis that may not result in code changes, as well as larger development projects spread across multiple repositories.

OpenAI has presented the project as a written specification rather than a conventional software product. The repository is centred on a SPEC.md file that defines the problem and intended behaviour, while a reference implementation is written in Elixir.

The system emerged from OpenAI's internal engineering workflow. Some teams recorded a 500% increase in landed pull requests over the first three weeks of using Symphony.

That increase came as engineers spent less time supervising individual agent sessions. The lower cost of starting speculative work also changed team behaviour, making it easier to try ideas, test refactors and discard weak results without committing significant staff time.

Symphony also widened access to the development process. Product managers and designers can file feature requests directly into the workflow and receive a review packet that includes a video walkthrough of the resulting work in the product.

How it works

The orchestration model uses the task manager as a state machine. Agents begin only on tasks that are not blocked, allowing work to proceed in parallel where dependencies permit.

In one example, a React upgrade was marked as blocked until a migration to Vite had finished. Agents started the React work only after that earlier migration was complete.

Agents can also add follow-up tasks when they detect issues outside the original scope, such as a refactoring opportunity or an architectural change. Those tasks can then be reviewed and scheduled in the same workflow.

The orchestrator can also support large monorepos, where the process of landing a pull request may be slow or fragile. In those cases, Symphony watches continuous integration checks, rebases changes when needed, resolves conflicts and retries failed checks.

Trade-offs

OpenAI said the approach has limits. Moving from direct interactive supervision to ticket-level assignment reduces engineers' ability to intervene continuously while an agent is working, and some tasks still require hands-on work in interactive Codex sessions.

Those tend to be problems that require stronger judgement or remain highly ambiguous. Routine implementation work, by contrast, can be delegated more readily, leaving engineers to focus on harder tasks one at a time.

OpenAI also said early versions of its agent workflow were too rigid because they focused narrowly on implementing a task. Over time, the company expanded the tools available to agents so they could read review feedback, inspect CI logs, manage pull requests and report on completed or abandoned work.

That led to a broader shift from giving agents fixed transitions to assigning them objectives. OpenAI said the change was intended to make better use of the reasoning ability of newer models.

Built by agents

Symphony itself was developed with heavy use of Codex. An early version ran in tmux and polled Linear while spawning sub-agents for new work, before later iterations were integrated into an internal repository designed to support agent-led development.

OpenAI then extracted the concept into a standalone specification and asked Codex to implement it in Elixir. To refine the design, it also used Codex to implement Symphony in TypeScript, Go, Rust, Java and Python to expose ambiguities in the specification.

The published version no longer depends on OpenAI's internal repositories or workflows. Alongside the main specification, the process agents are expected to follow is documented in a WORKFLOW.md file, which sets out steps such as moving issues through statuses, attaching pull requests and adding supporting material.

OpenAI said Symphony also relies on Codex App Server, a headless mode that allows programmatic interaction through a JSON-RPC API. That gave the company a way to integrate Codex into its workflow without relying on live command-line sessions.

Although OpenAI has released the project openly, it does not plan to maintain Symphony as a standalone product. Instead, it sees the project as a reference implementation for teams that want to build their own orchestration systems around coding agents. OpenAI added that the repository had already passed 15,000 GitHub stars.