1
Map for zero tokens
Codna builds a dependency and blast-radius graph deterministically — no LLM, no embeddings, ~60ms per repo. It knows what a change touches before reading a line into a model.
Comparison
Codna vs Greptile
Greptile reads your pull request and tells you where the bug is. Codna takes it from there — it maps the repo deterministically, writes the fix, and proves it against your tests. One reviews. The other repairs and verifies.
The problem
Where Greptile stops
Greptile is a strong AI reviewer. It indexes your codebase into a semantic graph of functions, files, and dependencies, then on each pull request it traces the diff across that graph and leaves line-level comments with confidence scores and an impact summary. It is good at finding the bug, flagging cross-layer risk, and learning your team's conventions from past review comments. But a review ends at the comment. Someone still has to open the editor, write the patch, and confirm it actually works. The reviewer points at the problem; closing it is left to you.
How Codna fixes it
How Codna closes the loop
Whole repo100,000+
Evidence bundle~600
2
Fix from evidence, not a comment
Instead of a review note, the agent gets a ~600-token bundle — suspect files, call paths, the failing test — and writes the actual patch.
3
Prove it with your tests
Every fix is gated by your own test suite. A patch that fails tests never ships, so the change that lands is verified, not just suggested.
codna fix . --issue "Greptile flagged a null-deref in the auth middleware"
What you get
Where Codna goes beyond review
Deterministic graph, not an index
Codna maps your repo into an exact dependency and blast-radius graph in ~60ms for zero LLM tokens — no embeddings, no RAG. It is used to scope a real fix and bound what that fix can touch, not just to inform a comment.
A verified patch, not a comment
Greptile's review ends at a review comment; Codna takes the issue and writes the actual patch. Every fix is gated on your own test suite, so what lands is proven, not suggested — about $0.04 per verified fix at public model rates.
Private by default, model-agnostic
Codna self-hosts with bring-your-own-key and fail-closed egress, and never trains on your code. It ships as a CLI, an MCP server, and a native GitHub App, and runs on whatever model you choose.
The proof
Fewer tokens. Faster. Verified.
Frequently asked
No — it sits after it. Keep Greptile reviewing pull requests; hand the issues it surfaces to Codna to fix and verify. Review and repair are different jobs, and the two complement each other.
Greptile builds a graph/index of the repo to inform its PR review. Codna's graph is deterministic — a dependency and blast-radius map computed in ~60ms for zero LLM tokens — used to scope an actual fix and bound what it can affect, not to comment on a diff. One understands to review; the other understands to repair.
Yes, and that is the intended setup. Greptile stays your reviewer on every pull request; when a finding needs a real change, Codna maps the repo, writes the patch, and proves it against your tests. Connect them through the CLI, the MCP server, or the native GitHub App.
Your project's own test suite. Codna gates every patch on a passing run — if the tests fail, the fix never becomes a pull request. That is the difference between a review comment you still have to act on and a verified change that is ready to merge.
Greptile's published plan is a flat monthly allowance plus per-review overage (cited mid-2026: $30/mo for 50 reviews, then $1/review). Codna fixes from a ~600-token evidence bundle — about $0.04 per verified fix at public model rates — and is bring-your-own-key, so you pay your model provider directly. The deterministic understanding step costs zero tokens.
Yes. Codna self-hosts with bring-your-own-key and fail-closed egress, and never trains on your code — the deterministic map runs locally before anything reaches a model. It builds the graph from source directly, so it spans many ecosystems and is model-agnostic on whichever model you bring.
Related
