Ctx
Instant recall for coding agents: search local agent history across 32+ providers
If you live in coding agents and lose context between sessions, install this. The 1.0.0 release—with lineage tracking and structured output—makes it the sharpest tool we've seen for turning local logs into actionable history. The free tier covers local search; pro's blame feature is $20/mo and worth trialing if you ever wonder 'why was this code written this way?'.
Verified 5d ago · liveness 80/100 · cite: rightaichoice.com/tools/ctx
- Developers who use multiple coding agents and lose context between sessions
- Engineers debugging failed attempts in long-running projects
- Power users who want token-efficient history retrieval
- Teams that want to attribute code changes to specific agent sessions
- Users who only run one agent session and never revisit history
- Developers needing cloud-hosted search without local setup
- Teams requiring collaborative history without a shared server (free tier is local-only)
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 only use one coding agent and never need to revisit past sessions, or if you require cloud-hosted, team-shared history without local setup.
ctx pro is $20/mo after a two-week free trial; you'll need to subscribe to use the blame feature.
Ctx's free tier covers local search across 32+ providers, making it a no-cost addition to any developer's toolkit. The pro tier at $20/mo is priced for individual developers; teams may find it cheaper than alternatives like Sourcegraph's enterprise plans, but if you need cloud collaboration, you'll pay extra for the upcoming cloud service.
In short
Ctx — Instant recall for coding agents: search local agent history across 32+ providers. Best for Developers who use multiple coding agents and lose context between sessions, Engineers debugging failed attempts in long-running projects, Power users who want token-efficient history retrieval. Free to start; paid plans from $20/mo.
What's new in Ctx
Checked 3 days agoAcross the latest 3 updates: 3 changelog entries.
ctx 1.2.3: Fixes OpenCode imports and managed upgrade signing
OpenCode imports skip non-indexable parts; malformed SQLite rows produce bounded diagnostics; managed upgrades to signed Core-only releases.
ctx 1.2.4: Search waits for semantic indexing; telemetry and retry fixes
Search now waits for semantic indexing catch-up; background telemetry drain expanded; failed sources pause after one retry.
ctx 1.2.2: Safer background indexing recovery and improved diagnostics
Setup reports indexing progress; import summaries show net changes; watcher recovery avoids repeated full audits; faulty sources pause individually.
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.
- +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: September 2026
How we score →Key Features
- Local search across 32+ coding agent providers
- Natural language search (e.g., 'failed migration')
- Search by file: --file crates/foo/src/lib.rs
- Multi-term search with --term flag
- Ranked, cited results with ctx IDs
- Show event snippets with --window context
- Print full session transcripts
- Lineage tracking for parent sessions, subagents, forks (1.0.0)
- Structured JSON/JSONL output (1.0.0)
- Self-contained Core index (1.0.0)
- Semantic search with multilingual model
- Scriptgram search for CJK and Indic scripts
- ctx pro: blame by file, line, commit, or PR
- MCP integration for agent querying
- Runs entirely offline, no API keys
About Ctx
Ctx is an open-source CLI for developers who want instant recall of their coding agent history. It indexes sessions from Claude Code, Codex, Cursor, Copilot CLI, and many other agents into a fast local searchable index stored in Tantivy. You can search in plain language or by file, and get ranked, cited matches that link directly to the original transcript event or full session. Built in Rust, it runs entirely offline—no cloud, no API keys, no background service implied, though a local daemon can watch history sources. The recent 1.0.0 release adds a self-contained Core index, lineage tracking, and structured JSON/JSONL output, making it a reliable tool for scripting and agent workflows. Additionally, 1.0.2 improves setup progress counters for large Codex scans and fixes error handling for quarantined rollouts. The free version gives you local search across your agent sessions. You can search by file using --file, or use --term for multi-term queries. Results show matching sessions, snippets, and ctx IDs. You can print the matching part of a transcript with ctx show event --window, or a compact transcript with ctx show session. Scheduling is not required; the CLI is designed for fast retrieval. ctx pro, a paid add-on at $20/month, acts like 'git blame, but for agent sessions'. From a line, file, commit, or PR, it surfaces the agent session that produced that code, with citations to the original transcript and recorded tool calls. That lets your current agent recover decisions, assumptions, and failed approaches, reducing repeated work and token spend—raw search can be 50x more token-heavy per query. The tool supports semantic search with a multilingual model, scriptgram search for CJK and Indic scripts, and an MCP integration so compatible agents can query history directly. Unlike agent memory tools that summarize (and can go stale) or codebase graphs that map structure, Ctx keeps retrieval tied to raw sessions, so agents inspect the original evidence. It's
Behind the Verdict
We've tested enough agent memory tools to know that summarizing history into facts usually ends up stale and useless. Ctx takes the opposite approach: it keeps the raw transcripts, indexes them locally, and gives you ranked, cited retrieval. That matters because agents need evidence, not summaries. When a new session can read exactly what the old session did, including tool calls and failed attempts, it avoids repeating mistakes and burns fewer tokens. The 50x token-efficiency claim is bold, but even if it's half that in practice, it's still a massive win. Where does Ctx fit versus alternatives? Agent memory tools like Mem0 or MemGPT compile histories into compact facts, which can lose nuance. Codebase graphs like Sourcegraph or CodeQL map code structure, but they don't capture the agent's reasoning. Ctx is different: it's a search engine over your agent logs. That's a niche, but if you're a heavy multi-agent user, it's the difference between 'what did I do?' and 'why did I do it that way?'. When should you pick Ctx? If you use multiple coding agents—Claude Code, Codex, Cursor, Copilot CLI—and switch between them, Ctx unifies that history. It's also great for long-running projects where you need to revisit investigations from months ago. If you're a solo dev on a small codebase with one agent, you might not need it. The free tier is local-only, so there's no team collaboration without shared infrastructure. If you work in a team and need everyone to see attributions, you'll need to set up a shared server yourself. One caveat: transcripts are preserved, not redacted. If you copy output that contains sensitive info, it will include everything. The docs warn you to review before sharing. Also, the pro's blame feature only works for sessions on your machine; if a
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.
Working on a side project, you switch from Claude Code to Cursor and need to recall why you chose a certain architecture. You run ctx search 'why did we use postgres' to find the session.
Outcome: You retrieve the exact transcript, including tool calls, and see the reasoning without re-reading all logs.
A teammate's agent produced a buggy change. You run ctx blame file src/checkout.ts --lines 118:146 to find the session that made the change.
Outcome: You get the session ID and open the transcript, discovering the duplicate cart-line assumption that caused the bug, allowing a targeted fix.
Your current agent is about to repeat a failed approach from last week. You configure the MCP integration so the agent can query history directly.
Outcome: The agent searches past sessions, finds the failed attempt, and avoids it, saving tokens and time.
Use Cases
- Search past agent sessions for a failed migration command to avoid repeating mistakes
- Recover previous discussion context when starting a new coding session on the same codebase
- Show a prior agent's full transcript to understand decisions made weeks ago
- Index all local agent logs for faster retrieval without manual file browsing
- Use the MCP integration to let your current agent query history directly
- Debug by finding the exact command that failed months ago
- Preserve context across tool switches (e.g., from Cursor to Codex)
Models Under the Hood
as of 2026-09-01
Limitations
- ctx is an open-source CLI tool for local search across past coding agent sessions, supporting 32+ providers. ctx pro is a paid add-on for attributing code changes to agent sessions.
- The hosted installer is the recommended path for managed Core and Pro installation, while GitHub Release binaries provide ctx Core only.
- Setup is CLI-only with no GUI.
as of 2026-08-21
Verification history
We have re-verified Ctx 6 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
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/mo
Ideal for
Solo developers or small teams who want free local search across multiple coding agents, without needing attribution to code changes.
What this tier adds
Free entry point with all local search features, including plain-language and file-based search, and structured output, but without the blame feature.
ctx pro
$20/mo
Ideal for
Individual developers or teams who need to trace code changes back to the agent session that produced them, and want to recover decisions and failed approaches.
What this tier adds
Adds git-blame-for-sessions across file, line, commit, or PR, with citations to transcripts, plus a two-week free trial.
Where the pricing makes sense
The company stage and team size where Ctx's pricing actually pencils out — and where peers do it cheaper.
Ctx's free tier covers local search across 32+ providers, making it a no-cost addition to any developer's toolkit. The pro tier at $20/mo is priced for individual developers; teams may find it cheaper than alternatives like Sourcegraph's enterprise plans, but if you need cloud collaboration, you'll pay extra for the upcoming cloud service.
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.
For a solo developer: install via curl takes under a minute; first setup indexes your history in about 2 minutes for a 4 GB corpus. For a tech lead: add ctx to your team's onboarding, each developer installs and indexes locally, roughly 10 minutes per machine. For an AI agent: configure the MCP integration, which takes about 5 minutes.
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 log search: replace manual grepping of ~/.claude and ~/.codex with ctx's structured search, which returns ranked, cited matches.
- ↗To a cloud-based history tool: export your index or transcripts using ctx show session --out to move to a team-shared solution later.
Integrations
Resources & Guides
Tutorials & Learning
Official links
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.
Popular in Code & Development
Bito
AI model router and code context engine that cuts agent token spend by grounding requests in your codebase and routing to right-sized
Poolside AI
Open-weight agentic coding models for secure on-prem enterprise AI
Frequently Asked Questions
Best-of guides
Topics
Used Ctx? Help shape our editorial sentiment research.