code graph · local · MCP

Your agent is guessing.Take it to the marrow.

CodeMarrow indexes a repository into a graph of symbols, calls and framework wiring — on your machine — and hands it to any agent as tools.

Askresolving…
→

login() calls verifyToken(), then writes sessionStore at db/session.ts:31 — the write isn't ordered against the expiry read.

01 — the problem

Grep finds text. It doesn't find reasons.

Agents read a codebase the way you'd read a phone book: one file at a time, matching strings, hoping the answer is nearby. Two hundred hits for "login", and none of them say why it fails on Tuesdays.

02 — index once

Turn the repo into a graph. On this machine.

Parsing, symbol resolution, call edges and framework wiring — deterministic and CPU-bound. No model, no upload, no minimum spec. The graph is written beside the repo and updates as files change.

03 — ask in structure

Follow the call, not the keyword.

"Why is login failing intermittently?" becomes a walk through real edges: router, handler, token check, the write that isn't ordered against the read. The answer cites lines, because it came from them.

04 — know what breaks

See the blast radius before the diff.

Change a signature and CodeMarrow resolves everything that reaches it — callers of callers, and the middleware and wrappers around them. Your agent plans the whole change instead of discovering it in CI.

05 — any agent

One map. Every agent reads it.

The same tools the app uses are served over MCP, read-only. Claude Code, Codex or any MCP client gets structure instead of search — with one line of setup.

$ grep -rn "login" src/
src/auth/login.ts:8 export async function login(req, res) {
src/auth/login.ts:41 // TODO: login retries?
src/ui/LoginForm.tsx:3 import { login } from '../api';
src/ui/LoginForm.tsx:57 <button>Log in</button>
src/api/index.ts:19 export { login, logout } from './auth';
… 209 more
214 matches · 61 files0 explain the failure
why it's different

Coding agents write code.
They don't know it.

CodeMarrow isn't another agent. It's the thing agents are missing: a structural model of the codebase they can query instead of re-reading. Keep the agent you like — give it something true to stand on.

Building
An agent on its ownGreps, opens forty files to change one signature, and finds the fifth caller when CI fails.
An agent with CodeMarrowAsks for the blast radius first and plans the whole change — every caller, every middleware around it — before the first edit.
Testing
An agent on its ownWrites tests for the file it happened to read, then loops until they pass. The paths that actually break go untested.
An agent with CodeMarrowDerives cases from real execution paths — every route and caller that reaches the code under test — so the paths that break get tested.
Debugging
An agent on its ownPastes whole files into context until the window fills, then guesses. Only the biggest models keep up.
An agent with CodeMarrowWalks the call path a few symbols at a time. The answer arrives with line citations, in a context small enough for a local model.
Code review
An agent on its ownA diff shows the lines that changed. It says nothing about what those lines reach.
An agent with CodeMarrowEach changed symbol comes with its callers and reach, so reviewers — human or not — look where the risk is.
Readability
An agent on its ownA new teammate — or a new session — starts from a file tree and a README that drifted.
An agent with CodeMarrowStarts from entrypoints and flows. "How does a charge become a ledger entry?" is one trace, not an afternoon.
CI/CDsoon
An agent on its ownEvery change runs every test, and nobody can say why a one-line fix touched the billing path.
An agent with CodeMarrowRun only what a change reaches, and flag pull requests whose blast radius crosses a boundary you care about.

Why symbols, not files.

A file is a place. A symbol is a meaning: one name, one definition, and edges to everything it calls and everything that calls it. Questions about code are questions about those edges — so the answer is a short walk, not a long read.

verifyToken()auth/token.ts:22
callers
login · refresh · wsAuth
calls
decodeJwt · clock.now
packages
jsonwebtoken
entry
POST /api/login

Small models can debug now.

When the tools return a few precise symbols instead of whole files, the model's job shrinks to reasoning over a short trace. A small local model like Gemma 4 E4B can follow it — no frontier model, no context-window anxiety, nothing sent anywhere.

Context used · "why is login failing?"gemma-4-e4b · local
Agent alone — reads 38 files~0k tokens
With CodeMarrow — 4 tool calls~0.0k tokens
Illustrative: a login trace on a 600-file TypeScript repo.
the desktop app

Search a symbol.
See everything that reaches it.

The same graph your agent queries, drawn. Callers on the left, what it reaches on the right, with every link placed at its call site.

The CodeMarrow desktop app tracing useScrollFrame in this website’s source: the hooks that call it, the sections that use them, and what it calls.
Real, not a mockup: CodeMarrow tracing this website’s own source.

Built to stay out of the way.

stays local

Embedded SQLite beside the repo. No database process, no cloud call, nothing leaves the machine.

incremental

A mid-size repo indexes in seconds. Edits update the graph instead of rebuilding it.

deterministic

The same repo gives the same graph, every time. No model is involved in building it.

Point it at a repo.

Index in seconds, then ask how the code actually connects — in the app or from your agent.

$ go install codemarrow/cmd/codemarrow@latest
Setup guide, MCP config and tool reference →