Skip to main content
A build writes everything it does under campaign/.kapso/. kapso trace reads it back after the fact, without the agent that ran it, and lays the evidence out so a reader can answer six questions from the record alone: what won, why, what was voided and on what evidence, what was rejected and why, what it cost, and whether it is safe to merge.
A campaign still running renders too, marked partial with the reason (the phase it is in, the error it failed with, no status yet, or waiting on you with the count of requests); follow a live one with kapso watch. A directory with no .kapso/ inside is not a campaign and is refused by name.

​
The sections

The trace above is a real one, from the trading example’s recorded build of 2026-10-25, abridged: a trading build whose first attempt scored a Sharpe of 2.16 and was voided because a development script had read the hold-out window, and whose second was cut by the time budget. Where each answer sits: Each attempt lists its sessions in the order they ran: the ideation of its iteration, the implementation on its branch, the verification and the judge. A session has one line per run the host made for it, a resumed or retried session two or more; the line carries how the run ended (success, error, timeout, paused for a session the inbox stopped, refused for an answer the model’s safeguards refused), its duration, its cost, its turns, the tools it used, the gates it called, the hooks that fired and how many denied, the delegates it asked; a run that resumed the session says why (retry: tags missing on a judge’s second run). An attempt the budget left unjudged says so on its judge line. OTHER SESSIONS holds the sessions that belong to no attempt: the harness setup, the engine’s own inference sessions, and a node still in flight. LESSONS is one entry per source served, with who read which cards and which the judge found load-bearing per node; SESSIONS FAILED lists every run that ended error, timeout or refused, and names the kinds of which every run failed.

​
One attempt in full

The same sections, with the one attempt’s evidence whole: the idea, each run’s model and host session, its error, each hook’s decision and reason, each delegate’s report, the files it changed and its closing message; the evaluator’s output; the verifier’s summary and findings; the judge’s feedback. The data behind --json always carries all of it; --branch is how the text shows it.

​
The data

--json prints what Kapso.trace(path).data holds, and TraceView(data) renders the same text again from it. A script or a skill reads the keys as pinned:
A run entry, as the session record holds it: started, ended, duration_seconds, deadline_seconds (the deadline the run was launched with: its room under the budget or its configured timeout; null without one), model, cli_session_id, exit, error, retry_reason (set on a run that resumed the session: tags missing for the judge’s retry), cost_usd (this run’s share of the host’s cumulative figure), cost_cumulative, turns, usage (the host’s token counts), tools (by name), gates (by server, by tool), hooks (each with its event, name, decision and reason, a hook that blocked a tool call included; null where the host reports none), delegates (each with its name, status, usage and report; on Codex the collaboration calls, by verb), host_errors, files_changed (the files the session wrote through its editing tools, relative to its directory; a file written by a shell command shows in the branch’s diff instead), last_message. The delivered candidate’s files_changed are the files its branch changed against the seed, from the diff.

​
Where each file lives

The session labels are the branch for an implementation session, verification/<branch> and feedback/<branch> for its verifier and its judge, ideation/iter<n>/<member> for the ideation of iteration n, difficulties/<branch> for the reconstruction of what an attempt lost, harness_setup for the setup session, and engine/<role>/<n> for the engine’s own inference sessions (the repo-memory bootstrap, the commit messages), which belong to no attempt. The trace joins the sessions to their attempts by these labels (a node records the iteration that made it, and every node of an iteration shares its ideation session) and the pull log’s events by the session the gate served.

Run and watch

The live view while it runs

Review the result

The Solution and the record

Use a harness

What a session is staged with

CLI reference

Every flag of kapso trace
Related pages: Run and watch · Review the result · Use a harness · CLI reference Kapso is an open-source framework by Leeroo that builds software toward measurable goals through experiment campaigns. Source code: github.com/Leeroo-AI/kapso · Install: pip install leeroo-kapso · Every page as plain text: llms.txt.