Progressive disclosure of your codebase's how-it-works.
The why first, the diagram underneath. Every decision the agent made, logged with its rationale; click one and the diagram lights up where it landed. Hover any module for its full changelog.
Decisions
Every decision the agent made, logged with its rationale, captured as it works — not reverse-engineered from diffs after the fact. The red dots are the ones you never signed off on.
Diagram
The whiteboard sketch of your system, auto-built — a live diagram that lights up to answer questions. Hover any module for its changelog; drag the slider to see what it looked like when "it used to work."
Backthread tells you what to look at — not just where to look.
The agent makes calls all day — algorithm swaps, default choices, quiet tradeoffs. Backthread logs each one with its why, and pins a red dot on the ones you never signed off on.
What you actually stop doing.
Not capabilities. Habits you can drop when the codebase explains itself again.
Stop reading every PR.
Decisions flag the calls that actually matter; the changelog keeps the receipt for everything else. Read the few that count. Or don't.
Quit treating AGENTS.md like a doc for you.
Forty-eight context files keep the agent on track. That's what they're for. Backthread is the human-readable equivalent — a current map of what's there and why.
Stop re-deriving the structure on a Sunday.
The architecture was getting captured the whole time. You just didn't have anywhere to see it.
Stop doing archaeology before every bugfix.
Every bug used to start with an excavation: what is this file, why is it like this. Now it starts with the decision log.
Your source stays yours.
Backthread reads your code to build the diagram and your agent's sessions to capture the why — and keeps neither. Exactly what that means:
Clone, parse, destroy
The GitHub App reads your repo in an ephemeral sandbox, extracts the structure, and throws it away. Your source is never written to our database.
Redaction on your machine
Capture strips each agent transcript on your machine — code and tool output dropped — and sends only the redacted prose. Your code never leaves your laptop in the clear. It's open source — audit the redaction code →
You pick the repos
Per-repo install, read-only access, revocable any time from GitHub. Private repos stay private — there's no make-public toggle.
The full boundary — what leaves your machine, what we store, and every sub-processor — is on /security.
There's a working demo. Go poke it.
Not screenshots — it's running. Click a decision to light up the modules it touches, read the why the agent gave, drag the time slider to scrub history.
Decision log, module graph that lights up on click, hover-changelog, draggable time slider snapped to commits. The full thing auto-builds from your repo and your agent's sessions.
open prototype →Start in one line.
npx backthread/plugin install backthread@backthreadthen run /backthread:start — same setup, native to Claude Code.
npx backthread install --agent codexnpx backthread install --agent cursornpx backthread install --agent geminiPriced per seat. Usage on top, only when you go big.
See it on your own repo once, free. After that it's a flat per-seat price with a generous monthly allowance baked in — and if you blow past it, the extra is a plain per-unit price you can see coming, never opaque token math. You're early, so these numbers might still wiggle.
Free
A real build of your own repo. Once.
- One full build of one repo
- Your real map + decision log
- Frozen in time — no refresh
Solo
For when you are the whole eng team.
- 1 seat · 1 repo
- Rebuilds itself on every merge to main
- Full history + time slider
- 300 rebuilds + 500 agent sessions / mo
Team
For the 2–30 people losing the thread together.
- Seats you add and drop, GitHub-style
- Everyone's decisions on one shared map
- Audit log + SSO
- 300 rebuilds + 500 sessions per seat
Enterprise
More repos, more people, more rules.
- Volume seat pricing
- SAML · data-retention controls
- Security review
Extra repos: +$10/mo each — you get one to start. Past your monthly limits? $0.20 a rebuild, $5 per 1,000 sessions. Most people never get close.
Things you might be wondering.
I'm shipping fast right now — do I actually need this?
Probably sooner than you think. The pain isn't dramatic on day one — it's the slow loss of being able to say what your system actually does without re-reading the source. Most people hit it around the third week of agent-heavy delegation: every bug suddenly needs an archaeology session before it can be fixed. Backthread keeps the mental model alive without you having to rebuild it by hand each time.
I just vibe-code — the agent handles everything. Do I need this?
Not yet. You'll know when. The moment you open files the agent wrote and don't recognise them, you'll need either Backthread or a few unplanned hours of forensic re-reading. We'd rather sell you the first one before the second one happens.
I read every PR diff anyway. Isn't this redundant?
Respect — and also: you're paying a velocity tax you might not be tracking. Reading every diff is fine for codebases you mostly wrote. For codebases where 30-70% is the agent's call, you're parsing a lot of noise to find the handful of decisions that actually matter. Backthread flags those decisions directly, so you can read the few that count instead of all of them.
How is this different from a code-review tool?
Code-review tools show you what changed in this PR. Backthread shows you what your system is, accumulated over every PR — and what it was a month ago, and why it changed. Different temporal slice, different question.
Do you read or store my code?
We clone your repo into an isolated sandbox, parse it, write only the derived diagram + changelog to our database, then destroy the sandbox. Your source code never lands in our database, logs, or backups. The long version with the load-bearing detail is on /security. If your org has a hard rule against any third-party reading code, Backthread can't help you yet.
Wait — does the plugin read my Claude Code transcripts?
Yes — and it strips them on your machine before anything leaves it. Every tool call and its output (the parts carrying your source code and command output) is dropped; code blocks in the remaining prose become [code redacted]. What survives — natural-language conversation, plus the repo-relative file paths the session touched (metadata — directory structure, not file contents) used as the anchor onto your architecture — is sent to our server, run through the extractor, and discarded: processed in memory, never stored. We keep the derived decisions: a short claim, the why, a date. The honest fine print: on the default path that redacted prose does leave your machine — paths are metadata, not source, so never-store-source still holds; never source code, never tool output. The full boundary is on /security, and the device token the plugin authenticates with is revocable in one click.
Who's building this?
Solo founder so far, building it in the open. I've been heavily delegating to the same agents Backthread is built for — which is how I noticed the problem. There's a working prototype at app.backthread.dev; the waitlist is how I'll find the first 20 testers.
The agent keeps shipping. Keep the thread.
It's live and free to start — one full build of your own repo, no card. If you've felt any of the above, you're exactly who we're building this for.
npx backthread · see how →