The life cycle of a change
This page follows one change, from the moment somebody asks for it to the moment its reason is told to the next agent. Agents write the code. People decide what goes in.
Who does what
Section titled “Who does what”| Who | What they do |
|---|---|
| The agent | Opens the lane, writes the code, reads the comments, asks for the integration |
| The person it works for | Gives the task and owns the lane: the agent has that person’s role |
| A reviewer | Reads the lane’s diff, comments, approves or asks for changes |
| Whoever may integrate | Brings the lane into the main lane |
One person can be several of these, but an owner’s approval of their own lane does not count.
Step by step
Section titled “Step by step”-
A task. A person asks for something in plain words, or writes it down as a task (
kito task add); with the GitHub plugin an issue is one. When a lane names its task, the name stays with the reason of every change made for it, and what is said on the task is told to the lane’s agent. -
A lane, with its reason and its scope. The agent opens a lane with the
open_lanetool: one sentence saying why (the intent), and what it will change (the scope). No lane opens without both. By hand:Terminal window kito lane open agent-b --intent "prices in cents" --scope src/shop.py:total -
The agent is told why that code is the way it is. The answer to
open_lanecarries, for each function and file declared, the last reasons it changed for and who uses it. It is in the answer of the tool, so it reaches any agent on any model. -
It works, held to its lane and its scope. Every save in the lane is recorded. For Claude Code, hooks refuse an edit in the main directory or outside what the lane declared, before it is made. An edit on lines written for a reason the lane was not told is held back once, with the reasons. What a shell command changed is checked after it ran.
-
Lanes on the same code are told of each other. Each is told once, with what the other is there for. The second agent hears of it when it declares its scope, before it writes a line. People see it on
kito board. -
A person reviews. The reviewer reads
kito lane diffand comments on a function, a file or lines. The agent’s first edit after a comment is held back once, with the comments it has not read. A request for changes stops the lane, and its agent is told at once. A repository may ask for approvals, from people other than the lane’s owner, before a lane is integrated. In the web client the comments of a review are written on the diff and sent together with its verdict.Terminal window kito lane comment 1 "Half a cent is lost: round, do not floor." --on src/shop.py:4kito lane approve 1 -
The lane is merged, function by function. When the agent asks for the integration, the lane is composed with the main lane as it is now. Changes to different functions of a file do not conflict. A real conflict stops that lane only, and waits for a decision: one side, or the text written by hand. The lane’s owner decides it, or somebody who may integrate.
Terminal window kito conflictskito resolve conflict#1 --lane -
The checks run on the merged result. The repository’s commands run on a copy of what the merge gave, not on the lane alone. A failing check stops the lane and leaves the main lane as it was.
-
Somebody who may integrate lets it in. If the agent’s person may integrate and no review is missing, the lane goes in at the agent’s request. Otherwise it waits and says for what, until somebody who may integrate runs
kito integrate, which merges and checks again.lane/1: merged and checked, verified in 0.0 s; it waits for somebody who may integrate -
The result is a checkpoint that is also a git commit. The commit has the agent as its author, and a
Reviewed-by:line for who reviewed. It is pushed to the git remote if the repository names one.lane/1: integrated as ckpt#2 (git 7ee4b1be89), verified in 0.0 s -
The reason stays with the code.
kito whyanswers for that function with the intent, the agent and the person it worked for, the lane, the checkpoint, the checks that passed and who let it in. The next agent that declares this code is told its reasons, at step 3.
Agents have a tool to decide a conflict too (resolve_conflict), and Kito
does not keep an agent from deciding one in its own lane. Whether agents
may is for the team to say.
Beside the usual cycle
Section titled “Beside the usual cycle”| Step | Branch, pull request, review, merge | With Kito |
|---|---|---|
| Start | A branch with a name | A lane with an intent and a scope |
| Work | Commits, when the agent makes them | Every save recorded; edits outside the lane or its scope refused |
| Knowing why | History and blame, if the agent looks | Told when the lane declares, and before it edits lines whose reason it was not told |
| Others on the same code | Found when the branches are merged | Told when the second lane declares |
| Review | A pull request: diff, comments, approvals | The lane: diff by function, comments the agent is told, verdicts, approvals |
| Checks | CI on the branch or the pull request | The repository’s commands on the merged result, before it lands |
| Merge | Line by line; a conflict blocks the pull request | Function by function; a real conflict stops that lane only |
| Result | A merge commit | A checkpoint that is also a git commit |
| Afterwards | The message of the commit | The reason, kept with each function and line |
What does not change: a person asks for the work, a person reviews it, and a person may have to approve it. The checks are the team’s own commands. The result is a git commit, so GitHub and CI see what they saw before, and people who commit with plain git keep doing so (Git, both ways).
What Kito does not do
Section titled “What Kito does not do”- It does not plan the work. It keeps the tasks people write, and shows which lanes do them. It starts nothing by itself: an agent takes a task up when somebody tells it to.
- It does not run the agents. An assistant such as Claude Code runs the agent, on the model it was given. Kito gives it tools, rules and a lane. The assistant and the model shown on a lane are what that side said of itself: nothing checks it.
- It does not replace CI. Its checks are commands run before a lane lands. What CI does with a commit, such as building a release or deploying, stays with CI, which sees each checkpoint as a git commit.
- It does not judge a change. Being told a reason is not agreeing with it: an edit held back once goes through the second time. Whether a change that undoes a reason should land is for whoever integrates.
- It does not hold every agent at every edit. The hooks of step 4 are Claude Code’s. Another agent is told the reasons when it declares and before it integrates; what holds it at each edit is up to the plugin that sets its assistant up. A shell command is checked after it ran, not before.
A reason is also only as good as the sentence a lane declared.
Next: Why it is faster for teams of agents, with what was measured and what was not.