Skip to content
GitHub

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 | sh

One 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 →
kito.acme.dev · Needs you · 3
prices in cents
shop · lane/2 · CC alice for ada · 1 conflict to decide
conflict
a discount never takes more than the price
shop · lane/5 · Zc erin for bob · asks to go in
integrate
chapters in the order they are read
books · lane/1 · Cx frank · asks for your review
review

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.

Merging function by function →

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.

  1. A laneopened with its reason and what it will touchopen_lane
  2. Told whythe reasons behind the code it declaredwhy
  3. Workheld to its lane and its scopehooks
  4. Reviewa person comments, approves, or asks for changeskito lane approve
  5. Merged, checkedfunction by function, with the checks on the resultkito integrate
  6. A checkpointa git commit, with its reason keptckpt#32

The life cycle of a change →

Measured

Numbers, and where they come from.

Each was measured on one machine and is written down with how. None that was not.

40 / 40integrations merged by Kito, where git stopped on 36 of the same 40the same merges, given to git · a test built around one case
21–24 msto check an agent's edit against the rules, before it is madethe rules before an edit · 20,000 files
2.1 smedian wait at the checks for ten agents at once, against 11.2 s one at a timewaiting at the checks · Kito against itself

What was measured, and what 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 claude

What 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

prices in centslane/14 · CC alice for ada · claude-opus-5
With Claude Code →

And plugins for the rest

Every plugin →

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

Other ways to install →