OpenAI shipped Symphony at the end of April 2026, an open-source specification that wires Codex agents directly into your issue tracker. A task in Linear becomes a dedicated agent workspace, a running pull request, and a review item, with no human pushing the rollout button in between. This guide walks through what Symphony actually does, why mobile is the unexpected unlock, and how to reproduce the pattern in your own automation stack.
The pitch is straightforward. You move a ticket on a board, a Codex agent picks it up on a remote devbox, writes the change, opens a pull request, and waits for review. If the agent crashes mid-run, Symphony restarts it. If the ticket changes, the agent picks up the new spec on the next poll. The control plane is your existing project tracker, not a new dashboard. The first internal teams at OpenAI reported a 500% jump in landed pull requests in the first three weeks of using it.
The 30-Second Version
What Symphony Actually Does
Symphony is a thin layer with strong opinions. It does not generate code itself, and it does not replace Codex. It binds the two ends of the loop, the human-readable task board and the agent that actually ships, into a single contract:
- Polls the issue tracker for new or changed tasks on a schedule.
- Spins up a fresh devbox per task, with the repo cloned and tools wired in.
- Hands the ticket spec to a Codex agent and lets it run end to end.
- Opens a pull request, links it back to the ticket, and pings the human reviewer.
- Restarts crashed runs and re-syncs when the ticket gets edited mid-flight.
The interesting design choice is that Symphony does not try to be the only system. It treats the issue tracker as the source of truth, and it treats the agent runner as a black box. That keeps the spec small enough to fork.
Why a Spec, Not a Product
OpenAI explicitly said they will not maintain Symphony as a standalone SaaS. The spec exists so that other teams can study, fork, or rebuild it on their own stack. That choice matters for three reasons:
You keep your tracker
Most teams already live in Linear, Jira, or GitHub Issues. A new product would force a migration. A spec lets you bolt the agent loop onto whatever you already use.
You pick the agent runner
Symphony is written for Codex, but the contract is general. You can plug Claude Code, an open-weight coder, or a self-hosted runner in the same slot. The pattern survives a model swap.
The hardest part is the harness, not the model
The 500% gain at OpenAI did not come from a smarter Codex. It came from removing the human in the "assign, watch, restart, nudge, re-prompt" loop that drains every agent project. We covered that broader shift in the orchestration era of agentic coding, and Symphony is the cleanest reference implementation of it so far.
The model writes the code. The harness writes the company. Symphony is OpenAI publishing the harness.
The Mobile Unlock Nobody Saw Coming
The detail that made the launch story memorable is small. One OpenAI engineer landed three pull requests from a cabin on weak Wi-Fi, working entirely from the Linear mobile app. No laptop, no SSH session, no terminal. Just dragging tickets on a phone while agents ran on remote devboxes and opened PRs.
That is the mobile thesis we have been pushing in posts like Hermes Workspace Mobile and agent orchestration on a phone, and Symphony makes it concrete. The phone is not where the work happens. The phone is where the work gets approved, redirected, and reviewed. The work happens on a devbox at full GPU speed.
Why This Matters for Mobile Automation
The Symphony Loop, Step by Step
| Stage | Where it runs | Who owns it |
|---|---|---|
| Ticket created or edited | Linear (mobile or web) | Human |
| Poll and dispatch | Symphony controller | Spec |
| Devbox provision | Cloud devbox per task | Spec |
| Code change | Codex agent inside devbox | Agent |
| Pull request opened | GitHub | Agent |
| Review and merge | GitHub (mobile or web) | Human |
The two human stages, ticket and review, are both mobile-friendly by default. Everything in between runs unattended. That is the shape of a workflow you can drive from a phone in a cabin, and it is the shape we expect more agent harnesses to adopt over the next few months.
How to Build a Symphony-Style Loop on Your Stack
You do not need OpenAI's exact spec to get most of the win. The loop is composable and you can stand up a working version this week:
- 1Pick the tracker you already use. Linear, Jira, GitHub Issues are all fine. The only requirement is a webhook or polling API.
- 2Pick an agent runner. Codex, Claude Code, or an open-weight coder behind a thin sandbox is enough to start. Make sure each run gets its own clean workspace.
- 3Write a small dispatcher. Poll the tracker, match a label like "agent-ready", spin up a devbox, hand the ticket to the agent, and post a PR link back to the ticket.
- 4Add a restart policy. Crashes happen. The dispatcher should re-queue a stalled run rather than asking a human to babysit.
- 5Wire the review step into your existing PR workflow. Mobile reviewers benefit most when the PR is small, well-scoped, and linked to the original ticket.
If your team already runs n8n, the dispatcher is a single workflow with a webhook trigger and a HTTP node that talks to your devbox provider. We walk through the n8n side of long-running automations in our n8n on ECS Fargate load test results, which is the same shape of infrastructure Symphony assumes.
Where Symphony Sits Next to Other Orchestrators
Symphony is not the only agent orchestrator that landed in late April 2026, and it is worth seeing the contrast:
- Sakana Conductor learns by RL which agent should handle each subtask. It is a router for a pool of agents.
- Hermes Workspace Mobile puts the approval and routing surface on the phone, with workers in the cloud.
- OpenAI Symphony wires the issue tracker to the agent runner and reduces the human work to ticket and review.
These three designs do not compete. They stack. A team can use Symphony to dispatch tickets, Conductor to pick the right model per subtask, and a Hermes-style mobile surface to approve sensitive steps. The picture we sketched in Sakana Conductor and multi-agent orchestration gets a much more concrete top half with Symphony in place.
Five Practical Use Cases
Bug triage that ships fixes overnight
Tag inbound bug tickets "agent-ready". The dispatcher provisions a devbox, the agent reproduces the bug, writes a failing test, fixes it, and opens a PR. You wake up to a queue of small, reviewable changes.
Mobile-first product backlog
A founder on the road can drag a feature ticket on Linear, see a PR appear an hour later, and review it from the same phone. The laptop becomes optional for a real chunk of the engineering loop.
Documentation that keeps up with code
A standing "docs catch up" ticket re-opens after every merged PR. The agent reads the diff, updates the relevant docs page, and opens a follow-up PR. Drift becomes a solved problem.
Refactor sweeps that never block a sprint
Long-tail refactors (rename a config key, swap an import, normalize an enum) sit in a backlog tagged for the agent. The dispatcher works the queue between higher-priority tickets without touching human capacity.
Customer-reported issues with full audit trail
Each ticket carries the customer ID, the agent run, the PR, and the review. Compliance gets a single thread per fix without anyone building a custom dashboard.
The Bottom Line
Symphony is the moment the "ticket to agent to PR" loop moved from a clever demo to a documented spec with a 500% number attached. The release is small in line count and large in implication. The control plane for agent work is your issue tracker, and once that is true, the device a human reaches for becomes a phone.
The question to take into your next planning session is simple. If every "agent-ready" ticket on your board ran to a pull request without a human in the middle, what would your team build with the time you got back?