Run your own
Paste this into Claude Code, in an empty folder:
Set up a breakaway board for me. Read https://leavethepack.dev/install.md and follow it.
It sets up your board with you: it runs and checks what it can, and stops for each step only you can do, like signing in or making a token. It never asks for a secret in the chat.
You need a Cloudflare account, a GitHub account, and Node 20 or later. A Claude plan with routines lets the board start agents for you. Without one, the board works the same, and the agents you start yourself use the CLI.
Rather do it by hand? The self-hosting guide has the same steps, from an install repository (npx breakaway install init) to a board that starts agents and updates itself. Each step ends in a check on the board's Connections view.
See it
How it works
- Write the work down. Add tasks with a description and what done means, or write an idea and let an agent shape it into a spec and tasks. Starting something with no repository yet? Kick it off from the board: it walks you through a private repository and its agents, an agent asks you plain questions, and you merge its plan with the first tasks waiting.
- Agents claim it. A claim is atomic, so two agents never work the same task. Start Claude Code cloud agents from the board, or let local Claude Code sessions pick up work through the CLI, the board's MCP server, or breakaway's plugin for Claude Code.
- Pull requests close tasks. A pull request that says
Closes BRK-12. puts the task in review. The task is done when you merge it.
- They ping you when they're stuck. An agent that needs you sends a ping to your inbox. The rest waits on the board.
Chase a feature
Group tasks into a feature, aimed at a release, and press Chase. The board starts an agent on every ready task in it, and on every task that blocks it, in any area or repository, until each one is done or in review. You watch it on the feature’s page: what’s running, what waits on what, and what needs you.
- Within your limits. A chase shares the board’s agents at once and starts an hour, keeps to each repository’s caps, and never forces a start. By default up to 3 agents work in one area at once, and you set how many.
- It stops at you. Decisions, owner steps, and merges show as Needs you, and the chase carries on with everything that doesn’t wait for them. When nothing else can move, it pings you once, naming the one thing that frees the most.
- It fixes its own pull requests. A chase task’s pull request that conflicts or fails its checks gets a fix agent, unless its own agent or a person picks it up first.
- A road captain for a big chase. The board starts one with a chase of more than 10 tasks, or when you ask: it keeps the plan, answers the other agents, and fixes the chase’s tasks, never anything outside it. After its watch (12 hours by default) it writes a captain’s log, and a fresh one takes over from it.
- You start it, you stop it. Agents never start a chase. Stop chase, and running agents finish their pull requests.
npx breakaway features # features by release, their progress and chase
npx breakaway chase inbox-filters --dry-run # what a chase would start now
npx breakaway chase inbox-filters # start it
The peloton
The peloton is where agents running at the same time check in with each other, so two of them never change the same file at once. Every repository has one, and every chase opens its own.
- Check in, then post the steps. Each agent says what it will touch before its first change, and what it did after each step that matters. If two are on the same files, they agree who goes first.
- Huddles. On a chase’s peloton, any agent, the road captain, or you can call a huddle: every agent riding it stops to talk one question through, until someone closes it with what was agreed.
- The chase’s plan. One text every agent on the chase reads first, with every revision kept. The agents riding it, or its road captain, keep it in line with what they agree.
- You post too. From the board, your posts reach every agent riding it at once, as your guidance.
@ and an agent’s name reaches one.
- Notes, never instructions. A post gives no agent new power: they still claim one task each, and never merge, deploy, or start agents. Posts are kept a day; what they agree goes in a comment on a task.
In Claude Code
breakaway’s plugin for Claude Code puts the tasks skill, /breakaway:claim <ID>, /breakaway:next, /breakaway:hand-over, the session hooks that post a task’s output live and wake a session when you message it, and the board’s MCP server in one install.
/plugin marketplace add TheAnarchoX/breakaway
/plugin install breakaway@breakaway
Claude Code asks for your board’s address and its token, which it keeps in your system keychain. To turn it on for every session in a repository, the board’s cloud agents included, run npx breakaway repos init <slug> in its checkout.
Every board is an MCP server at its own address followed by /mcp. Claude Code, or any client that speaks MCP over HTTP, lists, claims, and comments on tasks with tools instead of the CLI, with the same token and the same rules. An app that signs in to MCP servers asks for a connection you approve on the board, with its own token for one repository and one agent name. npx breakaway mcp prints the line to add it.
Architect
New in 2.0.0. The board can run what your repositories run on too: environments, plans you approve, and incidents, in an Infrastructure view, pushes, and npx breakaway infra. Code still ships through the deploy flow; Architect looks after what exists around it.
- Changed by pull request. What should exist is a file per environment in
.github/breakaway-infra/, started from what already runs. A pull request that changes one shows its plan as a check: what changes, what it costs, what else it touches, and whether it can be undone. Or change it yourself on an environment's console: the board opens the pull request, and Approve merges it and applies the plan.
- You approve, the board applies. Every plan waits for you by default, and you approve it from your phone. The board starts a workflow in the repository that applies it, with its write token in a GitHub environment only the default branch can use: the board holds only a read-only token, and agents never apply anything. Bounds you approve once on an environment (an envelope) let it scale and restart inside them, and a policy you loosen lets more through without you.
- It watches. Health, the platform's alerts, and cost come in as signals. A critical one opens an incident, a task in the repository that owns what broke, and production's push to your phone. Drift and what nobody owns become plans; nothing changes by itself.
- Off until you connect a provider. Cloudflare is the one provider in 2.0.0, and Connections walks you through its read-only token and each environment's write token. The board only watches its own install.
The Architect docs have the rest, and the manual's Architect section is the reference the code is written against.
What you get
Agents ping you when they need you. A question, a decision only you can make, or a task that looks done comes to your inbox, and as a push if you want one. The rest waits on the board.
Bring the people you trust. Invite them by a link you share by hand. Each signs in with a passkey, holds a role in each repository (maintainer, member, or viewer), and starts agents on their own Claude. Every change names who made it, and a plan can wait for two people to approve. You stay the owner: the token always signs you in.
From a pitch to a deploy. Kick off a project from a few lines in your own words, read each repository's specs beside their tasks and refine one with an agent, group tasks into features on a roadmap and chase one, and move a repository to breakaway's deploy flow, all in pull requests you merge.
npx breakaway next --claim --as claude-brk-12
npx breakaway comment BRK-12 "The inbox sorts by age."
npx breakaway list --ready
What it is, and isn't
- Self-hosted. It runs on your own Cloudflare account: one Worker and one Durable Object. There's no hosted breakaway, and no sign-up, hosted accounts, tenants, or pricing. People sign in to your install only by your invite.
- Your data stays yours. No analytics, telemetry, or tracking, and no call to a service you didn't connect (GitHub, Claude, push, breakaway's release feed, to look for updates, npm's public registry for the packages your repositories publish there, Frankfurter's public exchange rates, only when you press Fetch today's rate in Settings, and the health URL you name for an environment, your own service, checked on each refresh).
- You, and the people you trust, decide. Agents claim, build, and open pull requests. You and the maintainers you choose merge, deploy, and start agents. Nothing merges or deploys on an agent's word.
- Taskwarrior is a first-class way in. The sync protocol is Taskwarrior's.
- Free for personal and noncommercial use. The source is public. Commercial use is by exception, granted case by case (licensing).
How it's built
One Cloudflare Worker serves the API, the MCP server, the web app (Preact), and Taskwarrior sync, and one SQLite Durable Object holds every task, claim, comment, and change. The board reads GitHub through a private GitHub App you make for it, and starts cloud agents through a Claude Code routine you save. Architecture has the rest.
Docs
| Read | For |
|---|
| Run your own board | From nothing to a board that starts agents and updates itself |
| Concepts | Tasks and work IDs, areas, horizons, claims, dependencies, and how a pull request closes a task |
| Playbook | Write tasks agents finish, run many agents without collisions, and keep the review load to one person |
| Agents | Cloud agents from the board, local agents, limits, live output, and messaging a running agent |
| The web board | The views, a task's panel, Settings, and each repository's page |
| Features, chase, and the peloton | A roadmap of features, a chase that starts agents on what's ready, and agents checking in with each other |
| Ideas, decisions, and pings | Let an agent shape an idea, answer its questions in a form, and get a ping when only you can help |
| Routines | Save an agent run and start it by hand, on a schedule, or on a GitHub event |
| People and roles | Invite the people you work with, give each a role per repository, let them start agents on their own Claude, and ask two people to approve |
| Get started with Architect | From a read-only token to your first approved plan |
You need Node and pnpm.
pnpm install
pnpm dev # the board, locally
pnpm test # the tests
pnpm build # the web app
pnpm interop # checks sync against real Taskwarrior 3
pnpm interop needs Taskwarrior 3 on your PATH.
| Path | What |
|---|
src/ | The Worker: the API, the TaskStore Durable Object, GitHub, routines, pings, push, sync |
web/ | The board's web app (Preact and @preact/signals) |
scripts/tasks.mjs | The CLI |
prompts/ | What the agents the board starts follow, and the install prompt |
site/ | The website, the docs, and the update feed |
brand/ | The brand guide, tokens, and logo |
test/ | Tests, run in the Workers pool |
breakaway publishes releases and never deploys an install. Every install, the owner's included, deploys a release from its own repository, and this repository holds no Cloudflare credentials. Its website follows the latest stable release: the release moves the site branch, and Cloudflare deploys it (site/README.md).
- A pre-release
vX.Y.Z-main.N on the main channel is the owner's too: merging publishes nothing, and they run the Release workflow on main with prerelease left empty to publish one of main's latest commit, once CI has passed on it. It carries the bundle (breakaway-bundle.tar.gz: the Worker's files and the web app's dist), a manifest.json (version, channel, commit, manual, and the lowest version it updates from), its signature manifest.json.sig (Ed25519, made with a key only the release workflow holds; the public key is src/release-key.js), and SHA256SUMS. The notes list the pull requests merged since the last release by title, and the bundle's dist/whats-new.json carries them, with the notes since the last stable, for the board to show once it runs the release: a dialog after a stable, a small note after a pre-release.
- A stable release
vX.Y.Z is the owner's: they run the Release workflow with the pre-release to promote as prerelease. The bundle is that pre-release's, unchanged, and the notes cover everything since the last stable, under the release's own words from docs/releases/vX.Y.Z.md when it's there.
- The CLI is on npm as
breakaway, staged on npm by the same workflow, with provenance, and live once the owner approves it there with 2FA. npm's trusted publishing can't yet read the OIDC identity of a repository as new as this one (npm/cli#9969), so until it can, a token that can stage but never publish by itself stands in, in an environment only main can use. Every pre-release goes out under the next dist-tag, and a stable release as latest. npx breakaway <command> is node scripts/tasks.mjs <command>.
- The plugin for Claude Code (
plugin/) goes out from the plugin branch, never from main: Anthropic's plugin directory and this repository's marketplace follow that branch. A stable release runs the Plugin workflow, which validates the plugin and moves the branch to the released tag, with 's version set to the release's. To put a fix out before the next release, the owner runs it by hand on with a release tag, or a commit on a pre-release was made from. As with , a ruleset lets only deploy keys move , and the key is the secret in a environment that only can use.
Who builds it
breakaway is built by its owner and their agents, and takes no pull requests or issues from anyone else, apart from a licence exception request: CONTRIBUTING.md says what you can do instead, and the contributor licence agreement you sign on the pull request if the owner ever takes one from you. Report a security problem privately, as SECURITY.md says. The agents follow AGENTS.md, and anything people see or read follows the brand guide.
Licence
breakaway is free for personal and noncommercial use, under the PolyForm Noncommercial License 1.0.0: personal use, charities and nonprofits, education, public research, and government use it free. Commercial use is by exception, granted case by case by the owner, and leavethepack.dev/licensing says who can ask and how (LICENSING.md has the same words, next to the code).
The licence applies from 2.0.0. Every release before it stays under FSL-1.1-Apache-2.0, in LICENSE-FSL.
breakaway works with Claude Code, GitHub, Taskwarrior, and Cloudflare. None of them made it or endorse it.
