Rewind the work,behind your agent

Going YOLO doesn't need to be blind. Drop in the session log your agent already wrote and replay every prompt, tool call, token and dollar, on its own clock, on a timeline you can scrub, with every error marked where it happened.

Open a tape

Parsed locally, nothing leaves your machine

Session

Claude Code OpenAI Codex Gemini CLI Cursor Copilot Kiro
Track 01 · the deck

Fifteen minutes of work,
on one screen.

One lane per tool, plus prompt and assistant, playing back on the session's own clock.

vcr.dev: replay
The VCR app, with a recorded session loaded

Transport that behaves like one

Play on the session's real clock at 1× / 2× / 10× / 60×. Restart, step event-by-event, hold FF or REW to shuttle with acceleration, and flip skip dead air to jump the silences. Drag to loop a segment.

Zoom until the clips talk

Up to 500× with ⌘/ctrl + wheel. Lanes grow as you go until each tool clip shows the command it ran inline. Hide lanes with the eye toggles when you only care about one.

The script follows the head

A phosphor transcript of every event, tracking the playhead with the live line lit. Tool calls stay folded until you want them. Click any line to jump straight there.

Inspector, always on the beat

Whatever sits under the playhead, or whatever you pin by clicking, shows its inputs, its result, the per-response token split, model, stop reason and cost.

Track 02 · what went wrong

Every failed call,
marked where it happened.

Nothing fails quietly

A tool call that comes back with a non-zero exit doesn't get to hide in a page of scroll.

Every error, timeout and retry is flagged inline: in the transcript, on the timeline, and in a tool-by-tool table with call counts, error counts and time spent. Three failed Bash calls in a row read as three failures, not as noise.

Where the time went

Tool-usage and slowest-call tables, error counts per tool, and the split between time in tools and dead air: the gaps where nothing was happening at all.

Every error, on the timeline

Failed and timed-out calls are marked right where they happened, so the three minutes that went wrong don't need a full replay to find.

Track 03 · in the terminal

The same tools and more,
from the command line.

One binary. No server, nothing uploaded. Same sessions the browser reads, over SSH, inside a container, wherever you're already working.

vcr

The bare command: a banner and where every subcommand lives.

vcr ls

Every session vcr can find, across agents, newest first.

vcr stats

The full digest for one session: cost, tokens, tool time, dead air.

vcr replay

The same three-column workspace as the browser, sized to your terminal.

vcr watch

Follows a live session and calls out trouble as it happens.

~/code/den-landing - vcr
$ vcr

┌─────┐
│ ● ■ │  vcr
└─────┘

Replay, inspect and watch AI coding sessions: Claude Code, Codex, more soon.

USAGE
  vcr <command> [session]

COMMANDS
  ls        list every session vcr can find
  stats     the full digest for one session
  replay    the three-column workspace, in your terminal
  watch     follow a live session, flag trouble as it happens

  vcr <command> --help for more on each one.
Track 04 · frequently asked

Questions, answered.

I don't trust running things in YOLO mode.

Fair. Run the agent inside a Docker Sandbox instead, an isolated environment that keeps YOLO's blast radius off your actual machine, so replaying the session afterwards isn't the only safety net.

If you'd rather have a GUI on top of that than drive sandboxes from a terminal, den is an ADE (Agentic Development Environment) built around exactly this: Docker Sandbox support with no command line required. An agent running inside one of its sandboxes writes its session log exactly the way it would anywhere else, and Den can export that log straight to VCR from inside the sandbox: no manual copy step between the run finishing and you replaying it here.

Does any of this leave my machine?

No. The .jsonl is read with the local File API and parsed in the page: no server, no build step, no upload. That holds whether you drop a tape on the deck above or open one with vcr replay in a terminal.

What can I actually get out of a tape (.jsonl)?

The whole session, not a summary of it. Every tape carries:

  • Wall-clock duration
  • Every prompt and response
  • Tool calls, with arguments and results
  • Errors and timeouts, marked where they happened
  • Token counts: input, output, cache
  • Cost, in dollars
  • URLs and endpoints it touched
  • Model and stop reason
  • Busiest tool

If the session ran inside a Docker Sandbox on version 0.42 or later, the .jsonl also carries policy hits: the network and permission rules that fired during the run. A Docker Sandbox isn't required to use VCR at all, though. Any .jsonl one of the supported agents writes works the same way.

What are the demo tapes?

Five real recordings, not scripted demos. Each one started from a single one-shot prompt — copy-pasted straight into the agent, then left alone to build, test and (usually) get it running — and nothing has been edited out of the log afterward. Pick one from Try a demo tape above, or from the drop screen inside the app itself.

Which coding agents are supported?

Claude Code today. OpenAI Codex, Gemini CLI, Cursor, GitHub Copilot and Kiro are next. The session format each of them writes is public, so adding a reader for one is a parser, not a rewrite.

  • Claude CodeSupported
  • OpenAI CodexExperimental
  • Gemini CLISoon
  • CursorSoon
  • GitHub CopilotSoon
  • KiroSoon
Where does it find my session logs?

It doesn't go looking. You hand it one. Claude Code writes to ~/.claude/projects/, Codex to ~/.codex/sessions/. The Where are my session logs link on the deck above has the exact path for your OS.

Do I need to install anything?

Not to use the deck above: that's just a browser tab. A CLI is also there if you'd rather stay in the terminal: vcr ls, stats, replay and watch.

Is VCR open source?

Yes, Apache 2.0. The source, the parser and this page are all on GitHub.

Rec
Hero
00:00