Ctx
Ctx is a local, open-source CLI to search your coding-agent history, blame code lines to the agent session that wrote them, and graph your
Install the free CLI before you pay for anything: search, graph and blame over local history cost a curl, and `ctx blame` answering "which agent session wrote this line, and what did it actually say?" is something git blame and codebase graphs genuinely cannot do. The 2.2.x line is the one to be on — 2.2.8 fixed the incremental-import and stale-attribution bugs that made earlier versions annoying. The $20/mo ctx pro pencils out only if you regularly investigate old code or share selected
Verified 3d ago · liveness 80/100 · cite: rightaichoice.com/tools/ctx
- Developers running two or more coding agents who lose decisions between sessions
- Engineers debugging why a line of code looks the way it does, weeks after the fact
- Privacy-conscious teams that need agent history to stay on-device with no API keys
- Anyone cutting token spend by giving agents ranked history instead of raw transcripts
- Developers running a single agent who never revisit old sessions
- Users who want a GUI rather than a command-line workflow
- Anyone who needs guaranteed blame attribution when the producing session lives on a teammate's laptop
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Ctx if you run a single coding agent and never revisit old sessions, or if you need a GUI instead of a CLI.
Line-range and PR attribution through `ctx blame` sits behind the $20/mo ctx pro tier, so the free CLI covers search and graph but not blaming a commit back to a session.
The free open-source tier already covers indexed search, `ctx graph` and `ctx sift` across 32+ providers, which makes it cheaper than any hosted agent-memory product you would otherwise pay for. The $20/mo ctx pro tier adds only `ctx blame` — file, line-range, commit and PR attribution with transcript citations. For a solo developer who investigates old code weekly, that is the whole bill; teams that need shared history should treat the 2.2.0 beta ctx server as a separate evaluation entirely.
In short
Ctx — Ctx is a local, open-source CLI to search your coding-agent history, blame code lines to the agent session that wrote them, and graph your. Best for Developers running two or more coding agents who lose decisions between sessions, Engineers debugging why a line of code looks the way it does, weeks after the fact, Privacy-conscious teams that need agent history to stay on-device with no API keys. Free to start; paid plans from $20/mo.
What's new in Ctx
Checked yesterdayAcross the latest 5 updates: 1 launch and 4 changelog entries.
ctx 2.2.8: faster incremental imports, safer blame attribution
Incremental imports skip rereading unchanged Codex prefixes and use executable file metadata for worker compatibility checks. Background blame now selects history after the writer lock, so a queued worker cannot publish stale attribution.
ctx 2.2.7: validated ownership reuse and Sift telemetry hooks
Incremental imports reuse validated ownership for unchanged Codex rollouts instead of rereading large metadata prefixes, and telemetry now accepts Sift output-hook integration events.
ctx 2.2.6: import --all --incremental and import recovery
New `ctx import --all --incremental` runs one catch-up using existing checkpoints without enabling automatic indexing, and foreground imports recover the original request after lost acknowledgements while their worker is alive.
ctx 2.2.5: skill guidance restored, OpenCode import fix
The ctx skill again advises searching prior agent work before unfamiliar work and explains when to query an indexed code graph. Imports work after OpenCode's SQLite migration, and failed imports return a failing exit status.
ctx 2.2.0: portable history archives and opt-in team server
Adds export and restore of portable history archives for use with tools like restic, plus an opt-in beta ctx server for sharing selected sessions with a team. Ordinary local search and indexing keep working as before.
What people actually say about Ctx — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
86 mentions across 6 sources (Hacker News, Product Hunt, Bluesky, Stack Overflow, GitHub, Lemmy) · researched Jul 6, 2026.
Average across the 6 sources that answered — each source counts once, not each post.
- +Fully local — no cloud, no API key, no background service.
- +Written in Rust — fast indexing and sub-second search.
- +Claims 50× token efficiency versus raw transcript search.
- +Supports multiple major agent harnesses out of the box.
- +Natural language search across past sessions is genuinely useful.
- −No GUI — CLI-only may intimidate some users.
- −macOS install broken due to TLS redirect issue.
- −No freshness/decay metadata — stale results can mislead.
- −Some agent formats lack support (e.g., Pi, Shelley) — check your stack.
- −SQLite storage is simple but limits advanced querying.
- • No hidden costs — fully free and self-hosted.
Viability Score
How well maintained and how widely used is Ctx? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Local search across 32+ coding agent providers
- Natural-language search, e.g. ctx search "failed migration"
- BM25 lexical ranking with ranked, cited results by default
- Search sessions and events that touched a file with --file
- Multi-term search using repeated --term flags
- ctx show event <id> --window 3 for context around a match
- ctx show session <id> for a compact full transcript
- Optional local semantic search with an on-device model, no API key
- ctx blame by file, line range, commit or PR with evidence citations
- ctx graph: codebase graph indexed in SQLite for symbol, dependency and impact questions
- ctx sift: local compaction of noisy tool output before the agent reads it
- Single executable shipping graph, search, blame and sift as of ctx 2.0
- Automatic indexing on by default, completed before updates become visible
- Runs entirely offline with no API keys
- Export and restore portable history archives (ctx 2.2.0)
About Ctx
Ctx is an open-source CLI toolchain for context engineering: search, blame, graph and sift across coding-agent history that is already sitting on your machine. If you run Claude Code, Codex, Cursor, Copilot CLI, Gemini CLI, Goose, Factory Droid, Pi, OpenCode or Antigravity, their transcripts and tool-call records are already on disk, usually as JSONL files or SQLite databases under paths such as ~/.claude and ~/.codex. Running `ctx setup` discovers those sources, reads them without modifying them, and normalizes every provider's format into consistent local records for sessions, messages, tool calls, relationships and repository activity. No hooks, nothing runs inside the agent process, and automatic indexing keeps the index current with each update completing before it becomes visible. Search is the entry point. `ctx search "failed migration"` runs BM25 lexical matching by default, `--file crates/foo/src/lib.rs` narrows to sessions that touched a file, and repeated `--term` flags handle multi-term queries. Every result is ranked and carries a stable ctx ID, so `ctx show event <id> --window 3` prints the matching part of an old transcript and `ctx show session <id>` prints the compact whole. Optional local semantic search covers the case where the idea is the same but the wording differs, computing embeddings on-device with no API key. The headline capability is `ctx blame`. Start from a file, line range, commit or PR and it returns the session that produced those lines with citations back to the original transcript and recorded tool calls. When the producing session is not on your machine, it says plainly that it cannot prove the attribution. `ctx graph` rewrites the codebase-graph idea in Rust with the graph indexed in SQLite so queries hit the database directly and updates only touch changed files, and `ctx sift` compacts noisy tool output locally before your agent ever reads it. Version 2.0 folded graph, search, blame and sift into a single executable; the
Behind the Verdict
Where this pays off is the second week. You inherit a checkout file that behaves oddly, git blame points at a commit from a contractor's agent, and `ctx blame file src/checkout.ts --lines 118:146` hands you the session ID, the commit, and the transcript excerpt where the previous agent explained — wrongly — that duplicate product_ids were safe to merge. That is a different class of answer than a diff. Pick Ctx if you run two or more coding agents, or one agent across many threads, and you have felt decisions evaporate between sessions. The search side earns its keep too: `ctx search --file` plus `ctx show event` beats grepping JSONL by hand, and the structured, cited results are the reason the pitch about token efficiency holds up — you feed an agent ranked matches instead of a raw transcript dump. Pass if you run a single agent, never revisit old sessions, and want a GUI. Everything here is a CLI. It is also not a redaction layer: transcript text is preserved rather than automatically scrubbed, so review anything you copy off the machine. And if your team's agents run on other people's laptops, blame will honestly tell you it cannot prove attribution — useful, but not the answer you wanted. The closest comparison is the agent-memory category, which compacts past work into summaries that go stale. Ctx's bet is the opposite: keep the real record and make it queryable, including how parent sessions, subagents and forks relate. If you orchestrate aggressively, that lineage is the part that keeps a long chain of work recoverable. For codebase questions, ctx graph is positioned directly at Graphify, which reloads its whole Python/NetworkX graph per query; the Rust rewrite keeps it in SQLite and only touches changed files, which matters once a repo gets large. Two
Researching Ctx? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Ctx actually fits — and what changes day-one when you adopt it.
A migration test fails and you cannot remember whether you already tried the fix in a session three weeks ago. You run `curl -fsSL https://ctx.rs/install | sh`, then `ctx setup` to index the JSONL files under ~/.claude and ~/.codex, then `ctx search "failed migration"` and open the top hit with `ctx show session <id>`.
Outcome: You recover the earlier failed approach and its error output in minutes instead of re-running the same migration and burning tokens on a dead end.
A line in crates/foo/src/lib.rs looks strange and git blame only names a commit. You upgrade to ctx pro and run `ctx blame crates/foo/src/lib.rs` for the line range to pull the agent session that produced the commit, then read its reasoning via the cited transcript.
Outcome: You see the constraint the agent was working around, or get an explicit cannot-prove-attribution result — either way you are not guessing from the diff.
You want history to stay on-device with no API keys, so you run the free CLI with default BM25 search and leave the semantic executor unconfigured, letting each developer query their own local index through the MCP integration.
Outcome: Agent history never leaves the machine, and each developer gets ranked, cited recall of their own prior sessions without a cloud dependency.
Use Cases
- Search past sessions for a failed migration command so you do not retry the same approach
- Recover prior discussion context when starting a new session on the same codebase
- Pull a prior agent's full transcript to understand decisions made weeks ago
- Index all local agent logs for fast retrieval instead of browsing files by hand
- Let your current agent query history directly through the MCP integration
- Find the exact command that failed months ago to debug it now
- Preserve context when switching agents, e.g. from Cursor to Codex
- Blame a line, file or PR to the agent session that produced it and read its reasoning
Models Under the Hood
as of 2026-10-17
Limitations
- Ctx is a CLI with no graphical interface, so everything runs through commands and flags.
- The free tier is local-only: history is not shared across machines, and ctx blame explicitly reports that it cannot prove attribution when the originating session is not on your machine — for example when a teammate's agent produced the commit.
- The opt-in beta `ctx server` (added 2.2.0) is the only sharing path and requires an invitation or administrator-issued credential.
- The tool preserves transcript content rather than redacting it, so sensitive prompts and code stay in your local index as-is; an explicitly configured external semantic executor can send history and query text to its endpoint, so check retrieval backends before enabling it.
- The 1.x release line moved quickly, with interface migrations in 1.4.0 and a documented Windows 0.25.0 reinstall path; older managed installs must pass through the 1.3.2 compatibility bridge.
- Provider coverage keeps expanding and import fidelity for newer providers has needed several point fixes, including OpenCode's SQLite migration.
as of 2026-10-09
Verification history
We have re-verified Ctx 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Ctx tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Solo developers and small teams running one or more coding agents who only need local search, a local code graph and tool-output compaction.
What this tier adds
Starting tier at $0: indexes local sessions from 32+ providers, BM25 lexical search with --file and --term, optional local semantic search, ctx graph, ctx sift and MCP access.
ctx pro
$20/mo
Ideal for
Engineers who regularly trace why a line, commit or PR looks the way it does and need the producing agent session cited.
What this tier adds
Adds ctx blame by file, line range, commit or PR with citations back to the original transcript and recorded tool calls, plus an explicit cannot-prove-attribution result when the session is not on your machine.
Where the pricing makes sense
The company stage and team size where Ctx's pricing actually pencils out — and where peers do it cheaper.
The free open-source tier already covers indexed search, `ctx graph` and `ctx sift` across 32+ providers, which makes it cheaper than any hosted agent-memory product you would otherwise pay for. The $20/mo ctx pro tier adds only `ctx blame` — file, line-range, commit and PR attribution with transcript citations. For a solo developer who investigates old code weekly, that is the whole bill; teams that need shared history should treat the 2.2.0 beta ctx server as a separate evaluation entirely.
Setup time & first value
How long it actually takes to get something useful out of Ctx — broken out by persona, not the marketing-page minute.
Solo developer on macOS or Linux: one curl install line plus `ctx setup` to discover and index existing ~/.claude and ~/.codex directories — normally under ten minutes before `ctx search` returns results. Windows users: the PowerShell installer takes the same few minutes, though managed installs coming from the 1.x line must pass through the 1.3.2 compatibility bridge first. Team sharing is a
Switching to or from Ctx
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From grep and manual JSONL browsing: run `ctx setup` to index existing sessions, then replace ad-hoc file greps with `ctx search` and `--file` scoping.
- →From agent memory or compaction features: keep the agent's summaries but query the full transcript with `ctx show session <id>` when a summary has gone stale.
- →From 1.x managed installs: older installs must pass through the 1.3.2 compatibility bridge before joining the current stable channel.
- ↗To grep and manual log search: export portable history archives (2.2.0) and keep the raw JSONL/SQLite sources, which ctx never modified in the first place.
- ↗To restic or similar backup tooling: use ctx 2.2.0's export/restore for portable history archives backed by encrypted filesystem or object storage.
- ↗To a cloud-hosted team history: evaluate the opt-in beta ctx server, which shares selected sessions and lets admins control collection permissions and revoke access.
Integrations
Resources & Guides
- Resourcectx.rs
Home · Ctx
Helpful link from ctx.rs
- Resourcectx.rs
Graph · Ctx
Helpful link from ctx.rs
- Resourcectx.rs
Sift · Ctx
Helpful link from ctx.rs
- Conceptsctx.rs
How It Works · Ctx
Core ideas explained from ctx.rs
- API Referencectx.rs
Cli · Ctx
Methods, params, types from ctx.rs
- Resourcectx.rs
Troubleshooting · Ctx
Helpful link from ctx.rs
Tutorials & Learning
YouTube returned 6 videos for “Ctx”, and we withheld 6: 6 could not be judged, because “Ctx” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Ctx.
Official links
Tools that pair well with Ctx
Common stack mates teams adopt alongside Ctx, with the specific reason each pairing earns its keep.
Continue
Open-source AI coding agent for VS Code and JetBrains — free to fork since Cursor acquired Continue in January 2026.
Sourcegraph Cody
Sourcegraph Cody: an AI coding assistant that grounds chat, completions, and agent workflows in your entire multi-repo codebase.
Refact.ai
Open-source autonomous AI coding agent that plans, executes, and deploys tasks inside VS Code and JetBrains IDEs.
Featured Head-to-Head Comparisons
Ctx vs Spider Cloud
If you need to feed fresh web data into AI agents or RAG pipelines, Spider Cloud's pay-as-you-go API with Rust engine and Browser AI commands is a strong, cost-effective choice. For developers juggling multiple coding agents and tired of losing context, Ctx's free, local, open-source CLI indexes your session history for instant recall. They solve completely different problems—pick the one that matches your bottleneck.
Ctx vs Temporal Ai
Temporal is the heavy lifter for teams that need their AI agents and workflows to survive crashes, support human-in-the-loop, and scale with automatic retries. Ctx solves a different, focused problem: it indexes and searches your local coding agent history so you never lose context. If you build production-grade agentic systems, choose Temporal. If you just want to recover past agent sessions quickly, use Ctx. They don't compete—they complement.
Ctx vs Voyage Ai
Voyage AI and Ctx serve entirely different needs. Voyage AI is an enterprise-grade embedding API for RAG pipelines, ideal for finance/legal teams needing long-context, low-dimensional vectors with compliance. Ctx is a free, open-source CLI tool for searching coding agent history locally—perfect for developers who want to retain context across sessions without cloud dependency. Choose Voyage for production RAG accuracy; choose Ctx for agent workflow memory.
Alternatives to Ctx
View allContinue
Open-source AI coding agent for VS Code and JetBrains — free to fork since Cursor acquired Continue in January 2026.
Sourcegraph Cody
Sourcegraph Cody: an AI coding assistant that grounds chat, completions, and agent workflows in your entire multi-repo codebase.
Frequently Asked Questions
Best-of guides
Topics
Used Ctx? Help shape our editorial sentiment research.