📖 What Is Symphony?

Symphony is an open-source specification and reference implementation for orchestrating autonomous coding agents at scale. Instead of an engineer managing multiple Codex sessions across terminals — context-switching between agents, nudging them back on track, debugging stalled tasks — Symphony treats your issue tracker as a control plane. Every open ticket gets a dedicated agent workspace. Agents pull work, implement it, provide proof of completion, and land PRs. Humans review results instead of supervising processes.

OpenAI released Symphony under the Apache 2.0 license on April 27, 2026. The repo quickly gathered over 23,500 stars, trending on GitHub in large part because of the tech stack choice: it's written in Elixir (22.6K lines, 95.5% of the codebase). This was OpenAI's first major open-source Elixir project, and the Elixir community embraced it immediately.

Why Elixir?

The choice of Elixir — built on the Erlang BEAM VM — is not accidental. Symphony's core job is supervising long-running, potentially unpredictable agent processes. That's exactly what the BEAM was designed for:

• Lightweight process isolation. Each agent runs in its own BEAM process. If one agent crashes, it doesn't affect others.
• Supervision trees. Symphony uses OTP supervisors to restart failed agents automatically.
• Hot code reloading. You can update Symphony's logic without stopping running agents.
• Fault tolerance. The BEAM's "let it crash" philosophy maps naturally to agent orchestration, where individual agent failures should never bring down the system.

The reference implementation is in Elixir, but the SPEC.md is language-agnostic. OpenAI explicitly invites reimplementations in other languages.

Key Features

Issue Tracker as Control Plane

Symphony continuously polls your issue tracker (Linear is the primary integration; SPEC.md supports others). New tickets automatically get agent workspaces. Ticket status transitions drive the agent lifecycle — backlog, in progress, review, merging, done.

Proof of Work

Agents don't just write code and push. Symphony requires verifiable proof before merging:

• Successful CI passes
• Pull request with description and test evidence
• Walkthrough video of the feature working
• Complexity analysis and review feedback addressed

This is a significant step beyond current coding agents that simply generate code and stop. Symphony agents own the full lifecycle: implement, test, document, review, merge.

Modular, Composable Workflows

Tickets can represent arbitrary units of work — not just code changes. OpenAI uses Symphony for architecture analysis, implementation planning (generating task DAGs), and pure investigation. Agents can also create new tickets when they discover work outside the current task scope.

Continuous Operation

Because Symphony runs on a devbox and never sleeps, it works from anywhere. OpenAI engineers report filing tickets from mobile Linear apps and having agents complete the work before they return to their desks.

📊 At a Glance

Symphony is not a personal coding assistant. It's an organizational orchestrator for teams operating at a scale where human attention is the bottleneck. While Claude Code and OpenClaw excel at interactive coding and personal assistance, Symphony solves the problem of managing dozens of parallel agent sessions from a single issue tracker.

Pros & Cons

🔬 Detailed Analysis

Architecture & Design: 9/10

Symphony's architecture is its strongest feature. The choice of Elixir on the BEAM VM is a defensible engineering decision: each agent runs in its own lightweight BEAM process with true isolation, OTP supervision trees handle automatic restarts on failure, and hot code reloading enables zero-downtime updates. The SPEC.md-first approach means the architecture is well-documented and language-agnostic — OpenAI explicitly invites reimplementations. The proof-of-work requirement is a genuine innovation in the agent space, forcing agents to demonstrate completion through CI passes, test evidence, and walkthroughs rather than simply generating code and declaring done. The modular workflow system (tickets for analysis, planning, implementation, investigation) provides composability that most agent frameworks lack. At 22.6K lines of Elixir, the reference implementation is focused and purposeful.

Ease of Setup: 6/10

Symphony has the highest setup bar of any tool in this review category. It requires a mature engineering organization with established CI/CD pipelines, comprehensive automated test suites, and clear agent policies defined in a WORKFLOW.md file. The Linear API key and Codex credential configuration via dev.exs is straightforward for teams already using these tools, but the harness engineering prerequisites are real. For organizations without these foundations, Symphony won't function as intended. The Elixir dependency is another barrier — most engineering teams don't have Elixir expertise, and while the SPEC.md is language-agnostic, building a production implementation from scratch is a significant undertaking.

Value & Cost: 8/10

Apache 2.0 with zero licensing cost. You pay for the underlying agent API calls (Codex, Claude, etc.) and infrastructure to run the BEAM VM. For organizations already using Linear and Codex, the incremental cost is minimal. The 500% PR increase reported by OpenAI teams suggests the ROI is exceptional for teams that meet the prerequisites. However, the infrastructure investment (harness engineering, CI/CD maturity, agent policies) represents a significant upfront cost that may not be justified for smaller teams.

Scalability & Reliability: 8.5/10

The BEAM VM's process model provides native parallelism and fault tolerance that few agent frameworks can match. Each agent is fully isolated — a crash in one never affects others. Supervision trees provide automatic recovery. Hot code reloading enables updates without stopping running agents. Continuous operation on a devbox means Symphony works 24/7, with OpenAI engineers reporting agents completing work from tickets filed via mobile Linear apps. The 23,500+ GitHub stars and rapid community adoption suggest the architecture is sound, though the April 2026 release means limited long-term production data outside OpenAI.

Documentation & Ecosystem: 7/10

The SPEC.md is the standout documentation asset — a well-written, language-agnostic specification that serves as both documentation and invitation for reimplementation. However, as an engineering preview released in late April 2026, the broader ecosystem is nascent. Few third-party tutorials, integrations, or community tools exist. The Elixir reference implementation is well-structured but assumes familiarity with the Phoenix framework and OTP patterns. The primary integration is Linear-focused, with Jira and GitHub Issues support defined in the spec but less mature in practice. The GitHub community is active (23,500+ stars), but contribution patterns and governance are still forming.

📋 Score Breakdown

Dimension	Score	Notes
Architecture & Design	9/10	BEAM-based, SPEC.md-first, proof-of-work enforcement, modular workflows
Ease of Setup	6/10	High prerequisites (mature CI/CD, test suites, agent policies); Elixir dependency
Value & Cost	8/10	Apache 2.0, low incremental cost for existing Linear/Codex users, high ROI at scale
Scalability & Reliability	8.5/10	Native BEAM parallelism, process isolation, supervision trees, hot code reload
Documentation & Ecosystem	7/10	Excellent SPEC.md; nascent community, Linear-focused, early-stage project

Overall ToolBrain Score: 8.0 / 10

💰 Pricing

Category	Cost	Notes
Software	$0	Apache 2.0 license, fully open source
Agent API Calls	Pay-per-use	Uses Codex or any OpenAI-compatible agent API
Infrastructure	$10-50/month	Devbox or VPS to run the BEAM VM
Issue Tracker	Already owned	Requires Linear, Jira, or GitHub Issues subscription

🎯 Who Should Use Symphony

Symphony is not a personal coding assistant. It's an organizational orchestrator for teams that:

• Have mature CI/CD pipelines and automated testing
• Use structured issue tracking (Linear, Jira, GitHub Issues)
• Operate at a scale where human attention is the bottleneck, not agent capability
• Are comfortable with agents landing PRs autonomously (with review)

For individual developers or small teams, interactive coding agents like Claude Code or Cursor are more immediately useful. For engineering organizations running dozens of parallel agent sessions, Symphony addresses a problem none of the interactive tools solve: the human bottleneck.

🔄 Alternatives

Dimension	Symphony	Claude Code / Cursor	OpenClaw Agents
Orchestration model	Ticket-driven, autonomous	Interactive session	Config-defined pipelines
Human role	Review results	Supervise + steer	Configure + monitor
Agent lifecycle	Full PR lifecycle	Code generation	Task execution
Proof of work	Required (CI, video, tests)	Optional	Not enforced
Parallelism	Native (BEAM processes)	Manual multi-session	Thread pool
Tech stack	Elixir/Erlang	TypeScript/Rust	TypeScript
License	Apache 2.0	Proprietary/MIT	MIT

❓ FAQ

Verdict

Getting Started

Symphony is an engineering preview for trusted environments. Here's how to try it:

Option 1: Build Your Own

OpenAI's recommended approach is to use the spec to build Symphony in any language:

class="language-bash"># Ask your coding agent to implement the spec
# "Implement Symphony according to:
# https://github.com/openai/symphony/blob/main/SPEC.md"

Option 2: Run the Elixir Reference Implementation

class="language-bash">git clone https://github.com/openai/symphony.git
cd symphony/elixir
Set up dependencies
mix deps.get
Configure your issue tracker and agent provider
cp config/dev.exs.example config/dev.exs
Edit config/dev.exs with your Linear API key and Codex credentials
Start Symphony
mix phx.server

Symphony works best in codebases that have adopted harness engineering principles — repositories with clear agent policies defined in a WORKFLOW.md file, comprehensive test suites, and automated CI/CD pipelines.

📖 Related Reads

Review	Summary
OpenCode Review 2026	OpenAI's open-source terminal-native coding agent with multi-model support and 75+ provider options.
Claude Code Review 2026 | 8.2/10	Anthropic's terminal-native autonomous coding agent with 1M-token context and Agent Teams.
Hermes Agent Review 2026 | 8.0/10	Nous Research's self-improving open-source AI agent with a built-in learning loop and skill creation.
OpenClaw Review 2026	Personal AI assistant with 25+ messaging platform integrations and the largest open-source agent ecosystem.

📚 Citations

📝 Change Log

• May 27, 2026 — Full v4 restructuring: added structured sections (score hero, TL;DR, quick links, pros/cons, detailed analysis, score breakdown, pricing, FAQ, related reads, citations).

← Back to all posts