Openai Symphony Autonomous Agents

# OpenAI Symphony

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

Symphony turns project work into isolated, autonomous implementation runs, allowing teams to **manage work** instead of **supervising coding agents**. Instead of watching an agent code, you define tasks (e.g. in Linear), and Symphony spawns agents that complete them, provide proof of work (CI status, PR reviews, walkthrough videos), and land PRs autonomously.

---

## What Symphony Does

- Monitors a work tracker (e.g. Linear) for tasks
- Spawns isolated agent runs per task (using Codex or similar)
- Each agent implements the task, opens a PR, and provides proof of work
- Engineers review outcomes, not agent sessions
- Works best in codebases using [harness engineering](https://openai.com/index/harness-engineering/)

---

## Installation Options

### Option 1: Ask an agent to build it

Paste this prompt into Claude Code, Cursor, or Codex:

```
Implement Symphony according to the following spec:
https://github.com/openai/symphony/blob/main/SPEC.md
```

### Option 2: Use the Elixir reference implementation

```bash
git clone https://github.com/openai/symphony.git
cd symphony/elixir
```

Follow `elixir/README.md`, or ask an agent:

```
Set up Symphony for my repository based on
https://github.com/openai/symphony/blob/main/elixir/README.md
```

---

## Elixir Reference Implementation Setup

### Requirements

- Elixir + Mix installed
- An OpenAI API key (for Codex agent)
- A Linear API key (if using Linear integration)
- A GitHub token (for PR operations)

### Environment Variables

```bash
export OPENAI_API_KEY="sk-..."           # OpenAI API key for Codex
export LINEAR_API_KEY="lin_api_..."      # Linear integration
export GITHUB_TOKEN="ghp_..."           # GitHub PR operations
export SYMPHONY_REPO_PATH="/path/to/repo"  # Target repository
```

### Install Dependencies

```bash
cd elixir
mix deps.get
```

### Configuration (`elixir/config/config.exs`)

```elixir
import Config

config :symphony,
  openai_api_key: System.get_env("OPENAI_API_KEY"),
  linear_api_key: System.get_env("LINEAR_API_KEY"),
  github_token: System.get_env("GITHUB_TOKEN"),
  repo_path: System.get_env("SYMPHONY_REPO_PATH", "./"),
  poll_interval_ms: 30_000,
  max_concurrent_agents: 3
```

### Run Symphony

```bash
mix symphony.start
# or in IEx for development
iex -S mix
```

---

## Core Concepts

### Isolated Implementation Runs

Each task gets its own isolated run:
- Fresh git branch per task
- Agent operates only within that branch
- No shared state between runs
- Proof of work collected before PR merge

### Proof of Work

Before a PR is accepted, Symphony collects:
- CI/CD pipeline status
- PR review feedback
- Complexity analysis
- (optionally) walkthrough videos

---

## Key Elixir Modules & Patterns

### Starting the Symphony supervisor

```elixir
# In your application.ex or directly
defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      Symphony.Supervisor
    ]
    Supervisor.start_link(children, strategy: :one_for_one)
  end
end
```

### Defining a Task (Symphony Task struct)

```elixir
defmodule Symphony.Task do
  @type t :: %__MODULE__{
    id: String.t(),
    title: String.t(),
    description: String.t(),
    source: :linear | :manual,
    status: :pending | :running | :completed | :failed,
    branch: String.t() | nil,
    pr_url: String.t() | n