Like upgrading your model — without the bill.

Sharper answers, fewer wrong turns

Your agent reasons over a real call graph instead of guessing from grep hits. Ask "what breaks if I change this?" and it answers from actual callers — across files, across repos, across service boundaries. Fewer hallucinated imports, fewer cross-wired functions, fewer dead ends.

Precise chunks, not whole files

Instead of dumping whole files into context, your agent pulls the exact chunk it needs in one indexed query. On broad scans, compact mode trims that tool output up to 80% — the difference between a bloated, noisy context and a tight, focused one.

It finally remembers

Decisions, gotchas, fixes and to-dos persist across sessions and across every AI client you run. Stop re-explaining your architecture twice a day — the next session starts where the last one stopped. And it stays yours: memory is plain files on your disk, exportable to markdown you can commit to your repo.

100% local, 100% yours

Everything runs on localhost — indexing, search, memory. No cloud, no telemetry on your source, no training on your code. We literally cannot see it. Works fully offline on a 16 GB laptop.

Commoditization

“Won’t Cursor and Copilot just build this in?”

They’re building retrieval — inside their own walls.

• A built-in index belongs to the tool, not to you. Switch IDE, model or vendor and your context stays behind. codeindexer sits a layer above your tools — move from Claude to Gemini to a local model and keep the graph, the search, the memory.
• An IDE vendor profits from lock-in, so portable context is the one feature they won’t ship. Building on an open standard (MCP) is the opposite bet.
• Built-in retrieval is embedding search. A cross-language call graph, blast radius, persistent memory and a security audit are a different category of tool.
• And if they do catch up? You’ve lost nothing — see the next card.

Dependency risk

“Isn’t this another dependency we can’t see into?”

It never enters your dependency tree.

• Not in package.json, not in Cargo.toml, not in CI, not in production. Your build — and your users — cannot be affected by it.
• Everything it produces is plain files on your disk: the index, the embeddings, the memory. Inspect them, back them up, delete them.
• The Free tier makes no network calls at all — there’s nothing to audit on the wire.
• Switching it off tomorrow costs you convenience, not a broken build. Uninstall is rm, not a migration project.

Knowledge ownership

“Shouldn’t our decisions live in our repo, not in a tool?”

They do. That’s the design.

• Memory is files on your machine — and decisions, cards and reports export to plain markdown you can commit right next to your code.
• The index is derived data. Your repo stays the single source of truth; codeindexer just makes it queryable for the agent.
• It’s memory for the agent, not a replacement for your docs — the agent reads it so your team stops re-explaining the architecture every session.

The honest one

“Do we actually need it?”

Maybe not. Honestly.

• Small repo, one AI client, an agent that never gets lost, nobody re-solving solved problems? Skip it — you’re fine.
• It starts paying when the codebase outgrows the context window, the agent greps in circles and re-reads the same files, you run more than one AI tool or model, or the same architecture gets re-explained every week.
• Free for 3 projects, no card, no cloud — the cheapest way to find out is to point it at your gnarliest repo for a day.