Context Engines Feature Matrix

This matrix compares the twenty-one context tools profiled in this section, feature by feature, so the shortlisting step does not require reading twenty-one notes.

The interesting question is not which engine is best but whether a repository needs one at all: most codebases sit below the only published payback threshold in the category, and I claim most buyers of these engines are paying for an index their own vendors’ data cannot justify.

Legend: ✓ supported, ✗ not supported, ~ partial or conditional, ? not verified. Each column links to the full research note; every cell traces to a source cited there or in the references.

The matrix

#

Reading the matrix

#

This is not one market: a platform, a review-first code-intelligence graph, a hosted context-engine API, a docs-injection service, a code-map CLI, a graph CLI, a compression layer, a receipt-backed compression layer, a per-question search CLI, a prompt-compression library, a search engine, a packer CLI, a code-intelligence index with a code-health analytics suite, an output proxy, an on-demand search index, an LSP symbol toolkit, a search platform, a serialization convention, a text-to-SQL agent framework, and a governed data-semantics layer share a category label but sell twenty different jobs. Augment sells the author-review-verify loop around its engine; code-review-graph sells the smallest file set a change touches, traced through a stored AST graph; CodeAlive sells metered access to a hosted multi-repo index to whatever agent you already run; Context7 sells fresh third-party documentation injected at prompt time; Graft sells a readable map the agent opens like any other file; Graphify sells structural reasoning about one codebase; Headroom sells a smaller token bill for everything the agent reads, with the originals one retrieve away; Entroly sells proof about that same trade, every omission receipted and byte-exact recoverable; Jevgrep sells the first files of an answer, judged per query with no index to maintain; LLMLingua sells a smaller prompt, a small model deleting the tokens it judges unimportant before the big model reads anything; qmd sells local retrieval over your documents; Repomix sells one deterministic file; Repowise sells answers and judgments from one local index, the call graph the agent queries also scoring file health and finding dead code; rtk sells cheaper command output; Semble sells instant query-time snippets with no standing service; Serena sells the IDE’s own symbol tools to whatever agent you already run; Sourcegraph sells retrieval to whatever agent you already run; TOON sells the same data for fewer tokens at the prompt boundary; Vanna sold RAG over your schema, documentation, and past question-SQL pairs from a repository now archived; WrenAI sells the business meaning behind a warehouse (approved metrics, joins, worked examples as versioned YAML) to whatever agent asks, and the two data columns are the archive’s ancestor and the maintained successor. The review service that used to sit in this table, Greptile, moved to the Code review category, because what it sells is judgment on the PR stream, not retrieval. The Writes code row makes the split visible: Augment ships authoring agents, Sourcegraph’s Agentic Batch Changes stays in the migration lane, Serena edits at the symbol level when the task asks, CodeAlive’s review agent only comments on PRs, code-review-graph applies renames only after a preview, Vanna generates SQL and chart code but not application code, and the remaining 2026 columns refuse the code-writing job entirely.

I read the delivery row as the lock-in axis the marketing never names. Sourcegraph speaks MCP (plus API and CLI surfaces) to any agent; Repomix hands a plain file to anything that reads; Semble installs itself into whatever agents it finds, MCP, AGENTS.md instructions, or a sub-agent; code-review-graph’s installer is the widest surface here, one command writing MCP entries, hooks, skills, and rules text into up to sixteen detected platforms, with an uninstall documented to remove exactly what it wrote; Graft goes furthest in commitment, hooks, a statusline, and MCP config travelling inside the repo; Augment’s Context Engine only drives Augment’s own surfaces, so its documented token savings are purchasable only inside its own harness; Vanna stays on that pole too, its context reaching end users through the <vanna-chat> component and FastAPI routes you embed, with no MCP surface. Context7 and Headroom sit at the opposite pole: both are outside services (hosted or local) that any agent can consume, Context7 through one MCP registration or skill and Headroom through one wrap command across fifteen agents, which makes them the cheapest columns to try and the easiest to drop. Entroly lands on that same pole one receipt deeper: one pip install and entroly go starts a proxy, an MCP server, and reversible host hooks, and entroly activation status reports whether the hook actually ran, though the savings exist only when requests take the Entroly route, as its own docs concede. LLMLingua goes further out still, a library with no service at all, so the integration work and the deletion risk both land on the caller.

The scale row is where the budget decision lives, and the only published threshold belongs to Sourcegraph. Its own CodeScaleBench reports a +0.259 reward delta with agents 30% cheaper and 38% faster in the 400K-2M LOC range, and a slightly negative -0.080 below 400K LOC. Repomix inverts that curve: it pays off under a few hundred thousand tokens, then whole-window packing degrades linearly. code-review-graph publishes the row’s most self-critical guidance, under a few hundred files marginal by its own FAQ, though its reduction figures sit on a whole-corpus baseline its own README disclaims. Augment, Graft, and Vanna claim their ends of the curve but publish no size threshold.

Freshness splits real-time from snapshot, and it bites exactly when an agent is mid-edit. Augment indexes in real time; Repomix is a snapshot invalidated by every edit; Sourcegraph depends on index lag it inherits from its architecture; Serena sidesteps the axis entirely by parsing the working tree live with no index at all, and Jevgrep dodges it the same way, judging the tree live on every query. code-review-graph holds the event-driven middle, hooks and a daemon re-parsing only hash-changed files within seconds of an edit, a stored graph without snapshot staleness. Context7 moves freshness off your repo and onto the world’s documentation, refreshed by the service; Headroom, LLMLingua, and TOON have no index to go stale, one compressing each message as it passes, one pruning each prompt before it is sent, and one encoding each document deterministically, and Entroly joins the index-free set from the request boundary, selecting per call and receipting what it sets aside. Vanna’s Tool Memory only grew with each successful interaction, and the repository behind it has been frozen since 2026-03-29.

Every efficiency number in this matrix is vendor-run, and the pricing floors span free to $150K. Augment’s 33% token savings, Sourcegraph’s cost deltas, Semble’s 99%-fewer-tokens benchmark, Graft’s 42% token savings and 54%-to-66% SWE-bench jump, Jevgrep’s roughly 29% task-cost cut, and Headroom’s 57%-on-a-seeded-incident-dump table all come from the vendors themselves; Augment, Semble, Graft, Jevgrep, and Headroom at least publish methodology alongside the numbers, which is the category’s best practice even if no third party has replicated any of it, and Semble’s founders explicitly decline to claim end-to-end agent improvements. Entroly’s table is the newest and smallest entry in that set, 20 to 50 samples per row on gpt-4o-mini, but it is the only one that prints its own regression row in bold (SQuAD 2.0 falling from 80 to 72 percent) and ships offline commands that verify the installed path without an API key. code-review-graph’s roughly 63x median reduction is vendor-run too, but its methodology section is the row’s most self-critical, labelling its own recall metric circular and its whole-corpus baseline one no agent pays, and a third-party write-up still quotes older figures the current README no longer claims. LLMLingua’s 20x and RAG-gain numbers are the only ones here that went through peer review, and the April 2026 independent re-test still found code and few-shot inputs do not survive its pruning, with LLMLingua-1 missing requested compression rates badly enough to make bills unpredictable; Vanna’s 2023 accuracy study was the vendor’s own, and nothing independent has tested the frozen code since.

Choosing from the matrix

#

• Multi-repo organization past 400K LOC with agents thrashing on local search and an enterprise budget: Sourcegraph.
• Token-heavy team on one large private repo wanting a single vendor for authoring and review: Augment, after re-running its benchmark on your own repo first.
• Metered hosted indexing for any MCP agent on a small-team budget: CodeAlive, starting from the free tier and believing none of its numbers until replicated on your repos.
• Review-heavy teams on multi-thousand-file repos wanting the agent to read only the blast radius: code-review-graph, reading its own limitations first, since small repos and single-file diffs can cost more than they save.
• AI review of pull requests rather than retrieval: the Code review category, compared in its own feature matrix.
• Agents re-discovering how one large codebase connects, with structure and citations preferred: Graphify, after verifying its self-published benchmarks on your repo.
• Agents starting every session blind on a large repo, and a team that wants the map committed as wiring and regenerated per machine: Graft, keeping the free structural layer and re-running its vendor benchmarks on your repo first.
• An agent starting cold in a repository nobody indexed, paying per question instead of maintaining an index: Jevgrep, after measuring a week of queries against your provider bill.
• Very long natural-language prompts (RAG chunks, transcripts, few-shot demonstrations) and a preference for peer-reviewed compression: LLMLingua, measuring downstream quality at your target ratio and knowing code and few-shot inputs are where it fails.
• Local search over personal docs, notes, and knowledge bases for humans and agents: qmd, it is free and local.
• Small or mid repo, one-shot whole-repo questions, onboarding packs, or a CI guard on context budget: Repomix, it is free.
• One local index serving agent answers and code-health analytics together, with benchmark methodology published down to the losing rows: Repowise, re-running its comparisons on your repo before believing the deltas, and accepting the AGPL or the proposal-priced licence.
• Repo too big to pack, agents burning tokens on grep-and-read, no appetite for a standing service: Semble, measuring with semble savings before believing the benchmark.
• IDE-grade navigation, reference hunts, and symbol edits on a large polyglot repo, free and local: Serena, keeping grep for the vague concept queries symbol tools cannot answer.
• Metered-API sessions dominated by noisy test, git, and search output: rtk, measuring with rtk gain before believing the savings.
• Agents hallucinating APIs from fast-moving libraries: Context7, starting on the free tier and checking injected docs against the versions you pin.
• A token bill dominated by tool output, logs, or RAG noise across many agents: Headroom, starting with the proxy on one workflow and auditing what survives compression.
• Compression with a proof obligation, every dropped token recoverable and auditable: Entroly, running entroly simulate on your repo first and knowing the evidence base is one author’s small-n runs.
• Large uniform tables or record lists embedded in prompts: TOON, comparing tokens and accuracy against JSON on your own model before committing.
• Inheriting a Vanna deployment or wanting self-serve analytics chat over a warehouse: the frozen MIT core still runs self-hosted, but new builds should compare WrenAI first.
• Analytics agents writing plausible but semantically wrong SQL over a governed warehouse: WrenAI, keeping the MDL definitions in your own repo and treating the accuracy claims as unverified marketing until measured on your schemas.
• Code must stay on-device: Graphify, Repomix, code-review-graph, and Graft’s structural layer locally, qmd and rtk entirely, Headroom’s and Entroly’s compression entirely, or Sourcegraph self-hosted; Augment’s engine and Context7’s platform stay in their clouds.

Changes

#

• 2026-08-24 - Created with four columns as one of the remaining categories’ companion matrices.
• 2026-08-30 - Graphify, qmd, and rtk columns added, matrix at seven columns, kind-row prose and choosing list extended.
• 2026-08-30 - Extended to eight columns with Semble inserted alphabetically, with reading, choosing, and references sections extended.
• 2026-08-30 - Greptile column removed, back to seven columns, when the note moved to the Code review category.
• 2026-09-16 - Re-dated the re-verification and updated the Graphify pricing cell for the new monthly billing options and the early-access Enterprise tier.
• 2026-09-20 - Repointed the Graft references to the canonical trailhq/Graft repository after the GitHub org rename; no cells moved.
• 2026-09-24 - Renamed the Sourcegraph column to its listing title, Sourcegraph code context platform; no cells moved.
• 2026-09-24 - Removed the verification preamble line on owner request.
• 2026-09-25 - Updated the Graphify delivery cell to the vendor’s documented 17-assistant installer surface.
• 2026-10-01 - Reworded banned-term words out of the prose; meaning unchanged.
• 2026-10-04 - Extended from eight to nine columns with Serena (the LSP-backed MCP semantic-code toolkit), inserted in sorted position between Semble and Sourcegraph and traced to the new note; the intro, reading, and choosing sections updated for the ninth job and the live-parse freshness column.
• 2026-10-05 - Extended from nine to ten columns with CodeAlive (the hosted agent-agnostic context-engine API), inserted in sorted position after Augment Code and traced to the new note; the intro, reading, and choosing sections updated for the tenth job.
• 2026-10-06 - Moved the CodeAlive deployment and enterprise-orientation cells to record the demo-gated self-hosted deployment (Docker Compose or Kubernetes/Helm, BYO-LLM) with no SOC 2 badge yet; no membership change.
• 2026-10-07 - Extended from ten to eleven columns with Jevgrep (the per-query LLM-judged code-search CLI), inserted in sorted position between Graphify and qmd and traced to the new note; the intro, reading, freshness, efficiency, and choosing sections updated for the eleventh job.
• 2026-10-07 - Extended from eleven to fourteen columns with Context7 (the hosted docs-injection service), Headroom (the local compression layer), and TOON (the serialization convention), inserted in sorted position and traced to the new notes; the intro, delivery, freshness, efficiency, and choosing sections updated for the three new jobs, and the TOON note placed in this category over protocols because it optimizes what enters the window rather than interoperating surfaces.
• 2026-10-10 - Extended from fourteen to fifteen columns with LLMLingua (the peer-reviewed prompt-compression toolkit), inserted in sorted position between Jevgrep and qmd and traced to the new note; the intro, reading, delivery, freshness, efficiency, and choosing sections updated for the fifteenth job, with the April 2026 independent evaluation grounding the scale cell.
• 2026-10-10 - Extended from fifteen to sixteen columns with WrenAI (the governed semantic-layer context engine over data, the first column whose object is business semantics rather than code), appended in sorted position after TOON and traced to the new note; the intro, reading, and choosing sections updated for the sixteenth job.
• 2026-10-11 - Extended from sixteen to eighteen columns with code-review-graph (the Tree-sitter context graph with the review-first framing and the category’s most self-critical benchmarks) and Vanna (the archived MIT text-to-SQL RAG framework, the ancestor of the data-semantics column), inserted in sorted position and traced to the new notes; the intro, reading, delivery, scale, freshness, efficiency, and choosing sections updated for the two new jobs.
• 2026-10-12 - Extended from eighteen to nineteen columns with Entroly (the receipt-backed compression layer), inserted in sorted position between Context7 and Graft and traced to the new note; the intro, reading, delivery, freshness, efficiency, and choosing sections updated for the nineteenth job.
• 2026-10-13 - Extended from nineteen to twenty columns with SoL-Pi (the NV Labs Pi-harness efficiency extension), inserted in sorted position after Serena, all eleven cells traced to the new note, intro count bumped.
• 2026-10-13 - Extended from twenty to twenty-one columns with Repowise (the AGPL-3.0 local code-intelligence index with a code-health analytics suite), inserted in sorted position between Repomix and rtk and traced to the new note; the intro, reading, and choosing sections updated for the twenty-first job.
• 2026-10-16 - Moved the Graft column’s Kind cell to record the Trail-code rename and the self-learning repositioning (code map plus shared team learnings), updated the Serena delivery cell for the v2.0.0 REPL interface, and repointed the Graft reference links to trailhq/Trail-Code; no membership change.
• 2026-10-18 - Corrected the Headroom wrap count from fourteen to fifteen agents per the README and added its native Antigravity IDE integration to the delivery cell; no membership change.
• 2026-10-24 - Updated the Context7 delivery cell for the new Admin MCP account-management endpoint and the Repowise index-model cell for the README’s 28-language AST count (was 26); no membership change.

See also

#

• Context Management Patterns - the manual practices this category productizes
• Code Review Feature Matrix - the category Greptile moved to, judgment on the PR stream
• Harness Feature Matrix - the agents that consume what these engines deliver
• MCP - the protocol behind the delivery row
• Semantic code search in coding tools - whether indexed retrieval survives inside editors at all

References

#

• https://www.augmentcode.com/context-engine - Context Engine mechanics and efficiency claims for the Augment column
• https://www.augmentcode.com/pricing - flat Business plan and the 40% service fee for the Augment column
• https://codealive.ai/en - the tier table, per-action rates, and MCP delivery surfaces for the CodeAlive column
• https://docs.codealive.ai/integrations/mcp - the MCP v3 tools and hosted-endpoint deployment behind the CodeAlive column’s delivery cell
• https://github.com/yamadashy/repomix - CLI surface, output formats, token budgets, and MCP mode for the Repomix column
• https://sourcegraph.com/pricing - enterprise entry price and credits model for the Sourcegraph code context platform column
• https://sourcegraph.com/blog/why-coding-agents-fail-large-codebases - the 400K LOC threshold and the cost/speed deltas
• https://github.com/Graphify-Labs/graphify - the AST knowledge-graph architecture and license for the Graphify column
• https://github.com/tobi/qmd - the hybrid local search stack for the qmd column
• https://github.com/rtk-ai/rtk - the output-filtering strategies and agent integrations for the rtk column
• https://github.com/MinishLab/semble - the hybrid static-embedding stack and installer surfaces for the Semble column
• https://news.ycombinator.com/item?id=48169874 - the launch thread grounding the Semble column’s self-published-benchmark caveat
• https://github.com/trailhq/Trail-Code - canonical repository (trailhq/Graft and NanoNets/Graft redirect here), README architecture and claims, license, and adoption stats for the Graft column
• https://graft.nanonets.ai - the product site and Trail attribution for the Graft column
• https://raw.githubusercontent.com/trailhq/Trail-Code/main/TELEMETRY.md - the telemetry policy for the Graft column
• https://trailhq.com/pricing - Trail Brain plan pricing for the Graft column’s pricing cell
• https://hn.algolia.com/api/v1/items/49299985 - the launch thread grounding the Graft column’s vendor-run-benchmark caveat
• https://github.com/oraios/serena - the Serena column: tool surface, backends, licensing, adoption (as of 2026-10-04)
• https://raw.githubusercontent.com/oraios/serena/main/LICENSE - the per-component license behind the Serena column’s open-source cell
• https://api.github.com/repos/dzhng/jevgrep - the Jevgrep column: repository stats and activity (as of 2026-10-07)
• https://raw.githubusercontent.com/dzhng/jevgrep/main/README.md - the Jevgrep column: architecture, benchmark claims, and provider dependency
• https://github.com/upstash/context7 - the Context7 column: repository, install modes, and delivery surfaces (as of 2026-10-07)
• https://context7.com/plans - the Context7 column: tier table, call quotas, and overage rates
• https://github.com/headroomlabs-ai/headroom - the Headroom column: repository, deployment surfaces, and license (as of 2026-10-07)
• https://docs.headroomlabs.ai/docs - the Headroom column: compression table and seeded benchmark table
• https://github.com/toon-format/toon - the TOON column: repository and design rationale (as of 2026-10-07)
• https://raw.githubusercontent.com/toon-format/spec/HEAD/SPEC.md - the TOON column: spec version 4.3 and conformance requirements
• https://api.github.com/repos/microsoft/LLMLingua - the LLMLingua column: repository stats, license, and activity (as of 2026-10-10)
• https://raw.githubusercontent.com/microsoft/LLMLingua/main/README.md - the LLMLingua column: method family, integrations, and claims
• https://arxiv.org/abs/2604.02985 - the LLMLingua column: the April 2026 independent evaluation behind the scale cell’s code caveat
• https://github.com/Canner/WrenAI - the WrenAI column: repository, MDL mechanism, agent delivery surfaces, and open-core split (as of 2026-10-10)
• https://www.getwren.ai/pricing - the WrenAI column: credit tiers and Enterprise feature gates
• https://github.com/vanna-ai/vanna - the Vanna column: the 2026-03-29 archive banner on the repository page
• https://api.github.com/repos/vanna-ai/vanna - the Vanna column: stars, archived flag, and last push as of 2026-10-11
• https://raw.githubusercontent.com/vanna-ai/vanna/main/README.md - the Vanna column: the 2.0 agent architecture, Tool Memory, and MIT license
• https://vanna.ai/pricing - the Vanna column: Explorer, Team, and Enterprise tiers as of 2026-10-11
• https://raw.githubusercontent.com/tirth8205/code-review-graph/main/README.md - the code-review-graph column: mechanism, benchmark tables and their own disclaimers, installer surfaces, limitations
• https://raw.githubusercontent.com/tirth8205/code-review-graph/main/docs/FAQ.md - the code-review-graph column: size thresholds and the no-telemetry statement
• https://api.github.com/repos/tirth8205/code-review-graph - the code-review-graph column: stars, activity, and license as of 2026-10-11
• https://api.github.com/repos/juyterman1000/entroly - the Entroly column: repository stats, license, and activity as of 2026-10-12
• https://raw.githubusercontent.com/juyterman1000/entroly/main/README.md - the Entroly column: receipt and recovery mechanism, delivery surfaces, and the README benchmark table