╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ╚══════════════╝ ╚══════════╝ ╚══════════════╝ ╚══════════╝ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ file file file file read cache send tok tok tok tok tok tok file file file file read cache send tok tok tok tok tok tok ╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> ctx_read >>>>>>>>>>>> │ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ ┌─────────────┐ │ >>>>>>>>>>>>>>> compress >>>>>>>>>>>> │ ┌──────────┐ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ │ 100K tokens │ =========>│ >>> AST >>> cache >>> signal >>> │ =========> │ ~5K tok │ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ └─────────────┘ │ >>>>>>>>>>>>>>> filter >>>>>>>>>>>> │ └──────────┘ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ │ >>>>>>>>>>>>>>> dedupe >>>>>>>>>>>> │ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ╔══════════════╗ ╰──────────────────────────────────────────╯ ╔══════════╗ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ║ raw input ║ ─ ─ ─ ─ ─ ─ ─ ─ LeanCTX ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ║ output ║ ╚══════════════╝ ╚══════════╝ ╚══════════════╝ ╚══════════╝ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ ┌──┐ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │▓▓│ │▓▓│ │▓▓│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ ───> │▓▓│ │▓▓│ │▓▓│ ───> │░░│ │░░│ │░░│ │░░│ │░░│ │░░│ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ └──┘ file file file file read cache send tok tok tok tok tok tok file file file file read cache send tok tok tok tok tok tok

Honest Comparison

You already have tools.
Here's the difference.

A straightforward look at what LeanCTX does better, what it does the same, and when you don't need it at all.

Side by Side

Your agent, with and without.

The same agent, the same repo. The only variable is the layer between them.

Feature	No Tool	Manual Rules	LeanCTX
Token Savings	None	Low (static rules)	60–95% (cached: 99%)
Setup Effort	None	Manual per-project	One command
Agent Support	N/A	One agent only	29+ agents
Caching	None	None	Automatic + delta
Shell Compression	None	None	95+ patterns
Code Analysis	None	None	Tree-sitter AST
Maintenance	None	Manual updates	Automatic
Security & Governance	No enforcement	Basic file ACL	OWASP aligned, OS sandbox, capability ACL, signed bundles, audit trail

vs. Alternatives

How LeanCTX Compares to Other Tools

A feature-by-feature comparison with RTK, Context+, MemGPT/Letta and Headroom, the most commonly referenced alternatives. Fact-based, from their public documentation.

Feature	RTK	Context+	MemGPT / Letta	Headroom	lean-ctx
Read Modes	Single mode	Basic filtering	N/A (memory-focused)	Compresses after the read	10 modes (auto, map, signatures, diff, entropy...)
Shell Compression	No	No	No	No	95+ patterns, auto-detected
Session Memory	Basic state	Conversation history	Core feature (tiered memory)	Cross-agent store with dedup	Episodic + procedural + knowledge graph
Multi-Agent	No	No	Limited (single agent focus)	Shared store	Handoff, shared sessions, context bus
Code Graph / AST	Basic indexing	No	No	No	Tree-sitter AST, 18 languages, symbol resolution
Governance & Budgets	No	No	No	No	Role-based budgets, SLOs, audit trail
Local-First / Privacy	Cloud-dependent	Local	Server-based	Python package + proxy	100% local, zero telemetry
MCP Tools	Limited	No MCP	No MCP	Wraps external tools	76 granular MCP tools
Security Hardening	None	None	Basic auth	None	Sandboxing, signed bundles, audit reports

Based on publicly available documentation and source code as of June 2026. RTK (github.com/rtk-ai/rtk), Context+ (github.com/ForLoopCodes/contextplus), MemGPT/Letta (arxiv.org/abs/2310.08560), Headroom (github.com/chopratejas/headroom). All tools solve real problems. LeanCTX simply covers more layers of the context problem in one binary.

vs. compression layers

Compression shrinks what was read. Intelligence decides what gets read.

Tools like Headroom compress messages after your agent has already read everything. Useful, and compatible with LeanCTX. LeanCTX works one layer deeper, at the source. Here is the honest difference.

Dimension	Compression layer (e.g. Headroom)	LeanCTX
Where it sits	Message path: compresses what the agent already read	At the source: decides what and how to read (10 modes, intent routing, ~13-token cached re-reads)
Memory	Cross-agent store with dedup	Persistent knowledge: property graph, sessions, handoffs, evidence ledger
Governance	—	PathJail, shell allowlist, secret redaction, budgets, injection detection
Proof	Stats endpoint	Ed25519-signed, hash-chained ledger + reproducible benchmark
Reversibility	CCR (reversible compression)	Also reversible: every original stays one `ctx_retrieve` away
Form	Python package + proxy	One Rust binary, 30+ tools auto-detected, zero config

Note: some third-party comparison tables list lean-ctx as "Reversible: No"; that is incorrect. Every compressed read in LeanCTX is locally archived and retrievable via ctx_retrieve. Compression is one of five subsystems in LeanCTX. The two tools can even run together; Headroom lists lean-ctx as a compatible context tool.

Why not just…

Your stack already does some of this. Here's what it doesn't.

LeanCTX doesn't replace grep or your editor. It's the layer that decides what's worth your AI's attention.

Why not just grep?

grep finds text. LeanCTX finds the right symbols, ranks them by relevance, and returns budgeted, structural context instead of 500 raw matches you still have to read and filter.

Why not just read the files?

A raw read dumps 4,200 tokens when ~920 carry the signal. LeanCTX keeps the signal and drops the noise, and a cached re-read costs about 13 tokens instead of the whole file again.

Why not just compact more often?

Compaction throws away history you might still need. With LeanCTX there's never a dead end: every original is archived on disk and your agent retrieves it on demand. Nothing is silently lost.

Why not another MCP server?

Most MCP servers add tool-definition overhead and hand back raw output. LeanCTX is a full cognitive context layer: caching, persistent memory, shell hooks, and a governance layer, all in one local binary.

Best Fit

When lean-ctx Shines

LeanCTX delivers the most value in these scenarios.

Large Codebases

Projects with hundreds or thousands of files benefit most. The more context there is to manage, the bigger the savings.

Multi-Agent Workflows

When multiple AI agents work on the same project, LeanCTX gives them one shared brain: consistent, governed context for every agent.

Iterative Development

Long coding sessions with repeated file reads hit the cache - re-reads cost just ~13 tokens instead of thousands.

Transparency

When You Don't Need It

We believe in honest tooling. LeanCTX is designed for projects with substantial codebases - not everything.

Not Always Necessary

Single-file scripts or small utilities
Projects under 50 files
One-off prompts without file context

In these cases, the overhead of a context layer isn't justified. LeanCTX shines when your projects grow and context management becomes a bottleneck.

FAQ

Comparisons, answered.

How does LeanCTX compare to manual prompt engineering?

Manual prompt engineering requires hand-crafting every context window. LeanCTX automates this with 10 read modes, AST-aware compression, and session memory, saving 88%+ tokens with zero manual effort.

Is LeanCTX better than other MCP context tools?

LeanCTX is a full cognitive context layer rather than a plain MCP server: CLI integration, shell hooks, 76 MCP tools, persistent memory, code intelligence graphs, and a governance layer with roles and budgets.

Does LeanCTX work with my AI coding tool?

Yes. LeanCTX supports 30+ AI tools including Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, Codex, and JetBrains IDEs. Run lean-ctx setup for automatic configuration.

How is LeanCTX different from compression tools like Headroom?

Compression tools shrink what your agent has already read, on the message path. LeanCTX works one layer deeper, at the source: it decides what gets read in the first place (10 read modes, ~13-token cached re-reads), remembers knowledge across sessions, guards file and shell access, and signs every saving in a verifiable ledger. Compression is one of its five subsystems, and it is fully reversible: every original stays one ctx_retrieve away.

Is LeanCTX compression reversible?

Yes. Every compressed read is archived locally and the full original is retrievable on demand via ctx_retrieve. Nothing is silently lost; LeanCTX even tells your agent when to ask for the full content.

Get Started

See it on your repo.

Install in under a minute, run one session, then check the ledger. Your numbers will make the argument.

Get Started Security & Trust

You already have tools.Here's the difference.