Dozens of agents.
One repository.
Kito is version control that merges their work function by function, and keeps the reason with the code.
$ curl -fsSL https://kito.sh/install.sh | shOne person, many agents
What needs you comes first.
The web client opens on what is stopped until a person acts: a conflict to decide, a review, a lane that waits to go in. The rest keeps moving.
The web client →Merging
Two agents, one file. Git stops. Kito does not.
Alice adds a tax, Bob adds a receipt: two new functions, both at the end of the same file. Neither touched what the other wrote.
With git conflict
export function total(prices) { … } <<<<<<< aliceexport function tax(amount) { … }=======export function receipt(prices) { … }>>>>>>> bob
Somebody stops, reads both, and keeps both by hand.
With Kito integrated
export function total(prices) { … } export function tax(amount) { … }alice export function receipt(prices) { … }bob
Two functions were added. Nobody was asked.
src/shop.ts
export function total(prices: number[]) { let sum = 0; for (const price of prices) { sum += Math.round(price * 100); } return sum;} export function discount(amount: number, off: number) { return Math.max(0, amount - (amount * off) / 100);}
Why
Every line knows why it is there.
The reason a line was written is kept with it, and told to the next agent before it changes it. Point at a line.
The life of a change
From a task to main, without a queue of pull requests.
Six stops. A person is needed at the amber one, and only there.
- A laneopened with its reason and what it will touchopen_lane
- Told whythe reasons behind the code it declaredwhy
- Workheld to its lane and its scopehooks
- Reviewa person comments, approves, or asks for changeskito lane approve
- Merged, checkedfunction by function, with the checks on the resultkito integrate
- A checkpointa git commit, with its reason keptckpt#32
Measured
Numbers, and where they come from.
Each was measured on one machine and is written down with how. None that was not.
Works with
The assistants you already run.
Kito does not replace your coding assistant: it gives it a lane, the rules, and the reasons behind the code. One command sets any of them up, and kito init offers the ones it finds on your machine.
Set it up
$ kito assistant add claudeWhat it gets
- Kito's tools through its MCP server, and the rules in
CLAUDE.md - Hooks that hold every edit to its lane and scope, and tell it why before it changes a line
- Its model, said when a session starts, shown on its lane
On the board
Set it up
$ kito assistant add codexWhat it gets
- Kito's tools in
.codex/config.toml, and the rules inAGENTS.md - A hook that reads every patch before it is applied, and refuses it if Kito says no
- Its model, from every hook, shown on its lane
On the board
Set it up
$ kito assistant add zcodeWhat it gets
- Kito's tools in
.zcode/config.json, and the rules inAGENTS.md - Hooks before it writes a file and after a shell command, in your own ZCode settings
- Its name on every lane it works in
On the board
Set it up
$ # add kito-mcp to its MCP servers, then:$ kito init
What it gets
- Kito's tools: open a lane, declare its scope, ask why, integrate
- The rules, checked again when its lane is integrated
- Its name, as it introduces itself to the server, on its lane
On the board
And plugins for the rest
Give every agent a lane.
Git stays: every checkpoint is a git commit, and GitHub and CI keep working.
$ curl -fsSL https://kito.sh/install.sh | sh