╭──────────────────────────────────────────╮ ╭──────────────────────────────────────────╮ │ >>>>>>>>>>>>>>> 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

Comparação Honesta

Você já tem ferramentas.
Aqui está a diferença.

Ferramentas de compressão encolhem o que você envia pela linha. O LeanCTX faz isso também — e decide o que é lido em primeiro lugar, depois protege, lembra e prova isso. Uma análise direta do que ele faz melhor, o que ele faz igual, e quando você não precisa dele de jeito nenhum.

Lado a Lado

Seu agente, com e sem.

O mesmo agente, o mesmo repositório. A única variável é a camada entre eles.

Feature	Sem Ferramenta	Regras Manuais	LeanCTX
Economia de Tokens	Nenhum	Baixa (regras estáticas)	60–95% (cache: 99%)
Esforço de Configuração	Nenhum	Manual por projeto	Um comando
Suporte a Agentes	N/A	Apenas um agente	29+ agentes
Caching	Nenhum	Nenhum	Automático + delta
Compressão de Shell	Nenhum	Nenhum	95+ padrões
Análise de Código	Nenhum	Nenhum	AST Tree-sitter
Manutenção	Nenhum	Atualizações manuais	Automático
Segurança e Governança	Sem aplicação	ACL de arquivo básico	Alinhado ao OWASP: PathJail, allowlist de shell, redação de segredos, execução de código em sandbox OS (ctx_execute), trilha de auditoria
Compliance & Evidence	Screenshots	Coleta manual de evidências	Bundle de Evidência Assinado + offline leanctx-verify, cobertura EU AI Act / ISO 42001 / SOC 2, CGB + cobertura de políticas
SDKs e Extensibilidade	Nenhum	Código cola personalizado	SDKs Python + TypeScript (conformance de 14 verificações), /v1 OpenAPI + capacidades, gateway ctx_tools, extensões WASM e plugin

The cached figure (99%) is a repeat read served from cache at ~13 tokens; a first read never returns more tokens than the raw file, and every saving is measured net of injection (the tokens lean-ctx itself adds), so the number reconciles to your provider bill.

vs. Alternativas

Como LeanCTX se Compara a Outras Ferramentas

Uma comparação recurso por recurso com RTK, Context+, MemGPT/Letta e Headroom, as alternativas mais citadas. Baseado em fatos, de sua documentação pública.

Feature	RTK	Context+	MemGPT / Letta	Headroom	lean-ctx
Modos de Leitura	Modo único	Filtragem básica	N/A (focado em memória)	Comprime após a leitura	10 modos (auto, map, signatures, diff, entropy...)
Compressão de Shell	Não	Não	Não	Não	95+ padrões, auto-detectados
Memória da Sessão	Estado básico	Histórico de conversação	Recurso principal (memória em camadas)	Armazenamento cross-agent com desduplicação	Episódico + processual + grafo de conhecimento
Multi-Agent	Não	Não	Limitado (foco em agente único)	Armazenamento compartilhado	Handoff, sessões compartilhadas, bus de contexto
Grafo de Código / AST	Indexação básica	Não	Não	Não	AST Tree-sitter, 26 linguagens, resolução de símbolos
Governance & Budgets	Não	Não	Não	Não	Orçamentos baseados em função, SLOs, trilha de auditoria
Local-First / Privacy	Dependente da nuvem	Local	Baseado em servidor	Pacote Python + proxy	100% local, zero telemetria
Ferramentas MCP	Limitado	Sem MCP	Sem MCP	Envolve ferramentas externas	81 ferramentas MCP granulares
Security Hardening	None	None	Basic auth	None	Sandboxing, signed bundles, audit reports

Baseado na documentação e código-fonte publicamente disponíveis até junho de 2026. RTK (github.com/rtk-ai/rtk), Context+ (github.com/ForLoopCodes/contextplus), MemGPT/Letta (arxiv.org/abs/2310.08560), Headroom (github.com/chopratejas/headroom). Todas as ferramentas resolvem problemas reais. LeanCTX simplesmente cobre mais camadas do problema de contexto em um único binário.

vs. camadas de compressão

Compressão encolhe o que foi lido. Engenharia de contexto decide o que é lido.

Ferramentas como Headroom comprimem a requisição na linha. O LeanCTX já fornece essa camada — um proxy local opcional comprime toda requisição, seguro para cache de prompts — e vai mais uma camada fundo, na fonte: ele decide o que deve ser lido. Compatível com Headroom, mas você geralmente não precisa dele por cima. Aqui está a diferença honesta.

Dimension	Camada de compressão (ex.: Headroom)	LeanCTX
Onde se encaixa	Caminho da mensagem: comprime o que o agente já leu	Na fonte: decide o que e como ler (10 modos, roteamento de intenção, releituras cacheadas de ~13 tokens)
Memory	Armazenamento cross-agent com dedup	Conhecimento persistente: grafo de propriedade, sessões, passagens, livro-razão de evidências
Governance	—	PathJail, allowlist de shell, redação de segredos, orçamentos, detecção de injeção
Prova	Endpoint de estatísticas	Ed25519-signed, hash-chained ledger + benchmark reprodutível
Reversibilidade	Armazenamento de recuperação de referência	Também reversível: cada original permanece intacto `ctx_retrieve` fora
Form	Pacote Python + proxy	Um binário Rust, 30+ ferramentas auto-detectadas, zero configuração

Nota: algumas tabelas de comparação de terceiros listam lean-ctx como "Reversible: Não"; isso está incorreto. Cada leitura comprimida em LeanCTX é arquivada localmente e recuperável via ctx_retrieve. A compressão é um dos cinco subsistemas do LeanCTX. As duas ferramentas podem até rodar juntas; Headroom lista lean-ctx como uma ferramenta de contexto compatível.

Por que não apenas…

Seu stack já faz parte disso. Veja o que falta.

LeanCTX não substitui grep ou seu editor. É a camada que decide o que merece a atenção do seu AI.

Por que não apenas grep?

grep encontra texto. LeanCTX encontra os símbolos certos, ranqueia-os por relevância e retorna contexto estrutural orçamentado em vez de 500 correspondências brutas que você ainda precisa ler e filtrar.

Por que não apenas ler os arquivos?

Uma leitura bruta despeja 4.200 tokens quando ~920 carregam o sinal. LeanCTX mantém o sinal e descarta o ruído, e uma releitura em cache custa cerca de 13 tokens em vez do arquivo inteiro novamente.

Por que não compactar com mais frequência?

A compactação joga fora histórico que você ainda pode precisar. Com LeanCTX nunca há um beco sem saída: cada original é arquivado no disco e seu agente o recupera sob demanda. Nada se perde silenciosamente.

Por que não outro servidor MCP?

A maioria dos servidores MCP adiciona sobrecarga de definição de ferramentas e devolve saída bruta. LeanCTX é uma camada cognitiva de contexto completa: cache, memória persistente, hooks de shell e uma camada de governança, tudo em um único binário local.

Melhor Ajuste

Quando usar lean-ctx Brilha

LeanCTX oferece o maior valor nestes cenários.

Bases de Código Grandes

Projetos com centenas ou milhares de arquivos se beneficiam mais. Quanto mais contexto há para gerenciar, maiores as economias.

Fluxos de Trabalho Multi-Agente

Quando múltiplos agentes de IA trabalham no mesmo projeto, LeanCTX fornece um cérebro compartilhado: contexto consistente e governado para cada agente.

Desenvolvimento Iterativo

Sessões longas de codificação com leituras repetidas de arquivos atingem o cache - releituras custam apenas ~13 tokens em vez de milhares.

Transparência

Quando Você Não Precisa

Acreditamos em ferramentas honestas. LeanCTX é projetado para projetos com bases de código substanciais - não para tudo.

Nem Sempre Necessário

Scripts de arquivo único ou utilitários pequenos
Projetos com menos de 50 arquivos
Prompts avulsos sem contexto de arquivo

Nesses casos, o overhead de uma camada de contexto não é justificado. LeanCTX brilha quando seus projetos crescem e o gerenciamento de contexto se torna um gargalo.

FAQ

Comparações, respondidas.

Como o LeanCTX se compara à engenharia de prompt manual?

A engenharia de prompt manual exige a criação manual de cada janela de contexto. O LeanCTX automatiza isso com 10 modos de leitura, compressão consciente AST e memória de sessão, economizando mais de 88% dos tokens sem esforço manual.

O LeanCTX é melhor que outras ferramentas de contexto MCP?

LeanCTX é uma camada de contexto cognitiva completa em vez de um servidor MCP simples: integração CLI, hooks de shell, 81 ferramentas MCP, memória persistente, grafos de inteligência de código e uma camada de governança com funções e orçamentos.

O LeanCTX funciona com minha ferramenta de codificação AI?

Sim. O LeanCTX suporta mais de 30 ferramentas de IA, incluindo Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, Codex e JetBrains IDEs. Execute lean-ctx setup para configuração automática.

Como o LeanCTX é diferente de ferramentas de compressão como Headroom?

Ferramentas como Headroom comprimem a requisição na linha — a camada proxy. O LeanCTX já fornece essa camada: um proxy local opcional (lean-ctx proxy enable) comprime toda requisição — prompt do sistema, histórico e resultados de ferramentas — seguro para cache de prompts, mensurando os dólares reais economizados, de modo que você geralmente não precisa de um proxy separado de compressão de requisições por cima. E o LeanCTX vai mais uma camada fundo, na fonte: ele decide o que é lido em primeiro lugar (10 modos de leitura, releituras cacheadas de ~13 tokens), lembra conhecimento entre sessões, protege acesso a arquivos e shell, e assina cada salvamento em um livro-razão verificável. Compressão — lado da leitura e na linha — é um de seus cinco subsistemas, e é totalmente reversível: todo original permanece acessível com um ctx_retrieve.

A compressão do LeanCTX é reversível?

Sim. Cada leitura comprimida é arquivada localmente e o original completo é recuperável sob demanda via ctx_retrieve. Nada se perde silenciosamente; o LeanCTX até informa ao seu agente quando solicitar o conteúdo completo.

Como o LeanCTX é diferente da memória do agente fornecedor como Claude no Slack ou ClickUp Brain?

Esses fazem seu IA fornecedor lembrar sua empresa — você marca, dá seguimento em um tópico e ele constrói a memória. Mas essa memória vive na caixa preta deles: você não pode ver onde ela está, movê-la ou trocar o modelo por baixo. Isso é um login de contexto, não um login de modelo — no final você acaba alugando seu próprio conhecimento da empresa de volta. O LeanCTX mantém o fosso do lado você: sessões, um grafo de conhecimento e pacotes .ctxpkg portáteis permanecem locais e inspecionáveis, agnósticos a modelos em OpenAI, Anthropic e Gemini. Mesmo fluxo de trabalho de agente-como-colega; você mantém o contexto.

Começar

Veja em seu repositório.

Instale em menos de um minuto, execute uma sessão e depois verifique o livro-razão. Seus números farão o argumento.

Começar Segurança e Confiança

Você já tem ferramentas.Aqui está a diferença.