1
Map the whole repo
Codna's deterministic engine indexes every symbol, dependency, and call path in ~60ms for 0 LLM tokens — no RAG, no embeddings. You see the shape of the code before reading a line.
Use case
Understand a new codebase with Codna
Joining an unfamiliar repo means reading for days before you trust a single change. Codna is an AI pair programmer that maps every symbol, dependency, and call path deterministically in ~60ms for 0 tokens — so codebase understanding starts from a real map of what calls what, not a wall of files.
The problem
The repo is large; the part you need is small
A new codebase hides its shape. You grep for a function and find forty call sites, none of which tell you which path actually runs in production, so you read more files trying to hold the whole thing in your head. The usual AI shortcut doesn't help much: to understand a codebase, most agents read the repo into context first, which costs ~100,000 tokens and tens of seconds before they can say anything useful — and they still miss the call paths that matter. The slow, expensive part of onboarding to a new codebase is reconstructing how the pieces connect, and that is exactly the work that gets skipped under deadline. Codna builds a dependency and blast-radius graph of the whole repo up front, so you begin from a map instead of a guess.
How Codna fixes it
How Codna helps you learn a repo
Whole repo100,000+
Evidence bundle~600
2
Explore from a ~600-token evidence bundle
Ask about any symbol and Codna hands back a focused bundle — definition, callers, and blast radius — instead of 100,000 tokens of raw files. That's 162x less context to follow when you're learning what does what.
3
Change it safely
When you're ready to edit, the agent works from that same map and every fix is verified by your own test suite before it lands. You learn the repo and ship in it from the same evidence, for about $0.04 per verified fix.
codna map .\ncodna explain . --symbol "OrderService.checkout"
What you get
What you get when onboarding
Zero-token deterministic map
The dependency and call-path graph is built locally in ~60ms per repo for 0 LLM tokens — no RAG, no embeddings, nothing sent to a model just to read your code.
A ~600-token evidence bundle
Every question is answered from a focused bundle — definition, callers, and blast radius — 162x less context than reading the raw files, so codebase understanding stays fast and grounded.
Verified before it lands
When you move from learning to changing, the AI pair programmer fixes from that same map and your own tests gate the result — about $0.04 per verified fix.
The proof
Fewer tokens. Faster. Verified.
Frequently asked
Codna maps the repo deterministically and locally — ~60ms per repo for 0 LLM tokens, no RAG and no embeddings. The AI only ever sees a small evidence bundle when you ask it a question or ask it to act, so your full source never has to be read into a model just to understand it.
Every symbol, its dependencies, the call paths that reach it, and its blast radius — what would be affected if you changed it. That's the context you'd otherwise spend days reconstructing by hand, handed to you as a ~600-token bundle instead of a wall of files.
Yes. Mapping and exploring are read-only. Use Codna purely to understand how the code fits together; when you do decide to fix something, the same map scopes the work and your tests verify the result.
Both, in order. It starts as a map you explore to understand the repo, and becomes a pair programmer the moment you ask for a change — fixing from the same evidence bundle and verifying every patch against your own test suite, for about $0.04 per fix.
In a measured run, Codna mapped 130 repos across 110 languages in 9.2s total — for 0 tokens. The map scales with the code, not with an AI's context window, so large monorepos are fine.
Codna ships as a CLI, an MCP server for Cursor and Claude, and a native GitHub App. For sensitive code you can self-host with your own keys (BYOK), fail-closed egress, and no training on your data.
Related
