OpenAI Symphony Review: Redefining Agent Orchestration with Issue Trackers

From a single issue to fully automated PRs

An OpenAI engineer created three issues in the Linear mobile app while offline; by the time he returned, the corresponding PRs had completed CI and entered review without any terminal interaction. This experience is powered by a system called Symphony.

OpenAI open‑sourced Symphony in March 2026 together with a detailed SPEC.md. It is not a product but a formalized workflow specification that agents execute. Within three weeks the repository earned over 15 K GitHub stars, and Linear founder Karri Saarinen noted a sharp spike in workspace creation.

The team originally set an aggressive goal: the entire codebase would be generated by Codex, with no human‑written code. Their methodology was documented in the Harness Engineering blog, effectively turning “Codex as a teammate” into a repeatable practice.

As agents took on more tasks, engineers found themselves monitoring three to five concurrent Codex sessions, which quickly became unsustainable. The core insight was that the true unit of work is the issue, not the interactive session.

Issue‑centric orchestration

Symphony treats each active Linear issue as a state machine and launches a dedicated agent workspace for it. The workspace runs until the issue reaches a terminal state (Done, Cancelled, etc.). New issues are automatically assigned an agent, leveraging the existing priority, ownership, and deadline metadata that teams already maintain.

This design satisfies the simple goal stated in the spec: “For every open task, ensure there is an agent running in its own workspace.”

Because an issue can spawn multiple PRs across repositories or represent pure research, the PR is no longer the endpoint. Agents may also create new issues when they encounter sub‑problems that merit separate backlog items.

Task dependencies are supported: an agent can analyze a codebase, devise a plan, break it into dependent subtasks, and execute them in order. For example, a React upgrade can be marked as “depends on Vite migration,” causing the agent to wait for the Vite task to finish before proceeding.

SPEC.md: a language‑agnostic contract

The repository’s centerpiece is a 2 000‑line SPEC.md that defines the orchestration state machine and workspace security boundaries. Although the reference implementation is written in Elixir, the spec itself is language‑neutral.

Using Codex, the team generated parallel implementations in TypeScript, Go, Rust, Java, and Python to surface ambiguities in the spec and refine it, similar to how TCP/IP or HTTP/1.1 specifications are implemented across the ecosystem.

Elixir was chosen for the reference because its concurrency model naturally fits large‑scale agent orchestration. When code‑generation costs approach zero, language choice shifts from “who can implement it” to “who excels at the target scenario.”

The majority of the 15 K stars were attracted to the spec rather than the Elixir code, highlighting community interest in the formal contract.

Opening a spec raises questions about what “open‑source” means for a specification: can a forked SPEC.md be a contribution? The Apache 2.0 license applies, but mechanisms for community‑driven spec evolution remain unclear.

WORKFLOW.md and explicit processes

Each team also maintains a WORKFLOW.md that documents its development pipeline (branching, issue status updates, PR creation, review, demo video, etc.). This documentation, previously implicit, becomes mandatory for agents to follow, making hidden processes visible to newcomers and to the agents themselves.

Impact: 500% PR increase

In the first three weeks after deployment, some OpenAI teams saw a 500 % rise in PR volume. With the cost of assigning work to agents reduced to near‑zero, exploratory tasks—refactoring, hypothesis testing, low‑value optimizations—can be issued as issues for agents to attempt and discard if unproductive.

Product managers and designers can now submit issues directly in Symphony and receive a demo video of the feature in the product, bypassing the need to touch the code repository.

Symphony also automates the “last mile” of CI: after a PR is submitted, the system handles rebase, conflict resolution, flaky test retries, and merges without human supervision.

Scaling challenges and guardrails

Moving from interactive sessions to ticket‑level assignment removes the ability to adjust an agent’s direction mid‑run. If an agent drifts, the workspace may already have completed its cycle before the issue is noticed.

The team responded by adding guardrails and end‑to‑end tests to the toolchain, allowing agents to detect and correct failures autonomously.

Agents handle routine implementation work, while ambiguous or judgment‑heavy tasks still require engineers to launch Codex sessions directly.

State‑machine limits and goal‑oriented agents

Early Symphony designs treated agents as strict state‑transition nodes (receive issue → generate code → open PR → finish). This underestimated Codex’s capabilities, which can read review comments, respond to CI failures, close stale PRs, and generate cross‑repo changes.

The later approach gives agents a high‑level goal (“resolve this issue”) instead of a fixed sequence, letting the model reason and choose its own path within defined boundaries.

Codex App Server: programmatic control

Symphony uses Codex’s App Server mode, a headless JSON‑RPC interface that allows programmatic thread management and turn switching, avoiding CLI or tmux interactions.

The scheduler consumes line‑delimited JSON events, restarts crashed agents, and retries timed‑out sessions automatically.

For security, agents need to read/write Linear without exposing the access token. This is achieved with a custom tool called linear_graphql that agents invoke to interact with Linear while the token remains hidden.

Evolution of Symphony

The first version ran a Codex session inside tmux, polling Linear for new tasks. The second version integrated this logic into OpenAI’s internal main project, leveraging an existing agent toolchain. After internal adoption proved successful, the core concepts were extracted into an independent SPEC.md and open‑sourced, with Elixir chosen for its concurrency strengths.

External vs. internal orchestration

Symphony’s approach is an external orchestration layer: it reuses the team’s existing Linear setup, minimizing migration cost but inheriting platform limitations.

By contrast, the contemporaneous project Multica builds a self‑contained platform that embeds the entire agent workflow, offering full control at the expense of requiring new tooling and habits. (https://github.com/multica-ai/multica)

Both solutions answer the same question—what relationship should agents have with the team? The external model treats agents as high‑level assistants; the internal model treats them as full team members with their own context and autonomy.

From “internal combustion” to agent‑dense engineering

The 500 % PR surge is less about raw numbers and more about a paradigm shift: work initiation no longer requires an engineer; agents can directly participate in the workflow, allowing PMs and designers to submit issues that result in functional demos.

This mirrors the industrial revolution’s transition from human‑powered to machine‑powered production—not making engineers code faster, but outsourcing execution to agents.

Initially agents accelerated routine tasks (code completion, test generation). Over time they began handling complete work units, from issue creation to PR generation and demo delivery, reshaping who initiates work, makes decisions, and owns outcomes.

The engineer’s new role

Engineers now act as system designers: building guardrails, end‑to‑end tests, and workflow definitions that enable agents to operate autonomously. They no longer perform code reviews or monitor CI; instead they design mechanisms that let agents perform those actions themselves.

This shift demands new skills—process modeling, boundary design, and exception handling—beyond traditional technical judgment.

Open questions

Will tools like Linear, Notion, or Jira become the operating systems of the agent era? The answer remains uncertain, but it is clear that when agents can independently resolve issues and specifications become first‑class open‑source artifacts, the definition of an engineer will evolve.

Conclusion

Symphony tackles current engineering challenges while pointing toward a larger transformation: tools redefining the limits of work. The community is still exploring how agent‑centric workflows will reshape software development.