The why
behind
your code.
An agent reads what your code does in seconds, then guesses at why it is that way with the same confidence. The why was never in the code. It is in a PR from a year ago, a call no one wrote down, an engineer who left in March. Spelunk keeps that why, captured as you work and on tap for every agent you use.
git tracks what changed. Spelunk remembers why.
Why was this
written?
An agent reads what a function does in seconds, then answers why it is that way with exactly the same confidence. The catch is that the why was never in the code. It lives in a pull request from a year ago, a call no one wrote down, an engineer who left in March. Run git blame and you land on "fix tests".
So the agent guesses. It removes a guard clause that looks paranoid, modernises a slow path that looks like dead weight, ships a clean diff with passing tests. Three weeks later the thing that guard was guarding against happens in production. That gap between a fluent answer and a guessed one is where the expensive mistakes and the rework live, and it is paid by whoever inherits the change.
The why, kept.
So agents stop guessing.
Spelunk keeps the reasoning behind your code, captured as you work and shared across the team. Your agents answer "why is it this way" from something a teammate committed, not from a guess.
When the agent can see why a thing was built the way it was, it stops rewriting choices that were deliberate. You spend less time catching regressions in review and less time undoing confident mistakes after they ship.
Teams who parachute into codebases they did not write get to the first correct change sooner. The context a previous session wrote down is on the next agent's first query, so nobody starts from a blank page in someone else's repo.
The memory travels with the repo, so a decision stays answerable when the person who made it leaves and when you change agents. One engineer's sharper convention quietly becomes everyone's default, because the next query surfaces it.
Why this holds
where others let go.
Each of these is a thing you do not have to bet on. You do not bet that the team will keep up the bookkeeping, that you will still use the same agent next year, or that a vendor will let you take your context with you.
- Auto-capture, no authoring tax. The team does no extra work to keep the why. It is a by-product of the change, not a chore beside it.
- Cross-harness by design. The memory layer does not change when the agent does. Run two agents at once and they share one brain.
- Yours, on your disk. Owning your memory means owning it, not renting it back from the company that wrote the tool.
- Deterministic and drift-aware. Same answer every time, tied to the commit it came from, so it tracks the code instead of drifting loose.
The mechanism,
as proof.
The value case rests on a small set of deliberate choices. Here they are plainly, for the reader who wants to know how the claims above actually hold.
Tree-sitter AST chunking splits code at function and class boundaries across roughly 20 languages, alongside a code graph of callers, callees, and imports. Retrieval is BM25 and semantic search, fused, so the agent reasons about structure rather than loose tokens.
Decisions are written through to git notes, anchored to commits, carrying the commit SHA as provenance. Git had the feature the whole time. A note travels with the object, so the why clones and fetches the same way every other object in the repo does.
When a decision changes, the new entry supersedes the old one instead of replacing it. The current answer is what you get by default, and the superseded entry stays anchored to its commit, so "why did we used to do it the other way" remains answerable.
The CLI runs on your machine and the Server is self-hosted, with cloud optional. Asking for the history of a symbol or its state as of a past commit is grounded in git itself, so there is no graph database to stand up and nothing to back up beyond the repo.
Start with the CLI.
Grow with your team.
Hybrid base + included operations + soft-cap overage. We meter repos and operations, not humans or agents, so adding a teammate never changes the bill. Bring your own LLM keys.
The CLI and the self-hosted Server. MIT licensed. Local code intelligence, AST indexing, hybrid search, memory — zero cloud dependency.
- Local AST indexing & code graph
- Hybrid BM25 + semantic search
- Memory with supersede & harvest
- Self-hosted Server (Docker)
- Community support
Managed deployment with real-time agent coordination. For small teams and consultancies on a single project.
- Everything in OSS
- 3 repos · 30k ops / mo
- Live SSE memory stream
- Hash-chained audit log
- Social login (OIDC): Google, GitHub, Microsoft 365, Slack
- EU hosting (GCP eu-west)
Mid-size teams running multiple repos. Soft-cap overage at £8 per additional 10k ops, no surprise bills.
- Everything in Starter
- 8 repos · 120k ops / mo
- £8 / 10k ops overage
- Priority support
Larger teams that need bespoke identity and compliance. Sales-led, with terms shaped around your security review.
- Everything in Business
- SAML / SCIM single sign-on
- SCIM user provisioning
- Dedicated support & SLAs
Be first when
we open the gates.
Spelunk Cloud is in private beta. UK and EU teams first. Drop your email and we'll reach out when access opens for your team size — one email, no list, no spam.
You're on the list.
Check your inbox for a confirmation email — once you click the link, you're in. We'll reach out personally when access opens.