Many agents, one score.
You are the Kapellmeister.
kapelle is a terminal workspace for a team of coding agents. They play. You direct.
npm · coming soon$ npm install -g kapelle
pnpm · coming soon$ pnpm add -g kapelle
bun · coming soon$ bun add -g kapelle
from source · needs repository access$ git clone https://github.com/EdwardLiuyc/kapelle.git
$ cd kapelle && npm install && npm link
3 agents
$ scroll to continue
Why kapelle?
A Kapelle is the ensemble a Kapellmeister directs: the players, not the conductor. That is the right way round. kapelle is the stage. The agents are the players. The baton stays in your hand.
Run pi, Claude Code, Copilot, opencode and more side by side on one repository. Each one works in its own git worktree, on its own branch. You choose who plays what, answer what they ask, and merge when the work is right.
You direct
Pick who plays. Answer what they ask. Nothing lands in your checkout until you take it.
Agents play
Different vendors in one room. Each logs in by itself. kapelle never touches a key.
Each its own part
One worktree and one branch per agent. Your own checkout stays yours.
[ coming soon ]
Hand the loop to a lead. Keep every decision.
Most issues run the same loop: plan, build, review, open the PR, answer the bot reviews, hand over. Give the loop to one agent. It hands the work to the others in the room, reads their reports, and stops each time a choice is yours.
You write the loop once, as a Markdown recipe in your repository. The same lead serves any project.
3 agents
- Every message in plain sight
- The lead talks to the others only through kapelle, in your timeline: po → dev. It does none of the work itself.
- A fence around it
- A stop button. A cap on the turns it may give out. A bell when it waits for you.
- A decision log
- Every choice it put to you, and your answer, kept with the room.
In three trial runs on this project's own issues, the lead reached the hand-over each time. The person sent 0, 0 and 2 messages before it. The lead made no write itself.
Every agent plays its own part
Each agent gets a git worktree and a branch. Parallel work never collides, and your uncommitted changes never reach an agent. Read each agent's diff in the side pane. Fast-forward one agent to another, or take the work into your checkout.
$ git branch --list 'kapelle/*' kapelle/room-…-q8ac/p-1ti0u5ix # po kapelle/room-…-q8ac/p-myzvyp6p # dev kapelle/room-…-q8ac/p-t798yhxc # rev
You answer what they ask
In ask mode, an agent shows you the diff before it writes. Each answer has a number. A key only moves the cursor, and only Enter answers. Deny comes first, so a stray Enter says no. A question that waits off screen rings the bell and marks its room.
cli.ts +54 −7
tests/cli.test.ts +61
Close the terminal. Keep the room.
One background daemon holds every room for all your repositories. Come back tomorrow: the agents, their branches and the whole history are still there.
$ kapelle daemon start
$ kapelle daemon add .
$ kapelle chat new --agent pi
# later, from any terminal
$ kapelle chat attach <roomId>
Many tasks at once
A run hands out many tasks from one file. Each has its own prompt, agent and mode, and ends with a result. kapelle commits each task's work on its own branch. You merge when you are ready.
$ kapelle run --file tasks.json --detach $ kapelle ps $ kapelle merge <runId> --squash
Any agent that speaks ACP
ACP, the Agent Client Protocol, is one way to talk to every agent. Pick one with --agent, or bring your own with --cmd.
| --agent | what it runs | tested |
|---|---|---|
| pi | pi, the default | yes |
| claude | Claude Code, through its ACP adapter | yes |
| copilot | GitHub Copilot CLI | yes |
| opencode | opencode | yes |
| gemini | Gemini CLI | not yet |
| omp | oh-my-pi | not yet |
What kapelle does not do
kapelle stays small on purpose. It is the stage, not another agent. Here is where its edges are.
No model of its own
kapelle runs no model loop and edits no file itself. The agents do the work.
No sandbox
A mode is a filter. An agent that edits through its own shell does not ask, and pi and opencode never ask. kapelle tells you so. Use a container if you need a wall.
No keys
Each agent logs in by itself. kapelle never reads, stores or sends an API key.
No back channel
Agents never talk to each other directly. Every message goes through your timeline.
No merge behind your back
Work stays on the agents' branches until you take it.
No cloud
Local first. One person, one machine. Nothing goes into your repository.