What you can do with a recorded session

kcap records every coding-agent session as an immutable stream. Continue it after a crash, hand it to another agent, review the PR it produced, score the run, or ask what it cost — from the dashboard, the CLI, or inside the agent.

A Monday with kcap · 1:21

01 · Multi-player

Share the session, then work together

Multi-player is not another status update. It is a teammate opening the same agent session, the same spec in progress, or the same hosted agent and moving the work forward.

A live agent shared with the payments team: three people on the page and two forks from turn 2 A live agent shared with the payments team: three people on the page and two forks from turn 2
Payments team, Priya, Jonas The share menu: org members, project members, teams and people, or private The share menu: org members, project members, teams and people, or private
In kcapShare a live agent with your team, a project, or named people. Everyone on it sees the same turns, can steer it, and can fork it from any turn to try another approach.
Without the session

The next person reconstructs the conversation from Slack fragments

Alex pasted a wall of context. Nina has to reverse-engineer the spec from the thread. The session itself is not shareable.

You

I started the webhook replay spec but I want another read before the agent writes code. Here’s a dump of the last 20 turns…

Agent

Which version of the spec is current? I’ll start from the last message in this chat.

stale context re-explained

Without a session link, handoff is a paste

With the session

Send the session, not a wall of context

Nina opens the session Alex shared and picks up the work where it stands. A link replaces the paste.

You

I added the missing acceptance case to the spec. Can you continue from that version?

Agent

I see the spec update: duplicate delivery after a timeout must replay safely. I’ll update the test matrix first.

shared session same stream

With the session, the second person joins the work, not the thread

How it works

Session links, shared hosted agents, and recaps all point at the same durable session stream. Visibility decides who can open it. See Hosted agents and Session recall.

02 · Multi-agent

Switch coding agents without starting over

One coding agent gets stuck. The next one reads the recap, sees what was tried, and continues from there — not from turn one.

Forking an agent from turn 3: the correction to make, and the run moved from Claude to Codex Forking an agent from turn 3: the correction to make, and the run moved from Claude to Codex
Any turn, any agent
In kcapFork any turn into any agent. When one harness is down, the work carries on in another. When a turn went wrong, go back to it, say what to fix, and run it again.
Without the session

The next agent starts at turn one again

codex

codex › ran out of room in the context window
codex › /new
Codex Claude Code

You switch to Claude Code. It has none of the prior reasoning.

You

Here’s the failing test again. Please try another fix for the race in flush().

Agent

I’ll start by checking whether the lock-free swap is losing writes under contention.

restart lost context 6th hypothesis is also the 1st

Without the session, switching tools means repeating old work

With the session

The handoff keeps the failed hypotheses failed

Codex

47 turns Stuck on a race in flush()

Claude Code

New session Reads the Codex recap

Claude Code reads the Codex recap. The four hypotheses Codex already ruled out stay ruled out.

You

Continue from the Codex session. Keep the same failing test open.

Agent

Codex ruled out the lock-free swap, the channel rewrite, the timer reset, and the retry loop. I’ll try the staged-commit approach next.

continued from codex session

With the session, changing agents does not erase the investigation

How it works

Every session is tagged with its vendor and serialized to the same event stream. The next agent starts a new session, pulls the prior recap through the same MCP tool, and continues from there — regardless of who wrote the original. A hosted agent can also be forked from any turn: the fork starts from that turn's code and context, on the harness you pick, with the change you want made. See Recap and Session recall.

03 · PR review

Review PRs with the reasoning, not just the diff

Your agent already reads the code. Now it can read what your teammate tried before they wrote it.

In kcapkcap review hands your agent the sessions behind a PR: what was tried, what failed, and why the final diff
Without the session

Another PR you don’t have time to understand

diff

− batchSize: 500
+ batchSize: 5

You ask your agent why Sam changed batchSize to 5. It only has the code.

You

Why did Sam drop the batch size to 5?

Agent

Every other job in this repo uses 500. At 5, throughput drops by two orders of magnitude. Looks like a debug value. Restore it.

confident plausible wrong

Without the session, the agent confidently guesses wrong

With the session

The reason was in Sam’s session all along

Your agent pulls the session behind the PR and reads the load tests that led to the change

You

Why did Sam drop the batch size to 5?

Agent

Sam load-tested 500 — the database locked up at p99. They tried 200 next, but the writer OOM’d. At 5, the job stayed stable for 30 minutes. Trading throughput for stability until the writer is sharded.

grounded from Sam’s session

With the session, the agent stops guessing

How it works

kcap review <pr-url> launches your agent with the kcap mcp review tools, which hand it the PR’s linked sessions at review time: file context, prior test runs, and the FTS-indexed transcript. See PR review.

04 · Evals

Stop teaching agents the same repo rules twice

kcap scores sessions against your rubric and turns durable lessons into repo guidance loaded before the next agent starts

A session evaluation: 4/5 pass, scored on safety, plan adherence, quality and efficiency A session evaluation: 4/5 pass, scored on safety, plan adherence, quality and efficiency
Scored when the session ends
In kcapEach session is scored on safety, plan adherence, quality and efficiency, with the fixes worth making
Without the session

The same mistake comes back next week

session

+ jest.mock("./db", () => ({ ... })) // session 87
+ jest.mock("./db", () => ({ ... })) // session 134

Your team never mocks the database in this repo. Every new session has to relearn that rule.

You

Please don’t mock the database in this repo. Use the integration test harness.

Agent

I’ll mock the db module so the checkout tests run faster.

repeated reviewer catches it again

Without evals, lessons stay trapped in individual sessions

With the session

The useful lesson becomes repo guidance

The rule moves from a reviewer comment into the repo’s agent guidance. The next agent reads it before writing code.

You

Score the session and promote the db-mocking finding.

Agent

This repo’s guidance says not to mock ./db in checkout tests. I’ll use the integration harness instead.

scored loaded next run

With evals, the floor rises without asking every reviewer to repeat themselves

How it works

Evaluations run per session, score against your questions, and emit judge facts. Repeated high-signal facts can be promoted into curatable guidelines that ship at SessionStart. See Evaluations.

05 · Hosted agents

Launch a coding agent from any browser

A daemon on your machine spawns your coding agent in an isolated worktree. You start the work from the dashboard — phone, laptop, anywhere — and a teammate can join the same prompt.

A hosted agent's page: the live transcript, its work item, the PR's checks, threads and reviews, and the plan it is working through A hosted agent's page: the live transcript, its work item, the PR's checks, threads and reviews, and the plan it is working through
Plan, work item and PR, live
In kcapEvery hosted agent gets its own page: the live conversation, the plan it is working through, its work item, and the PR's checks, threads and reviews as they change
Without the session

Starting work means opening a terminal on the right machine

No SSH, no waking the laptop, no “are you on the billing-service checkout?”. Without a daemon, the agent lives where you happen to be sitting.

You

Can you pick this up? I’m on my phone. The repo is on my desk machine.

Agent

I can only run where this shell is. You’ll need to open a terminal on that laptop.

machine-bound one operator

Without a hosted agent, remoting is a meeting or a hop

With the session

Start an agent without opening a terminal

Run kcap daemon start -d once. The dashboard sees every running daemon and lists only the vendors it can actually spawn. A teammate can join the same session.

You

Open checkout-api on my laptop daemon, hand the agent the spec, and start.

Agent

Checked out spec/webhook-replay in a new worktree. I’ll read the spec and propose the first acceptance case before touching code.

live terminal isolated worktree

With a hosted agent, the work is on the dashboard, not on whoever has the laptop open

How it works

kcap daemon start on your machine. The daemon advertises itself to your kcap server; the dashboard’s launch dialog picks a vendor, repo, and branch, and the daemon spawns the agent in an isolated worktree. See Hosted agents.

06 · Session recall

Ask your agent: have we worked on this before?

kcap gives the agent six MCP tools — search past sessions, list a repo’s sessions, summarise one, read its transcript, walk it turn by turn, drill into the exact turn — so prior decisions show up in this conversation instead of getting re-litigated

In kcapMid-task, the agent searches past sessions and team memory, then cites what it found
Without the session

The agent only knows this chat

You ask a question that touches a decision your team already made. The agent has no idea it has been argued.

You

Should we put a queue in front of the rate-limiter, or call it directly?

Agent

A queue would give you backpressure and retry semantics — usually the safer default. I’ll sketch a Redis-backed queue.

confident already rejected

Without recall, every new session re-opens decisions your team has already closed

With the session

The prior decision shows up in this chat

The agent searches every session you can see, defaults to the current repo, and chains search → summarise → drill in until it has the actual turn

You

Should we put a queue in front of the rate-limiter, or call it directly?

Agent

Priya already ran this. The 24h shadow at direct call stayed within p99 budget, so the team chose direct over a queue. Revisit if shed rate climbs above 1%.

grounded from Priya’s session

With recall, the agent cites the prior call instead of starting the argument over

How it works

The kcap mcp sessions server gives the agent six chained tools: search_sessions, list_repo_sessions, get_session_summary, get_session_transcript, list_turns and get_turn. It’s repo-aware by default and respects the same visibility rules as the dashboard. See Session recall.

07 · Review flows

Don’t let one agent grade its own homework

The agent that wrote the code has the same blind spots when it reviews the code. A review flow hands your spec or diff to a separate reviewer — and loops until the findings are gone.

A review flow: two rounds with findings, then a clean third round A review flow: two rounds with findings, then a clean third round
Clean on round three
PR #1279, after round three PR #1279 after the clean round: six checks passed, no open threads, approved PR #1279 after the clean round: six checks passed, no open threads, approved
In kcapA separate reviewer works the diff in rounds until the findings are gone, and every round is on record. The PR's checks, threads and reviews show beside it.
Without the session

It reviews its own work and calls it clean

You ask the agent that just wrote the handler to check its own work. One agent can’t catch the blind spot it just wrote in.

You

Review your change before I open the PR.

Agent

Clean handler — it follows the existing route style and reads well. No issues. Good to merge.

self-graded no auth check

Without a second agent, the merge looks reviewed and isn’t

With the session

The reviewer catches it. Your agent fixes it

Your agent hands the diff to a hosted reviewer — a vendor you choose — and waits for the verdict. Round two comes back clean.

You

Get an independent review before I open the PR.

Agent

The reviewer flagged the missing authorization check. I added an org-admin guard and re-submitted. Second round came back clean.

signed off 2 rounds

With a review flow, work gets checked, fixed, and re-checked before it’s done

How it works

The kcap mcp flows server hands your spec or diff to a hosted reviewer you choose, independent of the agent driving the flow. It returns findings, your agent addresses them, and it re-reviews until it signs off — the whole loop event-sourced on your server. See Hosted agents and PR review.

08 · Analytics

What did your agents cost last month?

Token spend scatters across providers, repos, and developers. Ask in plain English — the analytics agent answers with a number you can audit, not a guess.

The Insights agent answering where this month's agent spend went, with a chart The Insights agent answering where this month's agent spend went, with a chart
The query behind every number
In kcapAsk in plain English. The answer comes with a chart, a table and the queries behind it.
Without the session

The spend is scattered across provider bills

bills

anthropic console $?
openai console $?
by repo / by dev —

You ask which repo burned the budget. The bills don’t say.

You

Which repo cost the most in tokens last month?

Agent

I can’t tell from here — provider billing isn’t broken down by repo or developer. You’d have to export each console and reconcile it by hand.

no aggregate manual reconciliation

Provider bills total the spend. They don’t tell you where it went

With the session

Ask in plain English. Audit the number

You ask the analytics agent, and it queries your session read model. Each row keeps the query behind it, so the number is auditable.

You

What did each repo cost in tokens last month?

Agent

Last month checkout led at ~$58 (4.2M tokens), then web at ~$16 and infra at ~$5. Each row keeps the query_read_model call behind it.

grounded from your read model

With analytics, the spend has a name, a repo, and a receipt

How it works

The analytics agent turns your plain-English question into a query_read_model call over the projections kcap builds from every session — counts, tokens, timings — and answers with a table or chart plus the exact query behind it. It reads aggregates only, never your transcripts. See Analytics.

Start with a session you already have

The four Capture, Inspect, Share and Reuse products together: a teal camcorder, plum microscope, yellow game console and orange sampler

Product screenshot

100%

Zoom in, then scroll or drag to explore. Use arrow keys when the image is focused.