Symphony: OpenAI's Open-Source Orchestrator for Autonomous Coding Agents

OpenAI quietly dropped Symphony — an open-source project that turns a Linear board into an autonomous coding pipeline. The pitch: stop babysitting coding agents. Instead, manage work. Symphony watches your issue tracker, spawns isolated workspaces per ticket, runs an agent in each, and lands the PR once CI passes and review is addressed.

The Core Loop

The runtime is a continuous service. Here's what it does:

1. Watches your Linear board for issues moving into a "ready" state
2. Spawns an isolated workspace (per-issue directory) so commands can't leak across tickets
3. Runs a coding agent session inside that workspace with the issue as the task
4. Produces proof of work — passing CI, a PR, review feedback addressed, and a walkthrough video
5. Lands the PR once the acceptance criteria are met

The engineer never touches the agent directly. They approve, review, or reject. Management happens at the ticket layer, not the prompt layer.

What the Repo Actually Looks Like

The repo is live at github.com/openai/symphony — Apache 2.0 licensed, already past 3.7K stars. Interesting architectural choices:

Aspect	Choice	Why
Language	Elixir / OTP	Long-running supervised processes, fault tolerance
Workflow config	WORKFLOW.md in-repo	Version the agent prompt & runtime with your code
Isolation model	Per-issue workspace directory	Agents can't reach across tickets
Spec location	SPEC.md	Anyone can build their own implementation

The Elixir/BEAM choice is telling. Symphony isn't a one-shot prompt pipeline. It's an always-on supervisor managing potentially dozens of long-running agent sessions, each one its own supervised process tree. That's exactly what BEAM was built for.

Why the "Proof of Work" Model Matters

The most important design decision: agents are not trusted to simply declare themselves done. Each task produces:

• CI status — it actually builds and tests pass
• PR review feedback — the agent addresses comments instead of ignoring them
• Complexity analysis — a self-evaluation of what changed and why
• Walkthrough video — a recorded demo of the change in action

That last one is the sleeper feature. A video walkthrough is review-friendly in a way that a PR description is not. You can watch the change happen before approving it, which is a much better oracle than reading a diff when the agent is the one doing the work.

"Harness Engineering" Is the Prerequisite

Symphony's docs note that it works best in codebases that have adopted harness engineering — meaning well-scoped tickets, clear acceptance criteria, and strong CI. That tracks with reality: the bottleneck isn't the agent. The bottleneck is the description of what "done" looks like. Symphony works because it pushes all the human effort to the top of the funnel (write a crisp ticket, define acceptance) and lets the agent do everything below it.

The Bigger Picture

Symphony slots into a rapidly maturing category of "agent orchestrators" — tools that treat agents as workers inside a larger workflow system instead of as interactive assistants. It's competitive with tools like T3 Code, AO (Composio Agent Orchestrator), and Cmux, but the OpenAI branding and Apache license mean this one will likely define the reference pattern.

The shift: from "supervise the coding agent" to "manage the work queue the agents pull from."

Key Takeaways

• Symphony monitors a Linear board, spawns isolated per-issue workspaces, and runs autonomous coding agent sessions inside each
• Agents produce proof of work: passing CI, PR reviews addressed, complexity analysis, and a walkthrough video before landing the PR
• The reference implementation is in Elixir/OTP — chosen for its fault-tolerant, supervised long-running process model
• Engineers move from supervising agents to managing a ticket queue; the bottleneck becomes how well you scope tickets
• Works best in codebases with strong CI and clear acceptance criteria ("harness engineering")

Resources

• openai/symphony on GitHub — Source code, reference implementation, and README
• Symphony SPEC.md — Full specification for building your own implementation
• Symphony Elixir Reference — The reference implementation running on BEAM/OTP
• OpenAI Releases Symphony: The Agile Kanban for the AI Era — Medium deep-dive on the launch