Capacitor Sign in Get started

Capacitor/How it works

How a recorded session becomes shared memory.

Capacitor records each coding-agent session as a durable event stream, then turns it into memory your whole team can draw on. Here’s how one recording becomes replay, recall, review, and evals — and exactly what it captures along the way.

From capture to capability

Once the session is durable data, the rest follows.

A coding-agent session normally scrolls away the moment it ends. Capacitor keeps the whole thing — prompts, reasoning, tool calls, and results — as a durable, structured stream. Everything below is what becomes possible once the session is data you can query, not a chat that’s gone.

Replay & audit → Every turn is stored in order, so the dashboard reconstructs the session exactly as it ran — the real events, not a summary. Recall → Past sessions are kept and indexed, so your agent can search them and surface the decision your team already made. PR review → The record keeps the reasoning and the discarded attempts, not just the diff — so a review can see why the code is the way it is. Handoff → The full session is preserved, so another agent picks up from the recap with the dead ends already ruled out. Evals → Every session is stored the same way, so an LLM judge can score it against your rubric — and the lessons that stick become guidance for the next run.

Two moving parts

How it works

On your machine

The Capacitor client is open source. It installs hooks into the coding agents you choose, and a background watcher tails each agent’s own transcript file and streams it to your server as the session runs — without changing how you work.

Your Capacitor server (cloud)

A Kurrent-hosted cloud instance, dedicated to your organization. It receives the session transcript, stores each session, and builds the data models behind the dashboard and search — then answers your agents’ queries against them.

Architecture diagram. You interact with your coding agent and the kcap CLI. On your machine, kcap hooks and the agent transcript sit inside the coding agent; the hooks send hook events to the kcap server, and the transcript feeds the kcap watcher, which streams it live to the kcap server. The agent makes tool calls to the kcap MCP server, which queries the kcap server; the kcap CLI talks to the kcap server too. In your Capacitor server in the cloud, the kcap UI talks to the kcap server, which reads and writes the kcap event store database (KurrentDB).
One session, end to end: the watcher streams the transcript to your server, which appends it to an immutable event store and projects it into the dashboard, search, and review.

What reaches your server

The full session transcript.

When a session is captured, the watcher sends the complete transcript — everything the agent read, wrote, and reasoned about:

Every prompt
The full text of every message you send the agent.
Every response
The full text of every agent reply.
Tool calls & results
Bash commands, file reads, and edits — with timing, output, and the exact diffs applied.
Thinking blocks
The agent’s reasoning, alongside the turn that produced it.
Token counts
Input, output, and cache reads/writes — per turn and per subagent.
Subagent trees
Every spawned subagent with its own transcript and token tally.
Repository context
Git repo, branch, and PR linkage.

Treat the transcript as sensitive by default. If a prompt or output contains a secret or a proprietary detail, you can delete that session from the server any time.

Where Capacitor stops

Capacitor never reads your repository.

Beyond the transcript above, nothing leaves your machine. Capacitor has no access to your filesystem — it never scans or uploads your source tree on its own. The only path to your server is the session transcript you can already see.

Go deeper

For the exhaustive, field-by-field list of what is captured — and the exclusions and controls in full — read What Capacitor captures. For the mechanics of hooks, the watcher, and the event store behind it, see System architecture and Visibility & sharing.

See it on your own repo.

Start free in minutes. Capacitor records what your agents actually did — for your team to replay, audit, and discuss. Nothing about how you work changes.

Get started →

Rather start a conversation? Talk to the team — we’re building with teams that already use coding agents.

Built by the team behind KurrentDB — event streams in production are what we do. Coding agents just produce a new kind.