Symphony, set beside the tools you know
Symphony is a set of rules, kept in a GitHub repository, that let many workers, people and AI agents alike, share one queue of work without taking the same task, losing stalled work or landing anything unchecked. Those rules are not only for code. Below, the same six powers are set beside the tools people already use in seven kinds of work. For what that looks like in practice, see the use cases.
The six powers
One taker per task
A task is claimed by being first to create its branch, and GitHub refuses the second, so two workers, human or AI, can never hold the same one.
Stalled work comes back
A claim with no new work for about a day is released and its branch renamed, so the next worker starts from where the last one stopped.
Overlaps are seen early
Each claim lists the files it will change, and the board says which open work meets which, and in what order it should land.
Nothing lands unchecked
Work arrives only as a pull request that passes the repository's required check.
No server, flat price
The bookkeeping runs in GitHub Actions with no AI call, and the AI work runs on a flat Claude plan, within its five-hour and weekly limits, never an API key.
The record is the work
The queue, the plan, the work and its history are issues, branches and commits that anyone with access can read.
Why it lives in GitHub, Claude Code and Chrome
Building on tools people already have gives four things a separate app would have to win on its own.
Trackable history
Every claim, plan, change and review is a commit or a comment, kept for as long as the repository is.
Shareable
The project is a repository: invite a person and they have the queue, the instructions and the shared memory, on their own Claude account.
Visible
The board, the control panel and the pull requests show who holds what and what is ready, without asking anyone.
Extensible
A new worker is a short file, a new kind of work is an issue form, and anything GitHub Actions can run can join in.
Read this as a comparison of designs, not of results. Each tool's column comes from its own public documents as of October 2026, and a tool changes faster than a page: if a cell is wrong, tell us. No benchmark result is quoted here; Symphony's own measurements are still running. Symphony is pre-release, and each grid ends with what the others do better.
Coding agents working together
Several AI coding agents, and the people beside them, changing one code base at the same time.
| What it does | Symphony | GitHub Copilot coding agent | Claude Code agent teams | GitHub Agentic Workflows | Codex cloud, Devin |
|---|---|---|---|---|---|
| Two agents can never take the same task | YesGitHub refuses a second push of the task's branch | NoA person assigns each task; parallel sessions have no lock | PartlyA file lock, on one machine only | YesA scheduler grants one claim per work item | PartlyA person, or an integration, starts each task |
| Stalled work is freed, and what was done is kept | YesAfter about a day with no commit; the branch is renamed, not deleted | NoNo claim to free; a session stops at 59 minutes | NoNot stated | PartlyOnly once the run is known to have ended; never by time | NoNo claim to free |
| People's own sessions and cloud agents follow one rule | YesLocal and cloud sessions, routines and agents in GitHub Actions | NoAgent sessions only | NoTeammates of one session | NoActions runs only; a person can read the queue, not claim | NoThe vendor's agents only |
| Warns when two tasks change the same files | YesThe board lists each shared file and the order to land in | No | PartlyYou tell teammates to own different files | NoDoes not order different work on the same files | No |
| Keeps running with your computer switched off | YesWorkers run in GitHub Actions | YesOn GitHub's runners | NoOne session on your machine | YesOn GitHub's runners | YesIn the vendor's cloud |
| AI work billed by a flat plan, not by the token | YesOne Claude Pro or Max plan; no API key | NoAI credits per use | YesYour Claude plan | NoAn API key or Copilot credits; the Claude plan's token is refused | PartlyCodex comes with ChatGPT plans; Devin bills units of work |
Where they are ahead. Copilot, Codex and Devin need nothing installed and give each task a fresh machine and a hosted screen to steer it. GitHub Agentic Workflows sandboxes its agents behind a network allowlist. Agent teams pass live messages between teammates. Symphony has none of these.
Tracking a team's work
A queue of tasks that people, and now AI agents, pick up, work and finish.
| What it does | Symphony | Jira | Linear | Trello | Asana | GitHub Projects |
|---|---|---|---|---|---|---|
| A shared queue anyone on the team can add to | YesGitHub issues labelled todo | Yes | Yes | Yes | Yes | Yes |
| Only one person or agent can hold a task | YesEnforced by git, not by convention | PartlyOne assignee field; nothing stops a second worker | PartlyOne assignee field; nothing stops a second worker | NoSeveral members per card | PartlyOne assignee field; nothing stops a second worker | NoSeveral assignees per issue |
| A task left idle goes back to the queue by itself | YesAfter about a day with no commit, with its work kept | PartlyIf someone writes an automation rule for it | PartlyCan close stale issues; does not hand them back | NoBy hand | PartlyIf someone writes a rule for it | PartlyIf someone writes a workflow for it |
| AI agents do the work, not only track it | YesClaude Code takes the task and opens the pull request | PartlyThrough Atlassian's agents and integrations | PartlyIssues can be assigned to coding agents | No | PartlyAI rules inside Asana | PartlyAn issue can be assigned to Copilot |
| Warns when two tasks will change the same files | YesFrom each task's plan and its pull request | No | No | No | No | No |
| The task, the work and its history are one record | YesIssue, branch and pull request, in git | PartlyLinked to code through integrations | PartlyLinked to code through integrations | No | No | YesIssues and pull requests on GitHub |
| Roadmaps, sprints, reports and a polished screen | NoA plain board and a control panel | Yes | Yes | PartlyBoards, with power-ups | Yes | PartlyBoards, tables and roadmaps |
| What it costs | Free bookkeeping; a Claude plan for the AI work | Free tier, then per seat | Free tier, then per seat | Free tier, then per seat | Free tier, then per seat | Free with GitHub |
Where they are ahead. Every tracker here has a far better screen, roadmaps, sprints, reports and mobile apps. Symphony does not try to replace them for planning: it is the part that lets several agents and people work a queue without taking the same task, and it can sit under GitHub Projects.
Automating work across tools
Something happens or the clock ticks, and work gets done without anyone pressing a button.
| What it does | Symphony | Zapier | Make | n8n | GitHub Actions alone |
|---|---|---|---|---|---|
| Starts on an event or a schedule | YesNew issues, pull requests, pushes, a timer | Yes | Yes | Yes | Yes |
| A step that needs judgement goes to an AI | YesClaude Code, with the repository's own instructions | YesAI steps and agents | YesAI modules | YesAI agent nodes | PartlyOnly with an action you add |
| Two runs never grab the same piece of work | YesEach run claims its task first | NoNot built in | NoNot built in | NoNot built in | PartlyConcurrency groups queue runs, not tasks |
| Nothing lands until a check passes, with a person able to approve | YesA pull request through the required check; the owner merges unless a worker is set to auto-merge | YesA built-in approval step | PartlyAn approval step you build | PartlyAn approval step you add | PartlyEnvironments with required reviewers |
| A lasting record of what changed and why | YesGit history, the plan and the pull request | PartlyRun history, kept for a time | PartlyRun history, kept for a time | PartlyExecution logs | PartlyRun logs, kept for a time |
| What it costs | Free on a public repository; a Claude plan for the AI | Per task, by plan | By plan, in credits | Free to host yourself, or per execution | Free on public repositories |
Where they are ahead. Zapier, Make and n8n connect to thousands of apps and have visual editors. Symphony connects to one thing, a GitHub repository, and everything it does is a file, an issue or a pull request there. Use them to bring work in; Symphony keeps several AI workers from colliding once it is there.
Revising documents from reviewers' comments
A paper, a report or a set of policies comes back covered in comments, and every comment needs an answer.
| What it does | Symphony | Word, by hand | Google Docs with Gemini | Microsoft 365 Copilot | Overleaf |
|---|---|---|---|---|---|
| Each comment gets an edit and the reason for it | YesClaude writes the edit and a comment saying why | NoYou do each one | PartlyYou ask, passage by passage | PartlyYou ask, passage by passage | NoYou do each one |
| Edits come back as tracked changes to accept or reject | YesWritten into the .docx as Word's own tracked changes | YesTrack changes | YesSuggestions | PartlyCopilot rewrites; you keep or discard | YesTrack changes |
| Many documents worked at once, never two hands in one file | YesOne task per document, claimed by one worker | NoOne at a time | NoOne at a time | NoOne at a time | NoOne at a time |
| Every version kept, with who changed what | YesIn git | PartlyVersion history in OneDrive | YesVersion history | PartlyVersion history in OneDrive | YesHistory |
| People editing the same page live | No | Yes | Yes | Yes | Yes |
Where they are ahead. Live co-editing belongs to Word, Google Docs and Overleaf, and Symphony does not offer it. Symphony's document tool is early: it is checked on documents it made, not yet on one saved by Word, and it refuses a paragraph that holds a picture, a link or an earlier tracked change.
Running a job on a university cluster
Code lives on GitHub; the computer that can run it is a shared cluster behind the university's sign-in.
| What it does | Symphony | ssh and sbatch by hand | Open OnDemand | A standing self-hosted GitHub runner | Globus Compute |
|---|---|---|---|---|---|
| Started from GitHub, by a button or a pull request | YesA workflow's Run button, or a workflow that calls it | NoFrom a terminal | NoFrom the portal | Yes | PartlyFrom Python code |
| Each runner lives for one job | YesStarted as a job by the cluster's own scheduler, from a chain the lab starts and stops | Yes | YesNo runner at all | NoA service stays connected | PartlyAn endpoint process |
| GitHub holds no password and no general key | YesOnly a key restricted to start, check or stop the runner | Yes | Yes | PartlyThe runner's own credential | PartlyAn endpoint credential |
| The output comes back beside the code that made it | YesThe job's log and a file, on the commit | NoCopied back by hand | NoCopied back by hand | Yes | PartlyReturned to the calling program |
Where they are ahead. Slurm still does the scheduling, the quotas and the queue, and Symphony uses it rather than competing with it. This part is early: it runs on one university's cluster, and each lab sets it up once in the cluster's own web shell.
Opening a project to volunteers
Many people, each on their own time and their own equipment, chip away at one big shared job.
| What it does | Symphony | BOINC | Zooniverse | Good first issues on GitHub | unsorry |
|---|---|---|---|---|---|
| Volunteers bring their own AI; the project holds nobody's key | YesCrowd mode: each works on their own Claude account | NoVolunteers lend computer time | NoVolunteers classify by hand | PartlyAnyone can, by hand | YesVolunteers' own agents |
| Two volunteers never take the same task | YesThe claim | YesThe server hands out work, and repeats some on purpose | PartlySeveral people see each item on purpose | NoA comment saying "I'll take it" | YesFirst push wins |
| Abandoned work goes back, and what was done is kept | YesAfter a day, on a renamed branch | PartlySent again after a deadline; partial work dropped | NoNot needed | NoBy hand | PartlyFreed after two hours; work dropped |
| Every contribution is checked before it counts | YesA required check on every pull request | YesResults compared across volunteers | YesAnswers agreed across volunteers | YesTests and review | YesThe proof checker |
| No server of the project's own | YesOnly GitHub | NoA project server | YesZooniverse hosts it | YesOnly GitHub | YesOnly GitHub |
Where they are ahead. BOINC and Zooniverse have run millions of volunteers for years; Symphony's crowd mode has not yet had its first crowd. unsorry is the closest relative, built for proving theorems, and its coordination runs in GitHub Actions as Symphony's does.
Building a team of AI agents in code
A developer writes a program in which several AI agents hand work to each other.
| What it does | Symphony | LangGraph | CrewAI | Microsoft Agent Framework | OpenAI Agents SDK |
|---|---|---|---|---|---|
| Agents on different machines and accounts share one queue | YesThrough the repository | NoInside one program | NoInside one program | NoInside one program | NoInside one program |
| State survives a crash with nothing to host | YesIt is in the repository | PartlyWith a checkpoint database you run | PartlyWith storage you set up | PartlyWith storage you set up | PartlyWith a session store you run |
| Every change passes a check before it lands | YesA pull request through the required check | PartlyHuman steps you add | PartlyHuman steps you add | PartlyHuman steps you add | PartlyHuman steps you add |
| Step-by-step control, streaming and any model | NoWhole tasks, done by Claude Code | Yes | Yes | Yes | PartlyOpenAI models first |
Where they are ahead. A framework is the right tool when one program must control every step. Symphony works a level up: each worker could be built with any of these, and Symphony keeps the workers from colliding.
Symphony is not a GitHub or Anthropic product. Every product named here is its owner's mark, used only to say what Symphony is compared with. What it costs, priced against the coding-agent tools, has its sources at its foot.