Why OpenAI Built Symphony and Gave It Away for Free

BBetter Stack
Computing/SoftwareManagementInternet Technology

Transcript

00:00:00This is OpenAI's Symphony, an open-source tool for orchestrating long-running agents using an
00:00:05existing issue tracker like Linear to help your agent autonomously complete tasks without any
00:00:10human supervision. But why doesn't an agent have to build it from scratch before you can use it?
00:00:14Does it only support Codex CLI? And is this the beginning of more
00:00:18open-source tools from OpenAI? Hit subscribe and let's find out.
00:00:25Symphony only exists because OpenAI hit a human-attention bottleneck, which means engineers
00:00:30could only supervise 3-5 Codex sessions concurrently before context switching began
00:00:35to negatively affect productivity. This, of course, wasn't going to scale. So guess how OpenAI fixed
00:00:41the fast-agent-slow-human-managers problem? They got rid of the human-managers. Kind of.
00:00:47Because with Symphony, humans put tasks on a board, a new agent will be spun up to complete that task,
00:00:52and the agent will only involve the human if there's something to review.
00:00:55But how does Symphony compare to similar tools like Multica and Conductor? Well,
00:00:58watch the demo and that'll be made crystal clear. Before we start, however, I just want to say
00:01:03Symphony has the weirdest installation process I've ever seen in my life. Or it could be the
00:01:07most genius way to install something. We'll get to that later.
00:01:10First, however, let's go through a basic example. So I have Symphony running,
00:01:14polling for tasks in Linear to work on. And in Linear, I'm going to create a new issue,
00:01:18which will be to build a Hello World app using TypeScript and BUN.
00:01:22Right now, Symphony isn't configured to work on backlog tasks. So I'll change the status to To-Do
00:01:27and hit Create Issue. Remember the ID of the task, which is SYN7.
00:01:31So after a while, Symphony picks up on the ID of that task. And a few seconds later,
00:01:36we have a GraphQL validation error, which isn't a big deal and is very easy for Codex to fix.
00:01:41But after that, we can see that Codex has completed the work, has changed the issue
00:01:45from To-Do to Done, and has left a comment here from Symphony. Which means if we go to
00:01:49our Symphony workspaces directory, we'll talk more about that later, we can see we have a new
00:01:53workspace with the same ID as our issue. And if we go into that workspace, we have the list
00:01:58of files created for the Hello World TypeScript BUN app. And if we go into the source directory,
00:02:04we can see that the code for the app is over here. And that's essentially Symphony in a nutshell.
00:02:08Now let's go through how to set it up. So there are two ways to install Symphony
00:02:12according to this repo. Option two, which is what we're used to, we set up Elixir,
00:02:16clone the repo, then build the code and run it using the existing workflow file.
00:02:20Option one, however, is possibly the weirdest or most forward thinking way to install something.
00:02:25You just basically give your coding agent this prompt, and it will read the spec file,
00:02:30which is more than 2000 lines long. But it basically gives your agent detailed
00:02:34instructions on how to build Symphony, which is wild because if everyone went down this route,
00:02:39no two versions of Symphony would look the same. Some people will have different features in
00:02:43different languages, which would be chaos for open AI to maintain and support.
00:02:47But it's also kind of genius because if you built your own version of Symphony,
00:02:51you would feel responsible for it. You'd fix the bugs, you'd add the features,
00:02:55and you'd essentially maintain it. And if you didn't want Symphony to use linear or
00:02:59codecs, then that's up to you. Someone built a Go version of Symphony that runs on Charm CLI,
00:03:04and someone else built one that was powered by the Claude SDK. I wasn't that creative,
00:03:09so I put the default prompt into codecs using GPT 5.5 Low Effort, and it gave me a Python version
00:03:15of Symphony, which makes sense because NLM's are very good at Python. But once that's done,
00:03:19you'll need a linear personal API key, which you can get from security and access,
00:03:23and you can create one by clicking over here. Then you'll have to add that key to your work profile,
00:03:28which is a file that tells Symphony how to do its job, containing some YAML front matter,
00:03:32which of course has the API key, active states for the agent to know when it can work on a task,
00:03:37as well as the workspace root and the codecs command, which is the shell command Symphony
00:03:42uses to launch a coding agent. And below that is the markdown prompt sent to the coding agent
00:03:46for each issue. You can access OpenAI's workflow in D file from their repo if you're interested.
00:03:51But as of right now, this workflow isn't fit for a real project. Say I wanted to make changes to
00:03:56my film emulation app that I've been working on. I would need to add a create-after hook, which runs
00:04:01after Symphony creates a workspace for an issue, and this hook will first clone the repo to the
00:04:06workspace directory, and then check out to a new branch in that repo. I've also added a run-after
00:04:10hook, which runs after codecs finishes working on the issue. So this one stages the files, then
00:04:15creates a new commit before pushing the branch and creating a new pull request with these values.
00:04:20So now if I run Symphony using UV, which was also acquired by OpenAI, but that's a topic for another
00:04:25video, it's polling for new issues. So now if I create a new issue to update the readme, just in
00:04:30the section that shows batch processing, to use a wildcard instead of showing multiple files, again,
00:04:35I'll change it from backlog to to-do, then hit create issue. Now Symphony has picked up on that
00:04:40issue. And if I look at the Symphony workspaces directory, we can see there's a new folder matching
00:04:45our issue ID, which contains the cloned project. And now that Symphony has finished working on the
00:04:49issue, it's changed the status to done and has created a new PR with a link to the linear ticket
00:04:54and the exact change that I requested. Now, of course, I could change my Symphony code to add a
00:04:59better PR description and to put a link to the PR in the comments, but I'm sure that's very easy for
00:05:04Codex to do. So that's a quick overview of Symphony. If you're already comfortable with or work at a
00:05:08company that uses linear, then you'll feel right at home with the interface. And if you're a Codex user,
00:05:13then you can use your skills, MCP tools and plugins that you already have installed. I personally don't
00:05:18use Codex, but I can definitely see the vision OpenAI we're going for with Symphony. Imagine
00:05:22you had a team of developers all working on the same project with AI. Instead of having their own
00:05:28personal harness with their own workflow, there can be a central agent with central skills, central
00:05:33tools, central workflows and plugins. And each developer can communicate with that by giving
00:05:37it a task and they can see what other developers are working on, what prompts they've used and can
00:05:41see at a glance what other features might affect the feature that they're working on. Even though
00:05:46it's very difficult to come up with a feature that won't touch another part of the code that someone
00:05:49else is working on. But as cool as Symphony is, in my opinion, Multica does a better job because it's
00:05:54easier to set up, create and add different agents, and you can even schedule tasks. Nevertheless,
00:05:59I completely see a place for Symphony. It's kind of like the bare bones version of Multica where you
00:06:04can add the exact features you want instead of having a product that is built for you. So think
00:06:08of Symphony like the Pi harness and other tools like Multica or Conductor as cloth code. And if
00:06:13you don't know anything about Multica, then check out this video, which goes through everything you
00:06:18need to know about it.

Key Takeaway

Symphony solves the human-attention bottleneck by delegating agent orchestration to issue trackers like Linear, allowing OpenAI engineers to manage more than 5 concurrent Codex sessions without manual supervision.

Highlights

  • OpenAI engineers hit a human-attention bottleneck where supervising more than 3 to 5 Codex sessions concurrently caused productivity-killing context switching.

  • Symphony automates the agent-human workflow by using Linear issue statuses to trigger autonomous task execution and human review only when necessary.

  • The tool offers a non-traditional installation method where users provide a 2,000-line spec file to a coding agent to generate a custom version of the software.

  • Symphony supports custom hooks such as create-after for cloning repositories and run-after for staging files and pushing pull requests automatically.

  • A workflow configuration file uses YAML front matter to define API keys, active issue states, and the specific shell commands used to launch coding agents.

Timeline

Solving the human-attention bottleneck

  • Productivity drops significantly when a single engineer attempts to supervise more than 5 Codex sessions simultaneously.
  • Symphony eliminates the need for constant human management by spinning up agents based on task board updates.
  • Human intervention is reserved exclusively for the final review stage of a completed task.

The rapid pace of AI agents creates a fast-agent-slow-human problem where the human becomes the scaling limit. Symphony acts as an orchestration layer that monitors Linear boards for new issues. When a task status changes to To-Do, the system automatically initializes an agent to resolve the specific issue ID without manual hand-holding.

Automated task execution and workspace management

  • Symphony polls Linear for tasks and creates local workspace directories matching the issue ID.
  • The system successfully generates code for specific requests like a TypeScript and BUN Hello World app.
  • Agents automatically update the status of Linear issues from To-Do to Done upon completion.

In a live demonstration, the system identifies issue SYN7 in Linear and resolves a GraphQL validation error independently. It creates a dedicated directory for the project and populates the source folder with the requested files. This workflow ensures that every task has a traceable local footprint and an updated status on the project management board.

The agent-led installation process

  • Users can build Symphony by feeding a massive spec file to a coding agent rather than using traditional build tools.
  • This installation method results in unique versions of Symphony tailored to different languages and SDKs like Go, Python, or Claude.
  • Configuration requires a Linear personal API key and a work profile file containing YAML front matter.

The primary installation method involves an agent reading a 2,000-line specification to reconstruct the tool, which encourages users to take ownership of the code they generated. Examples include a version running on Charm CLI and another powered by the Claude SDK. The work profile serves as the instruction manual, defining the workspace root and the exact markdown prompt sent to the agent for every new issue.

Custom hooks and production workflows

  • Create-after hooks allow the system to clone existing repositories and check out new branches before work begins.
  • Run-after hooks automate the staging, committing, and pushing of code to create pull requests.
  • Integration with the UV package manager facilitates the polling of new issues for existing projects.

To make Symphony viable for real-world projects, users must implement hooks that handle version control tasks. A film emulation app example demonstrates how the system clones a repo, updates a readme file using wildcard characters, and submits a PR with a direct link to the Linear ticket. This automation covers the entire lifecycle from issue identification to the final pull request.

Centralized agent orchestration for teams

  • Symphony provides a central harness for teams to share skills, tools, and plugins across multiple developers.
  • The platform allows team members to see which prompts and features others are using in real-time.
  • Compared to tools like Multica, Symphony functions as a bare-bones framework for building highly customized orchestration environments.

The vision for Symphony is a unified agent infrastructure where developers avoid isolated workflows. By centralizing the AI harness, teams can monitor how different features interact and avoid overlapping code changes. While competitors like Multica or Conductor offer more out-of-the-box scheduling and ease of use, Symphony is designed for those who need a modular, 'Pi-harness' style foundation to build their own specific features.

Community Posts

View all posts