End to end
Write a card. Get a branch.
There is no prompt box in the middle of this. You describe the work on a card, and what comes back is a branch you can read, test, and merge, or throw away without touching anything else.
You write the card
You give it a title and the actual instruction. It is the same thing you would have typed into a chat window, except that it stays attached to the work.
A worktree is cut
A fresh git worktree is cut on a fresh branch. It is a real directory on disk, sharing one object database with the repository.
A session spawns
A real Claude Code session starts inside that worktree, with the harness loaded and the project memory already recalled.
It works while you do
The card moves lanes on its own. You start the next one instead of watching this one.
It asks when it needs you
A decision it should not make alone moves the card to Needs you and stops. Nothing guesses on your behalf.
You review a diff
What comes back is a normal branch diff. Read it, run the tests, push back, or merge it. Nothing landed on main while you were not looking.
What it learned is kept
Decisions, conventions and gotchas are written to memory and synced to the team, so the next session and the next teammate start further along than this one did. This is the step that compounds, and it is the one almost no other tool performs at all.
Why worktrees
Parallelism without isolation is just faster conflicts.
A git worktree gives each session its own checkout on its own branch while sharing the repository's object database. That is the whole trick. It is cheap, it is native to git, and it means an agent cannot reach into work it was not given.
Persistence
The second session should not repeat the first.
Most agent tooling forgets everything the moment the window closes. Memory here is a first-class store: routed onto the prompt that needs it, regenerated as an index, and synced so it belongs to the team rather than to one transcript on one laptop.
Decisions
Why approach A beat approach B, recorded when the reasoning was fresh.
Gotchas
The quirk that cost an hour once, so it never costs an hour again.
Conventions
Project rules that are not visible in the code and not written in any README.
Bug log
Each entry records the error, its root cause and the fix. The log opens automatically before an edit to a file that has failed before.
Control
The board is a control surface, not a status page.
Three things you can do to a session while it is still running. These are the real screens, not descriptions of them.
Tool calls, file reads and test runs stream as they happen, so you can tell a session is going wrong before it finishes going wrong.
Drop legacy v1 routes
A session heading the wrong way is stopped from its card. The worktree and the branch stay exactly where they are, so you can read what it did before you decide anything.
It is a real directory on a real branch. Open it in your own editor and finish the work by hand, with no export step and nothing to migrate.
First run
Purchase, download, point it at a repository.
There is no public package to install and no free tier to evaluate on a toy project. You buy it, you download it, and it runs against your real repository from the first card.
Purchase a seat
$150 per user per month. One seat per person who will run sessions.
Download and open it
The board runs locally against your machine and your checkouts. Your code does not go anywhere it was not already.
Add a project and write one card
Point it at a repository, describe one real piece of work, and watch the worktree get cut.
Start saving, and get more out of every session
From the first week you can see what each session actually cost, per tool and per turn. The harness keeps context lean so you are not paying twice for the same file, and memory stops your sessions relearning what they already worked out. On one measured installation that cut prompt-token cost by 86.9%.