1
Map, don't retrieve
Codna builds an exact dependency and blast-radius graph deterministically — no embeddings, no similarity guess, ~60ms per repo for zero LLM tokens. It knows what actually breaks, not what reads similar.
Comparison
Codna vs Cursor
Cursor is a full AI IDE, and a good one. Codna is not trying to replace it. Codna is the precision layer underneath: a deterministic repo graph and a hard test gate that make the agent you already drive in Cursor surgical.
The problem
How Cursor understands your code
Cursor indexes your repository by chunking it into functions and classes, embedding each chunk into a vector, and storing those vectors so the agent can retrieve the most semantically similar pieces at query time. This RAG approach is fast and broad, and Cursor's Composer model and Cursor 3 agents act on what it returns. But retrieval is a similarity guess, not a map: it surfaces code that reads like your query, which is not always the code that actually breaks when you change a line. The index lives in Cursor's cloud (embeddings in Turbopuffer, paths obfuscated), and review safety leans on Bugbot — a probabilistic reviewer that catches most issues, not a gate that blocks the ones it misses.
How Codna fixes it
What Codna adds underneath Cursor
Whole repo100,000+
Evidence bundle~600
2
Hand Cursor a tight evidence bundle
Codna feeds a ~600-token bundle — suspect files, call paths, the failing test — to your agent through the MCP server. Cursor stays your cockpit; Codna aims it.
3
Gate every fix on your tests
A patch must pass your own suite before it ships. Not a probabilistic review pass — a hard gate. A fix that fails tests never reaches a pull request.
codna fix . --issue "the checkout test is failing" --mcp cursor
What you get
What Codna adds underneath Cursor
A deterministic graph, not a guess
Where Cursor retrieves code by vector similarity, Codna computes an exact dependency and blast-radius graph deterministically — no embeddings, no RAG, about 60ms per repo for zero LLM tokens. It knows what a change actually breaks, not what reads like your prompt.
A hard test gate on every fix
A patch must pass your own suite before it ships — a deterministic gate, not a probabilistic review pass. A fix that fails your tests never reaches a pull request.
It drives Cursor, you don't switch
Codna runs as an MCP server Cursor connects to, so the agent you already use gets the graph and the evidence bundle in place. Bring your own key, self-host with fail-closed egress, and no training on your code.
Measured: 5× fewer tokens, 1.7× faster
Across 87 verified tasks, Codna averaged ~16k tokens per fix versus Cursor's ~81k — 5× fewer — and ran 1.7× faster (13.4s vs 22.6s), at about $0.02 per fix. Run Codna standalone, or underneath Cursor through MCP.
The proof
Fewer tokens. Faster. Verified.
Frequently asked
No. Cursor is your IDE and agent cockpit; Codna is the understanding and verification layer beneath it. Codna exposes an MCP server that Cursor connects to, so the agent you already use gets a deterministic graph and a test gate without changing how you work.
Cursor retrieves code by vector similarity — a fast, broad guess at what's relevant. Codna computes an exact dependency and blast-radius graph deterministically, with no LLM and no embeddings, so it knows precisely which code a change affects rather than which code resembles your prompt.
Yes — that's the intended setup. Codna runs as an MCP server, so Cursor stays your cockpit and Codna feeds your agent a roughly 600-token evidence bundle of suspect files, call paths, and the failing test. You drive Cursor exactly as before; Codna just aims it.
Codna is model-agnostic via bring-your-own-key, so you can point it at whatever model you run in Cursor or a managed option. The deterministic map is language-agnostic — it built graphs for 130 repos across 110 languages in 9.2 seconds for zero LLM tokens — and it verifies against your existing test runner.
Yes. Like most RAG and embedding-based IDE indexes, Cursor is cloud-hosted. Codna runs fully self-hosted with bring-your-own-key and fail-closed egress, and never trains on your code; the deterministic graph runs locally for zero tokens.
The understanding step costs nothing — the deterministic graph uses zero LLM tokens. Each verified fix then works from a roughly 600-token evidence bundle instead of 100k, which measured at about $0.02 per fix versus roughly $1 for a typical agentic edit that reads the entire repo. In a measured head-to-head against Cursor across 87 tasks, Codna used 5× fewer tokens (~16k vs ~81k) and ran 1.7× faster, with every fix gated by a passing test.
Related
