Symphony: how OpenAI's new Codex orchestrator actually works

OpenAI dropped something interesting yesterday. It's called Symphony, it's written in Elixir of all things, and it hit 15,500 GitHub stars in a day. The headlines are calling it "an orchestrator for Codex agents", which is true but useless, it tells you nothing about what the thing actually does or why anyone should care.

I spent the morning reading the spec and tracing through the reference implementation, and I want to walk you through what Symphony is, because I think it's a clean example of a pattern that's about to become very common: the agent-as-worker pattern, where coding agents are not chat partners but background workers consuming a queue of tickets.

Let me explain what that means.

The problem Symphony solves

Most people's mental model of a coding agent today comes from using Cursor or Claude Code or ChatGPT's Codex mode. You sit down, you describe what you want, the agent writes some code, you review it, you iterate. It's a conversation. The agent is a tool you're holding.

That works fine for one developer doing one thing. It falls apart the moment you want to scale agents across an engineering organisation.

Imagine you have fifty engineers and a thousand open tickets. You want agents to chip away at the backlog overnight, picking up small bugs, dependency bumps, refactors, test additions, the stuff that's well-specified but boring. You don't want fifty engineers individually pasting tickets into Cursor at 9am. You want the tickets themselves to flow to agents, autonomously, with the results showing up as pull requests humans can review.

This is a different shape of problem. It's not "agent as pair programmer". It's "agent as background worker". And background workers need orchestration: a way to pull jobs off a queue, run them in isolation, report results, and not stomp on each other when things go wrong.

That's what Symphony is. It's an orchestrator for the agent-as-worker pattern.

The shape of the pattern

Symphony has three moving parts, and once you see them the whole thing clicks.

The poller. Symphony continuously watches an issue tracker, Linear, GitHub Issues, Jira, whatever you've wired up. It looks for tickets matching a filter you define (typically a label like agent-ready plus some constraints on size or type). When it finds one, it claims it.

The runner. For each claimed ticket, Symphony spawns an isolated Codex agent run. "Isolated" is doing real work in that sentence: each run gets its own filesystem sandbox, its own git branch, its own environment, its own token budget. Two agents working on two tickets cannot see each other or interfere with each other. If one of them goes off the rails, it can't take down the others.

The reporter. When an agent run finishes, Symphony collects what it calls "proof of work": the diff, the PR it opened, the CI results from running the test suite, and a structured log of what the agent did and why. This bundle gets posted back to the original ticket so a human can review.

That's it. Poll, run, report. The whole spec is maybe 300 lines of prose plus the Elixir reference implementation.

Why Elixir

This is the part that surprised me, and I think it's worth a paragraph because it tells you something about how OpenAI is thinking.

Elixir runs on the BEAM virtual machine, which was originally built for telecoms, for systems that need to run thousands of independent processes that fail in isolation without bringing the system down. "Let it crash" is a cultural slogan in the Elixir world. If one process dies, a supervisor restarts it; the rest of the system carries on.

That's almost embarrassingly well-suited to running flaky AI agents in parallel. Agents fail. They time out, they hallucinate a non-existent API, they get stuck in loops, they exceed token budgets. You want every one of those failures to be local. You want the orchestrator itself to be unkillable.

So OpenAI reached for the language designed for exactly that fault model. I think this is going to look obvious in retrospect.

A worked example

Let me make this concrete. Suppose your team has a Linear board, and you tag a ticket agent-ready that reads:

Bump lodash from 4.17.20 to 4.17.21 across all packages in the monorepo. Update the lockfile. Make sure tests pass.

Here's what Symphony does:

1. The poller sees the new agent-ready ticket and claims it. The ticket gets a comment: "Symphony run started, agent ID sym-7f3a."
2. Symphony spawns a fresh sandbox: clones your repo, checks out a new branch (symphony/sym-7f3a-bump-lodash), gives the agent a scoped GitHub token and a Codex API key.
3. The Codex agent reads the ticket, greps the codebase for lodash, edits the relevant package.json files, runs npm install to update the lockfile, runs the test suite, sees it passes.
4. The agent opens a PR titled "Bump lodash to 4.17.21" with a description summarising what it did and which tests it ran.
5. CI runs against the PR. The results, pass, fail, with logs, get attached to the run record.
6. Symphony posts the proof-of-work bundle back to the Linear ticket: PR link, CI status, agent's reasoning trace, time and tokens consumed.

A human reviews the PR. If it's good, they merge. If it's not, they reject and either fix it themselves or refine the ticket and re-tag it.

The key thing is that no engineer ever opened Cursor. The work flowed from ticket to PR autonomously. The engineer's role was to write a clear ticket and review a clear diff.

Trade-offs, because there are always trade-offs

This pattern is powerful, and it has real costs.

It only works for well-specified work. If a ticket is ambiguous, the agent will make something up. Symphony assumes the ticket is the spec. Teams adopting this pattern end up writing much more precise tickets than they used to, which is good for humans too, but it's a real cultural shift.

Review load goes up. You've replaced "engineer writes code" with "engineer reviews agent's code". Reviewing is faster than writing, but it's not free, and reviewing bad code is sometimes slower than writing good code. Teams I've seen experimenting with this pattern report that the review bottleneck is the real constraint, not the agents.

Sandboxing has to be airtight. If your isolated agent run can reach production credentials, or push to main, or call external services with side effects, you have a problem. Symphony's sandboxing is good but the responsibility for what's inside the sandbox, what tokens, what network access, what filesystem mounts, is yours.

Cost is non-trivial and bursty. A thousand tickets running overnight is a thousand Codex API calls, each potentially long. You'll want budgets and concurrency limits, both of which Symphony supports but neither of which is free to tune.

Adjacent patterns

If Symphony reminds you of something, you're probably right.

It's structurally close to CI/CD systems like GitHub Actions or Buildkite, poll for events, run isolated jobs, report results. The difference is the worker is an LLM agent, not a deterministic pipeline. That changes what "success" means and what review looks like.

It's also close to the task queue pattern familiar from Celery, Sidekiq, or Oban, the Elixir-native job queue Symphony uses internally. Same shape: a queue of work items, isolated workers, results back to the caller. Symphony is essentially Oban with an LLM as the worker function.

It's not the same as agent frameworks like LangGraph or AutoGen, which orchestrate multi-agent reasoning within a single task. Symphony orchestrates many independent single-agent runs across many tasks. Different problem, different shape.

When to reach for it

Reach for an orchestrator like Symphony when you have a steady flow of well-specified, bounded work that doesn't need a human in the loop during execution, only at review. Dependency bumps, mechanical refactors, test backfills, doc updates, migration grunt-work. The boring middle of an engineering backlog.

Don't reach for it when the work is exploratory, ambiguous, or requires judgement during the work itself. That's still a job for an engineer with an agent in the loop, not an agent with an engineer at the end of it.

The interesting question is how much of a typical backlog falls into the first bucket. My guess is more than people expect, and that's why Symphony got 15,000 stars in a day.

---

Footnotes and links

Further reading

• [Spec]: Symphony orchestration spec, OpenAI, 27 April 2026.
• [Background]: "Designing for agent failure", Anthropic engineering blog, good companion piece on sandboxing assumptions.
• [Adjacent]: Oban documentation, for the queue pattern Symphony inherits.
• [Contrast]: LangGraph docs, for what multi-agent orchestration within a task looks like, as distinct from Symphony's across-tasks model.

¶