The flight recorder for AI coding agents

Review your agent's work before it becomes history.

Your agent narrates its own work — and the narration is confidently wrong just often enough to matter. Gurgeh records what actually happened, turn by turn, so you catch it on your machine — before the commit, before the push, before anyone else has to.

Local-first · No signup · Observed, not narrated · Launching 2026

gurgeh — acme-payments-api · prompt 3 of 3 · nothing committed yet
"The webhook signature test is flaky — fix it so CI is green."
Agent said"All tests pass — 12 passed in 0.42s." ✓
Observedpytest exit 1 · observed  the suite actually failed
Turn 4edited src/payments/legacy_reconcile.py, reverted it in turn 6 — no commit will ever show this
⚑ src/payments/verify.py changed — nobody mentioned it
✓ reviewed → gurgeh commit --per-task · clean, intent-labeled commits, authored from the record
The problem

The diff you review is the story's last page.

Your agents run overnight, touch 200 files, and hand you a final diff with a tidy summary. The diff tells you what survived. It can't tell you why it changed, what was tried and reverted, or whether "all tests pass" was ever true. So you skim, you approve, and you hope. Gurgeh ends the hoping — while the work is still on your machine.

Before the commit

The capture point decides what you can ever know.

Some tools staple the conversation to your commits — provenance, after the fact. But a record captured at commit time can only contain what survived to commit time: the final diff, plus the agent's own account of itself. Gurgeh records at every turn, while the information still exists.

Captured at the commit

The final diff, flattened. Ordering and intermediate states are gone.
The transcript as the agent told it — narration, notarized.
Dead ends and reverts never appear. They never reached a commit.
Review happens downstream, in the PR — after history exists.
The conversation — prompts, tool output, whatever the agent read — pushes to every clone.

Captured at every turn

Per-turn diffs — which instruction caused which change.
Observed outcomes — real exit codes beside the agent's claims.
Dead ends kept — the file it touched and quietly reverted is often the review signal that matters most.
Review first — then gurgeh commit --per-task writes clean, intent-labeled commits.
Local until you choose — share distilled intent in the PR, not a raw transcript in the commit graph.

The asymmetry: everything a commit-time record contains can be derived from a turn-time record. The reverse is impossible — by commit time, the trajectory no longer exists. And because review happens first, the commit stops being a snapshot of whatever the agent left behind and becomes the output of your review: history gets cleaner, not just better-annotated.

Observed, not narrated

An agent's account of its own work is exactly as trustworthy as anyone's.

Usually fine — and occasionally, expensively, not. A record you can act on has to come from the machine, not the narrator. Gurgeh records what the tools actually did, and marks the difference.

What it catches

observedreal exit codes, not the agent's narration — "12 passed" can't hide a failing suite.
unexplaineda file changed that nobody discussed — the edit most likely to hurt you, surfaced first.
groupedovernight loops collapse into one reviewable unit, not 40 commits.

The record

vs gitgit shows what survived. Gurgeh shows why — and what didn't survive.
vs AI reviewthey re-derive intent from the final diff. Gurgeh kept the actual intent — the prompt, the plan, the turn it happened in.
attributedevery event marked observed or inferred — a guess is fine for a review aid, unacceptable as provenance.
How it works

Capture. Review. Then commit.

01 · Capture

As it happens

Supported hooks record real prompts, tool results, and exit codes; working-copy snapshots capture every turn's changes. Your existing history ingests retroactively the moment you install.

02 · Review

Before it's history

A timeline of what the agent set out to do, what it claimed, and what actually happened — with unexplained changes and failed claims flagged, while everything is still local and fixable.

03 · Commit & share

Clean by construction

Promote reviewed work into intent-labeled commits, split by task. Share the distilled record in the PR description — your team gets the why, not a transcript dump.

Local-first

Your code — and your conversations — never leave your machine.

No cloud. No account. No telemetry. And nothing embedded in your commit graph: prompts, tool output, and everything your agent read stay local until you deliberately share the distilled intent. When your team's ready, the shared record is opt-in — redacted at capture, on-premises a first-class option.

◇ runs on your laptop◇ no account◇ no telemetry◇ nothing pushed by default◇ signed binaries
Launching 2026 · Free & open source

Be first on the record.

Gurgeh launches publicly later this year — local-first, open source, and the full local experience free forever. Early access goes to people who review agent code every day. Tell us what you run and we'll get you in.

$ curl -LsSf https://gurgeh.ai/install.sh | sh  — at launch