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

Benchmark

Não Confie.
Verifique.

Execute lean-ctx benchmark run em qualquer projeto. Contagens reais de tokens. Métricas de precisão reais. Medido com tiktoken (o200k_base).

Começar Estrelar no GitHub

Como ele se mantém honesto

Medido. Verificado.

O Benchmark roda localmente, conta tokens com o tokenizer exato e rejeita compressões que caem abaixo da barra de qualidade.

Contagem exata de tokens

Conta com o mesmo tokenizer usado por LLMs modernos - sem estimativas, sem suposições.

tiktoken o200k_base

Guarda de qualidade

Pontua a preservação do AST, identificadores e estrutura de linha. Saídas que falham são bloqueadas automaticamente.

threshold: Q ≥ 95% · ρ ≥ 15%

Reproduzível

Roda no seu repositório. Mesmas entradas → mesmos números. Ótimo para CI e regressões.

offline · determinístico

Veja a diferença

Antes & Depois

O mesmo arquivo. A mesma informação. Tokens dramaticamente menores.

Sem LeanCTX

// src/auth.ts · mode=full

import { jwt, verify, sign } from 'jsonwebtoken';

import { bcrypt } from 'bcryptjs';

…

3,517 tokens

Com LeanCTX (modo mapa)

// src/auth.ts · mode=map

exports: AuthService, validateToken, …

deps: jsonwebtoken, bcryptjs, ioredis

…

412 tokens

88% menos tokens

Três passos para economias verificadas

Aponte. Meça. Verifique.

Aponte para qualquer arquivo ou diretório

Passar um único arquivo, um diretório ou um padrão glob. O motor de benchmark processa tudo o que encontrar.

lean-ctx benchmark run src/

Medição exata de tokens

Usa tiktoken com a codificação o200k_base (mesma do GPT-4o, Claude e LLMs modernos). Sem estimativas - contagens reais de tokens.

tiktoken o200k_base

Economia por modo

Obtenha pontuações de precisão e porcentagens de economia para cada modo de compressão. Escolha o modo certo para cada caso de uso.

modes: 10

Saída real

Benchmark em ação

Execute o benchmark em qualquer arquivo do seu projeto. A saída mostra contagens exatas de tokens para cada modo de compressão, porcentagem de economia e pontuações de preservação de qualidade.

Detalhe por arquivo - tokens antes e depois de cada modo

Pontuações de qualidade - AST, identificadores e linhas de código preservados

Totais agregados - economia em todo o diretório com recomendação do melhor modo

lean-ctx benchmark run

$ lean-ctx benchmark run src/auth.ts

◆ lean-ctx Benchmark

────────────────────────────────────────

src/auth.ts (123 lines, 3,517 tokens)

────────────────────────────────────────

Mode Tokens Saved Rate

full 3,517 0 0%

map 412 3,105 88%

signatures 252 3,265 93%

diff 187 3,330 95%

aggressive 298 3,219 92%

entropy 312 3,205 91%

────────────────────────────────────────

Quality: AST 98% | Idents 97% | Lines 96%

Encoding: tiktoken o200k_base | Time: 12ms

Escolha o modo certo para cada tarefa

Modos de Leitura Comparado

full 0%

Arquivos que você irá editar

Tudo - conteúdo completo em cache para releituras em ~13 tokens

map 70-90%

Apenas arquivos de contexto

Código: deps + exports + assinaturas. Não-código: esboços estruturados (títulos Markdown, chaves JSON/YAML/TOML, resumos de lock)

signatures 55–93%

Exploração da superfície da API

Somente assinaturas de função/classe/tipo

diff 80–95%

Após edições

Linhas alteradas com contexto circundante mínimo

aggressive 75–90%

Arquivos boilerplate grandes

Estrutura e lógica, sintaxe removida

entropy 70–83%

Arquivos ruidosos (JSDoc, comentários)

Apenas linhas de alta entropia (filtragem Shannon + Jaccard)

task 65–85%

Leituras focadas na tarefa (ex.: 'corrigir bug de autenticação')

Código relevante para a tarefa + contexto de dependência via Knowledge Graph + filtro IB

auto 70–99%

Padrão - LeanCTX escolhe o melhor modo automaticamente

Adapta-se por arquivo: tipo, balde de tamanho, recente, relevância da tarefa

reference 80–95%

Documentação de API e pesquisa de referência

API pública, tipos, assinaturas, docstrings

lines:N-M 90–99%

Ler um intervalo específico de linhas - precisão cirúrgica

Linhas exatas solicitadas, mais contexto mínimo circundante

O ctx_smart_read do LeanCTX escolhe automaticamente o modo ideal usando previsão Bayesiana baseada no tipo, tamanho e contexto do arquivo.

Estágio

Pipeline Avançado de Compressão

Além da seleção de modo, o LeanCTX aplica um pipeline de otimização multiestágio que se adapta ao tipo de arquivo, contexto da sessão e intenção da tarefa:

Thompson Sampling 5–15%

Aprende limiares ótimos de compressão por tipo de arquivo usando exploração de bandit multi-braço (explorar vs explorar)

AST Pruning 40–70%

Poda consciente do idioma via Tree-sitter - remove corpos de função, comentários e código repetitivo preservando assinaturas de API

IDF Dedup 10–30%

Desduplicação entre arquivos usando frequência inversa de documentos - elimina conteúdo já visto na sessão

IB Filter 15–25%

Filtragem consciente da tarefa usando o princípio do Gargalo de Informação - mantém apenas conteúdo relevante para a tarefa atual

Verbatim Compaction 5–20%

Colapsa estruturas repetitivas (imports, linhas de log, código repetitivo) em resumos contados

Estes estágios são cumulativos - aplicados em sequência, podem reduzir um arquivo de 1000 linhas para menos de 50 tokens preservando todas as informações relevantes para a tarefa. O pipeline é totalmente automático e não requer configuração.

Preservação verificada

Compressão Qualidade

Limiar de qualidade (composto)

95%

A saída comprimida só é usada se a pontuação de qualidade composta permanecer em 95% ou acima.

Densidade mínima

15%

Bloqueia saídas de baixa informação com uma densidade mínima de sinal de 15% (ρ).

Ponderação

50/30/20

Composto = AST 50% + identificadores 30% + linhas 20% - então a estrutura é o que mais importa.

Princípio da densidade de informação

Por que Menos Tokens = Maior Densidade de Sinal

Os LLMs têm um orçamento de atenção fixo. Cada token na janela de contexto compete por pesos de atenção. Encher a janela com código repetitivo significa menos atenção no código que importa.

Ao remover o ruído antes que ele chegue ao modelo, LeanCTX aumenta a densidade da informação de cada solicitação. O resultado: maior razão sinal-ruído, menor diluição do contexto e o modelo permanece dentro dos limites de contexto útil.

Maior razão sinal-ruído

10K tokens de contexto focado superam 200K de código boilerplate. O modelo concentra sua atenção na lógica em vez de comentários JSDoc e código boilerplate de importação.

Ruído de contexto reduzido

O ruído de contexto dilui a janela de atenção do modelo. Removê-lo ajuda o modelo a permanecer ancorado na estrutura real do código e reduz a chance de alucinação.

Custo menor por resposta

Menos tokens de entrada significam custos de API mais baixos e mais mensagens dentro do seu limite de taxa. A mesma cota vai mais longe — para cada ferramenta de IA que você usa.

Exemplos do mundo real

Medido em Código Real

Instantâneos representativos - seus números variarão por arquivo e base de código.

Componente React 88%

450 linhas - modo map

12,840 → 1,541

Módulo Rust 93%

820 linhas - modo signatures

18,290 → 1,280

API Express 91%

1.200 linhas - modo aggressive

31.500 → 2.835

Pipeline ML Python 83%

680 linhas - modo entropy

15,400 → 2,618

Configuração TypeScript 95%

340 linhas - modo diff

8,750 → 437

Transparência

Benchmark
Metodologia

Cada número nesta página é reprodutível. Veja exatamente como medimos.

Tokenizer

Todas as contagens de tokens usam tiktoken com a codificação o200k_base, o mesmo tokenizador usado por GPT-4o, Claude e LLMs modernos. Sem estimativas ou aproximações.

Limiar de Qualidade

A saída comprimida só é usada se a pontuação de qualidade composta permanecer em 95% ou acima. Composto = preservação AST (50%) + preservação de identificador (30%) + cobertura de linha (20%).

Reproduzir Localmente

Execute lean-ctx benchmark run src/ em sua própria base de código. A saída mostra contagens exatas de tokens para cada modo de compressão, porcentagem de economia e pontuações de preservação de qualidade.

Aviso Legal

Os resultados variam por tipo de arquivo, tamanho, linguagem e modo de leitura. O intervalo "60-99%" reflete a variação do mundo real: arquivos estruturados pequenos comprimem mais, arquivos não estruturados grandes comprimem menos. Releituras em cache (~13 tokens) representam o melhor caso.

Our Own Overhead, Measured

Savings claims must be net of what LeanCTX itself injects. The fixed per-session footprint (advertised tool schemas + MCP instructions) is ~2.1K tokens, measured in an isolated environment with lean-ctx doctor overhead and enforced in CI via --gate — it can only shrink. lean-ctx gain reports savings net of this overhead.

Deterministic Self-Verify

lean-ctx benchmark dual-arm --json replays a pinned 15-turn agent session through a stateless arm and the long-lived proxy rail, prices both with real tokenizer counts and published per-model rates, and fingerprints the run with a BLAKE3 digest — anyone can reproduce the exact figures, no live model needed.

Meça seu economia real.

Instale o LeanCTX e execute benchmark run em sua base de código. Números reais, seus arquivos, suas economias.

lean-ctx benchmark run src/

Funciona em qualquer codebase. Sem configuração. Resultados em segundos.

Começar Estrelar no GitHub

Não Confie.Verifique.

Medido. Verificado.

Contagem exata de tokens

Guarda de qualidade

Reproduzível

Antes & Depois

Aponte. Meça. Verifique.

Aponte para qualquer arquivo ou diretório

Medição exata de tokens

Economia por modo

Benchmark em ação

Modos de Leitura Comparado

Pipeline Avançado de Compressão

Compressão Qualidade

Por que Menos Tokens = Maior Densidade de Sinal

Medido em Código Real

BenchmarkMetodologia

Tokenizer

Limiar de Qualidade

Reproduzir Localmente

Aviso Legal

Our Own Overhead, Measured

Deterministic Self-Verify

Meça seu economia real.

Não Confie.
Verifique.

Benchmark
Metodologia