OpenAI Symphony: Let Teams Manage Projects, Not Supervise AI Coding

1. A Different OpenAI Project

On 26 February 2026 OpenAI added a low‑key repository openai/symphony on GitHub. The README describes Symphony as a system that turns project work into isolated, autonomous implementation runs, allowing teams to manage work instead of supervising coding agents.

2. Core Idea: Turn Humans into PMs

Current AI coding tools (Cursor, Copilot, Codex) require developers to watch the AI line‑by‑line, intervene, and correct errors. Symphony aims to break this model. Humans act like project managers: they create tickets, set priorities and milestones in Linear, while Symphony polls the board, dispatches AI agents, isolates their runs, validates results and submits PRs. The approach assumes tasks are well‑defined, boundaries clear, and the codebase is "machine‑friendly" – a practice the authors call Harness Engineering .

3. Full Lifecycle of an Implementation Run

Polling – Every 30 seconds Symphony scans Linear for tickets in Todo or In Progress and checks that prerequisite dependencies are satisfied.

Sandbox Isolation – Creates a dedicated workspace for each ticket; up to ten agents can run concurrently without interfering.

Agent Execution – Starts a Codex subprocess and communicates via a stdio‑based JSON‑RPC protocol; each run can have up to 20 turns with context carried across turns.

Proof of Work – The agent must provide CI pass logs, unit‑test results, PR‑review feedback and a textual description of the changes.

Landing – After verification the PR is merged and the ticket automatically moves to Done .

If a run fails, Symphony retries after 10 seconds, then uses exponential back‑off up to a five‑minute cap. An agent that produces no output for five minutes is terminated and reassigned.

4. Harness Engineering: Making Codebases Machine‑Readable

The Symphony team admits most codebases are not ready for autonomous agents. They propose three requirements:

Hermetic Testing – Tests must be fully self‑contained and runnable locally without external services.

Machine‑Readable Docs – Provide shell scripts or a Makefile so the agent can discover how to build, test and deploy without implicit knowledge.

Modular Architecture – Minimize side effects so an agent can safely modify a module without risking unrelated parts; tightly coupled “spaghetti code” hinders autonomous operation.

Many teams treat the adoption of Symphony as an opportunity to repay technical debt.

5. Why Elixir?

About 94.9 % of Symphony’s code is written in Elixir, with a few Python helper scripts. The choice is intentional: the framework’s core challenges are high concurrency, long‑running task management and fault tolerance—areas where the Erlang/BEAM VM excels.

Elixir’s supervision tree naturally manages hundreds of potentially failing long‑running tasks; each agent runs as an independent process that automatically restarts on crash, isolating failures. The entire scheduling logic consists of roughly 258 lines of Elixir code , with no database dependency—state is recovered by re‑polling Linear after a restart.

// Initialization handshake
client → initialize (client info + capabilities)
client → initialized
client → thread/start (approval policy, sandbox mode, work dir)
client → turn/start (thread ID, rendered prompt, workspace path)

6. WORKFLOW.md: Version‑Controlling Agent Behavior

Each repository includes a WORKFLOW.md file that configures the agent. The file combines YAML configuration with a Markdown prompt template and is stored alongside the code, making the agent’s behavior a version‑controlled artifact.

Linear project slug ( project_slug)

Monitored ticket states ( active_states)

Agent system prompts and task templates

Workspace lifecycle hooks (e.g., after_create, before_run)

Concurrency limits, retry strategy, timeout settings

Because WORKFLOW.md lives in the repository, any change is subject to code review and can be reloaded at runtime without restarting Symphony. Invalid configurations automatically roll back to the last valid version.

---
tracker:
  kind: linear
project_slug: my-project
active_states: [Todo, In Progress]
agent:
  max_concurrent_agents: 5
  max_turns: 20
---
# Agent Prompt Template
You are a professional software engineer.
Please complete the task: {{ issue.title }}
Details: {{ issue.description }}

7. UBS Perspective: AI Moves from Conversation to Execution

"Symphony may mark a major shift in how AI is applied in the workplace—from chat‑based interfaces to tools that can directly execute tasks within enterprise workflows." – UBS analyst

Most enterprises currently use AI as an assistant (e.g., Copilot for code completion, ChatGPT for documentation). Symphony represents the next stage: AI replaces parts of the workflow, taking ownership of the entire task from assignment to delivery.

Analysts note that project‑management tool vendors such as Atlassian (Jira/Confluence) stand to benefit, as frameworks like Symphony reinforce the central role of ticket systems in software development.

8. Key Insights

Stop watching AI write code; developers become project architects.

Harness Engineering is required for AI autonomy—codebases must be machine‑readable. WORKFLOW.md brings agent behavior under version control, extending "infrastructure as code" to AI governance.

Proof of Work enforces quality standards for automated contributions.

Symphony is an engineering preview, not a production‑ready solution.

Conclusion

Symphony’s value lies less in the number of PRs it can auto‑merge and more in how it concretely maps a path toward autonomous AI development. While harness engineering demands upfront effort and sandbox security remains a real challenge, the framework shows that future engineers will spend increasing time enabling AI to work effectively rather than writing every line of code themselves.