Git remembers what changed. hindsight remembers why.

Every conversation with a coding agent, kept next to the code it wrote.

Works with the agents your team already uses

Claude Code
Codex
Cursor
Gemini CLI
Copilot CLI
OpenCode
Amp
Droid
pi

The reasoning behind your codebase has moved into chat. It lives on one computer, in one person’s history, and most of it is gone within weeks. The diff survives. The why doesn’t.

Review intent, not just diffs.

Reviewers see the request, the decisions and the alternatives the agent rejected before they read a single line.

Make the whole team better with agents.

What your best engineers figured out spreads to everyone, as searchable prompts and skills every agent on the team gets.

Measure AI adoption honestly.

The share of changed lines matched to agent edits, per repository and pull request, with tokens and cost per commit.

Keep knowledge when people move on.

Months later, anyone can ask why a line exists and read the exact turn of the conversation that wrote it.

Product

The missing half of every commit.

hindsight records sessions while your team works and ties each one to the code it produced. Nobody changes how they work.

Commit page

Every commit, with the conversation that wrote it.

Prompts, replies, tool calls, plans and subagents, read as one thread. Next to it: the kind of work, tests run, models, tokens and an estimated cost.

Linked automatically through a commit trailer
Sessions from several agents, one timeline
Continue any session in your own agent

octo-org/lines

Keep the last line of input without a trailing newline

ana·5 hours ago·3 files·+19−0·100% matched

ana 17:41

The parser drops the last line of a file without a trailing newline. Find why, fix it and add a test.

Claude Code claude-opus-4-6

The scanner never flushed what was left after the last newline. Adding a test for it.

Explore agent Find where the last line is dropped

Read parse/scan.go

Created parse/scan_test.go +13

Ran go test ./parse/...

Attribution

Line-by-line attribution you can defend.

Each hunk of the diff is tied to the turn whose edits explain it: agent, mixed or human, with a confidence and a link to that turn. It says what the method knows, never guesses who typed a line.

Replays the agent’s edits against the real diff
Rolls up to pull requests and repositories
A number you can bring to the board

Changes3 files

parse/scan.go +3 −0

Agent · turn 1 · Explore agenthigh

21+     if rest != "" {22+         lines = append(lines, rest)23+     }

parse/config.go +2 −1

Mixed · turn 2 in the Codex sessionmedium

48-     MaxLine: 4096,48+     MaxLine: 64 * 1024,49+     KeepTrailing: true,

Matched to agent edits86%

AgentMixedNot matched

Pull requests

Pull requests that explain themselves.

A summary drawn from the conversations behind every commit: what was intended, what was decided, what was rejected and what is still open. On GitHub, one comment per pull request links each commit to its conversation.

Updated on every push, never a comment storm
Rejected alternatives, not just the final answer
Generated text is labeled as such

octo-org/atlas

Open

Search across sessions #12

Let people search the prompts and replies of every session they can read.

Decisions: Rank recent sessions first when scores tie.; Page with a cursor, not an offset.
Rejected: A separate search service.
Open items: Highlight the matched words in results.

Summary from 4 sessions behind 3 commits · generated text can be wrong

Decision record

Every decision, with the words that settled it.

hindsight proposes decisions from the conversations behind merged pull requests. Your team accepts them into a record: what was decided, what was rejected, who said it, and the pull request it shipped in.

Numbered, searchable, superseded when things change
Linked to the exact turn where it was decided
Your agents read it before they change things

Record· octo-org/atlas

Behind 3 commits

D-42Accepted

Page search results with a cursor

“Use a cursor, not an offset. Rows move under us while people scroll.”

Aada, in a conversation · the words that settled it

Rejected: Offset paging over a snapshot table.
Shipped in: Search across sessions #12
Accepted by: Jesus, 3 October

Ask why

Ask why. Or let your agent ask.

hindsight why names the commit, the session and the prompt behind any line. The built-in MCP server gives your agents the same memory, so they look up the reasoning before they rewrite it.

Works with Claude Code, Cursor, Gemini CLI and more
Reads only what you’re allowed to read
hindsight calls no model to answer

Claude Code· octo-org/atlas

marco 10:12

Why does search page with a cursor instead of an offset? I want to simplify it.

Claude Code claude-opus-5

hindsight why src/search/page.ts:18

hindsight read_conversation turns 4–6

Ada chose the cursor in pull request #12: offsets skipped rows when new sessions arrived mid-scroll. A test covers it. I’d keep the cursor and simplify the ranking instead.

Playbook

Skills that write themselves.

hindsight notices what people keep telling their agents, the retyped prompts and the corrections, and drafts a skill from it. Publish it once and it installs in every agent your team uses, each in its own format.

Suggestions found locally, or on your server
Published like code: owners publish, members propose
Checked for secrets and risky commands

Playbook· Suggestions

You’ve told agents “run the tests before you commit” 14 times in 6 sessions.

run-tests-firstSkill · draft

Publish

Before any commit, run the project’s test command and stop if a test fails.

Claude Code.claude/skills/run-tests-first/SKILL.md
Codex.agents/skills/run-tests-first/SKILL.md
pi.pi/skills/run-tests-first/SKILL.md

See your next commit with its conversation. Setup is one command per clone.

Get started Read the FAQ

New · hindsight Live

Your agents, finally aware of each other.

Five engineers, five agents, one repository. Live shows who is working where right now, and stops an agent once before it edits a file a teammate’s agent is already changing.

Liveocto-org/checkout4 working now

A
Anasrc/cart/totals.ts
Claude Code
J
Junsrc/api/orders.ts
Codex
M
Marcosrc/cart/totals.ts
Cursor
L
Leadocs/checkout.md
pi

Marco’s agent paused before editing src/cart/totals.ts

Ana’s agent is changing this file right now. It stops once, so they can coordinate before it goes ahead.

Watching AnaClaude Code · liveFork session

ana 11:02

Round line totals before tax, not after.

Claude Code claude-opus-5

Read src/cart/totals.ts

Editing src/cart/totals.ts

marco suggestion

Keep the rounding helper in money.ts. I’m changing it too.

Collision checks

An agent pauses once before editing a file another person’s agent is editing. No more silent overwrites between parallel sessions.

Watch and suggest

Open a teammate’s session as it happens and send a suggestion into it, kept under your name in the record.

Fork and continue

Take any live thread into your own agent. The new session shows where it came from.

Turn on Live Off by default. Owners and admins turn it on per workspace.

And the rest

Built for how teams actually ship with agents.

Search every conversation

Prompts and replies across the workspace, filtered by repository, author, agent, date and path.

Continue any session

Load a teammate’s session into your own Claude Code, Codex or pi as history, and pick up where they stopped.

See how you work with agents

A private read of each session: six habits from steering to verification, with the prompts that show them.

Cost per commit

Models, tokens and an estimated cost for every commit and pull request, from the sessions behind it.

Workspaces that mirror GitHub

Team and personal workspaces with roles. Reading never goes beyond what GitHub already allows.

Open export

Agent Trace records and session JSON for any repository, from the web, the API or the command line.

Security and control

Your reasoning stays on your infrastructure.

hindsight runs on a server you own. The CLI talks to that server and nothing else.

Self-hosted

One Node process and Postgres, deployed with Docker on your own server, in your own cloud.

Redacted twice

Secrets are scrubbed when a checkpoint is written, and again over every string before it’s uploaded.

No telemetry

No analytics, no phoning home. Model calls for summaries go through a provider you configure.

Tool output stays local

Command output, files read and search results aren’t uploaded by default. Neither are images.

Permissions follow GitHub

People read a conversation only if they belong to its workspace and can read the repository on GitHub.

Authors stay in control

Keep a session private, share one with a link that expires, or delete anything you uploaded, at any time.

9coding agents supported out of the box

2redaction passes before anything leaves a computer

0network calls before a commit returns

1server, yours, holding every conversation

Your server, your data, your rules. One Node process and Postgres, deployed with Docker.

Deploy hindsight See how it works

Get started

Three steps. Nothing new to learn.

No new workflow, no new review tool to adopt. Your team keeps committing the way it does today.

Link a repository

Signs in, installs hooks into every agent on the computer and into git, and registers the repository.

hindsight init

Work as usual

Hooks record each session. Every commit carries a checkpoint, uploaded in the background. Nothing waits.

git commit

Read the why

On the commit, on the pull request, in search, or straight from your agent while it works.

hindsight why app.ts:42

FAQ

What engineering leaders ask first.

Already have an account on this server? Sign in.

Get started

Where does our data live?

On a server you run. hindsight is one Node process and Postgres, deployed with Docker on your own infrastructure. The CLI uploads only to that server and sends no telemetry.

Will it make the whole team better with agents, not just better informed?

That’s the point. Prompts that worked are searchable, so people see how a teammate solved something before they try, and can continue that session in their own agent. What people keep telling their agents becomes a skill every agent on the team gets. Live lets anyone watch a teammate’s session as it happens. And each person gets a private read of their own habits, from planning to verification, with the prompts that show them.

How fast do new engineers get up to speed?

Faster, because the reasoning is written down. They read why the code is the way it is in the conversations that wrote it, and hindsight why answers for any line. Their agents start with the same history and the team’s skills from day one.

Will it slow down commits?

No. Hooks record the session locally while people work. The upload runs in a detached process after the commit returns, and failed uploads stay queued and retry on their own.

How do you keep secrets out?

Secrets are redacted twice: once when a checkpoint is written on the computer, and again over every string of the upload. Tool output, such as command output and files read, isn’t uploaded by default, and neither are images.

Who can read a conversation?

Every session is private or team. Team sessions are readable by members of the repository’s workspace who can also read the repository on GitHub. Authors can share a single session with a person, or through a link that expires.

Can engineers delete what they uploaded?

Yes, at any time. hindsight delete removes one session and hindsight disable removes everything a computer uploaded for a repository. Summaries drawn from a deleted session go with it.

How is attribution calculated?

hindsight replays each agent edit against the commit’s real diff and ties every hunk to the turn whose edits explain it: agent, mixed or not matched, with a confidence. It reports what the method can show, never a guess about who typed a line.

Which agents are supported?

Claude Code, Codex and pi are verified with real sessions. Cursor, Gemini CLI, OpenCode, Copilot CLI, Droid and Amp are supported too. hindsight init sets up every one it finds on the computer.

Does hindsight send our code to an AI model?

Only for pull request summaries and playbook suggestions, through the OpenRouter key you configure, and only from team sessions. Answers to “why” come from your own agent: hindsight calls no model for them.

What does hindsight Live change for us?

Nothing until an owner or admin turns it on for a workspace. Then agents pause once before editing a file a teammate’s agent is editing, and people can watch, suggest into and fork each other’s sessions.

Make every line of AI-written code explainable.

Your team’s best engineering thinking now happens in conversations with agents. Keep it with the code.

Get started See how it works