Your codebase remembers why.
The reasoning behind every change lives in the conversation, not the diff — and walks out the door when people leave. The Intern captures the why as it happens and feeds it back to any agent before it touches your code.
Two-line install · Works with Claude Code · No credit card needed
Retrieved before edit · lines 42–61
why:sessions are pinned to a single region on purpose — the EU tenant's data-residency promise breaks if a token validates against us-east. Do not "simplify" this into a global lookup.
Retrieved before edit · lines 88–104
why:the retry loop is intentionally capped at 1 — Ricoh's gateway double-charges on idempotency-key reuse.
Plugs into the tools your team already uses
The Memory Layer
Institutional memory that lives with your code
Git holds the diff. The reasoning lives in the session transcript and disappears the moment it ends. The Memory Layer correlates the two — so the why behind a change is never lost, and never has to be reconstructed from scratch.
Capture the why, as it happens
When an agent picks between alternatives, adds a workaround, or settles a design question, the reasoning is recorded against the exact files and line ranges it concerns — straight from the session, not the commit message.
Vectorised against your code
Every decision is embedded and tied to (repo, file, line range). Retrieval is a similarity search filtered by file overlap — given the lines you're about to touch, the most relevant reasoning surfaces first.
Read back before any edit
Before an agent — or a new engineer — touches a file, the institutional memory for those lines is read back. No more re-deriving decisions that were settled months ago by someone who has since left.
Assumptions graduate to canonical
Reasoning on a feature branch is provisional. When the code lands on your default branch, the matching context graduates to canonical and retrieval weights it higher. Provisional context is flagged in amber.
The Intern
Built on the memory layerAn agent that works like it's been here for years
The memory layer is the product. The Intern is what becomes possible once your agents have it: a teammate that picks up a ticket, reads the reasoning behind the code it's about to change, ships a PR, and closes the loop with the human who raised it — instead of treating your codebase like a contractor seeing it for the first time.
- 1Picks up a ticket from a Linear label
- 2Reads the institutional memory for every file it will touch
- 3Does the work and opens a pull request
- 4Reports back to whoever raised it — in plain English
How it works
The loop closes itself
You don't change how you work. As decisions get made, the reasoning behind them is captured, kept accurate, and handed to whoever touches that code next — so the hard-won context behind your codebase stays with it instead of walking out the door.
Captured as it happens
The thinking behind every non-obvious choice is recorded in the moment it's made. No docs to write, no wiki to keep current, nothing to remember to do — it happens in the background while the work gets done.
Kept tied to the work
Each piece of reasoning stays matched to the exact code it explains, and keeps step as that code changes. What was true last quarter never quietly becomes misleading — context you can trust, not a stale doc.
Surfaced before the next edit
Whoever picks up the code next — a new hire or an agent — gets the relevant history first. Settled decisions don't get re-argued, and hard-won workarounds don't get undone by accident.
Security & privacy
Your code and your keys stay yours
Bring your own key
Team API keys are stored encrypted in your Supabase project and decrypted server-side only at call time. Data and cost stay in your pipeline — never logged, never exposed.
Multi-tenant from day one
Every row is scoped to a team and protected by row-level security. There is no global context, and no query can cross tenants.
The patch is derivable, not precious
We keep repo, SHA and line ranges — not your source. The actual diff is pulled from GitHub only when it's needed.
Stop letting the reasoning walk out the door
Give your agents the institutional memory a senior engineer would have. Two lines to install, and it starts capturing on your next commit.