What Backthread actually does.
Backthread helps engineers and teams understand their own codebase while AI agents do the coding. It reads your agent sessions and git history and turns them into a short, ranked list of what changed — the decisions your agent made, the tradeoffs it accepted, and the risks it left behind — each with the reasoning behind it. It all lives on a live architecture diagram you can rewind through time, so you see not just what your system is, but how it got there. You keep the mental model without re-reading the code.
- Stop digging through old code to remember why it works that way.
- Stop reading every PR just to stay in the loop.
- Stop relearning a system you're supposed to own.
Three steps, then it runs itself.
It reads the reasoning
Your agent sessions, commits, PRs, reviews, and the issues linked to your work — the why that a diff and a code review never show.
It extracts what matters
One pass turns all of it into decisions, accepted tradeoffs and potential risks — ranked, deduplicated, each with its rationale.
It shows the short list
You get a feed of what's worth understanding, on a live map of your system you can scroll back through in time.
It matters more with a team.
As models improve, more code ships without a human ever reading it — and review becomes the bottleneck. On a team, no single person saw everything the agents built. Backthread gives everyone the same view of what changed and why — above the diff, alongside review, not a review tool — so reviewers and new hires don't rebuild the architecture from PRs. A daily or weekly digest keeps the whole team current without a meeting.
See it on a real codebase.
A live demo runs on a real repo. Open the map, click a module, and read the decision, tradeoff or risk behind it — with the reasoning, not just the diff.
Open the live demo →Your code stays yours.
Backthread connects to two things — your GitHub repo, to build the map, and your coding agent, to capture the why. Here's what each one does with your code.
Reads your code to build the map
The GitHub App copies your repo into a temporary sandbox, reads its structure, and deletes it. Your code is never saved to our database. Read-only, one repo at a time, revoke anytime. Private repos stay private.
Reads your sessions to capture the why
The plugin reads your agent's chat on your own machine, strips the code and command output, and sends only the plain-English "why." Your code itself is never sent. It's open source, so you can check it →
The full list of what leaves your machine, what we store, and every sub-processor is on /security →
One command. Any agent.
See it on your own repo, free. It connects your repo, installs capture in your agent, and builds your first map.
npx backthreadIn Claude Code, run /backthread:start — same flow, built in. Works with Claude Code, Cursor, Codex & Gemini.
Free to see it. Cheap to keep it.
Build your repo once, free. After that, a flat price per seat with a monthly allowance included — go over it and you pay a clear per-unit rate.
Free
A real build of your own repo. Once.
- One full build of one repo
- Your real map + decision log
- Ask it anything, once it's built
Solo
For when you are the whole eng team.
- 1 seat · 1 repo
- Rebuilds on every merge to main
- Full history + time slider
- Ask it anything, any time
Team
For the 2–30 people losing track together.
- Seats you add and drop, GitHub-style
- Everyone's decisions on one shared map
- Shared answers across the whole team
- 300 rebuilds + 500 sessions per seat
Extra repos: +$10/mo each; you get one to start. Over your monthly limit? $0.20 per rebuild, $5 per 1,000 sessions. Most people never get close.
Things you might be wondering.
How is this different from a code-review tool or a wiki?
Code review checks the lines in one PR; a wiki is stale the day it's written. Backthread sits above the diff — it shows what your whole system is now, what changed, and the decisions, tradeoffs and risks behind it. And it rebuilds on every merge, so it never drifts from what's actually shipped.
Can I just ask how something works?
Yes. Ask "how does X work?" or "why is it built this way?" right in your agent, or run /backthread:how. You get a short, cited answer pulled from your real decision history — not a guess from re-reading the code, which costs 100×+ the tokens to derive that way.
Will it go stale?
No. It rebuilds on every merge to your main branch, so the diagram, decisions and risks always match what's actually shipped. You're never reading a diagram someone drew six months ago.
Do you read or store my code?
No. We copy your repo into an isolated sandbox, read its structure, save only the diagram and decisions, then destroy the sandbox — your code never lands in our database, logs or backups. The agent plugin strips code and command output on your own machine before anything is sent, and that client is open source, so you can check it. Full details on /security.
Does it work with my agent and repo?
It works with Claude Code, Cursor, Codex and Gemini, on any GitHub repo — public or private. One command — npx backthread — connects your repo, installs capture in your agent, and builds your first diagram, free.
Who's building this?
I'm Jevgeni — I build with the same coding agents Backthread is made for, and I kept losing the plot on what they'd changed and why. Backthread is the tool I wanted: it keeps the reasoning behind a codebase visible while the agents work. It's live today at app.backthread.dev. If your team is delegating real work to AI, I'd like to hear how it holds up on your repo.
Understand your own
codebase again.
Point Backthread at your repo. See every decision, tradeoff and risk — and the why behind each one.