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

Non fidarti.
Verifica.

Esegui lean-ctx benchmark run in qualsiasi progetto. Conteggi di token reali. Metriche di accuratezza reali. Misurato con tiktoken (o200k_base).

Inizia Stella su GitHub

Come rimane onesto

Misurato. Verificato.

Benchmark esegue localmente, conta i token con il tokenizer esatto e rifiuta le compressioni che scendono sotto la soglia di qualità.

Conteggio esatto dei token

Conta con lo stesso tokenizer utilizzato dai moderni LLM: niente stime, nessun gioco.

tiktoken o200k_base

Guardia di qualità

Valuta la conservazione dell'AST, degli identificatori e della struttura delle righe. Gli output fallimentari vengono bloccati automaticamente.

soglia: Q ≥ 95% · ρ ≥ 15%

Riproducibile

Esegue sul tuo repository. Stessi input → stessi numeri. Ottimo per CI e regressioni.

offline · deterministico

Vedi la differenza

Prima & Dopo

Lo stesso file. Le stesse informazioni. Molto meno token.

Senza LeanCTX

// src/auth.ts · mode=full

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

import { bcrypt } from 'bcryptjs';

…

3,517 token

Con LeanCTX (modalità mappa)

// src/auth.ts · mode=map

exports: AuthService, validateToken, …

deps: jsonwebtoken, bcryptjs, ioredis

…

412 token

88% di token in meno

Tre passaggi per un risparmio verificato

Indica. Misura. Verifica.

Indica qualsiasi file o directory

Passa un singolo file, una directory o un pattern glob. Il motore di benchmark elabora tutto ciò che trova.

lean-ctx benchmark run src/

Misurazione esatta dei token

Utilizza tiktoken con l'encoding o200k_base (stesso di GPT-4o, Claude e moderni LLMs). Niente stime - conteggi token reali.

tiktoken o200k_base

Risparmi per modalità

Ottieni punteggi di accuratezza e percentuali di risparmio per ogni modalità di compressione. Scegli la modalità giusta per ogni caso d'uso.

modes: 10

Output reale

Benchmark in azione

Esegui il benchmark su qualsiasi file del tuo progetto. L'output mostra i conteggi esatti di token per ogni modalità di compressione, la percentuale di risparmio e i punteggi di conservazione della qualità.

Suddivisione per file - token prima e dopo ogni modalità

Punteggi di qualità - AST, identificatori e righe di codice preservati

Totali aggregati - risparmio per directory con raccomandazione della migliore modalità

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

Seleziona la modalità giusta per ogni compito

Modalità di lettura Rispetto a

full 0%

File che modificherai

Tutto - contenuto completo memorizzato per nuove letture con ~13 token

map 70-90%

Solo file di contesto

Codice: deps + exports + firme. Non codice: schemi strutturati (intestazioni Markdown, chiavi JSON/YAML/TOML, riepiloghi lock)

signatures 55–93%

Esplorazione della superficie API

Solo firme di funzione/classe/tipo

diff 80–95%

Dopo le modifiche

Righe modificate con contesto circostante minimo

aggressive 75–90%

Grandi file boilerplate

Struttura e logica, sintassi rimossa

entropy 70–83%

File rumorosi (JSDoc, commenti)

Solo righe ad alta entropia (filtraggio Shannon + Jaccard)

task 65–85%

Letture focalizzate sul task (es. 'fix auth bug')

Codice rilevante per il task + contesto di dipendenza tramite Knowledge Graph + filtro IB

auto 70–99%

Predefinito - LeanCTX sceglie automaticamente la migliore modalità

Si adatta per file: tipo, bucket dimensione, recenza, rilevanza del compito

reference 80–95%

Documentazione API e ricerca di riferimento

API pubblica, tipi, firme, docstring

lines:N-M 90–99%

Lettura di un intervallo specifico di righe - precisione chirurgica

Righe esatte richieste, più contesto circostante minimo

LeanCTX's ctx_smart_read di LeanCTX seleziona automaticamente la modalità ottimale utilizzando la previsione bayesiana basata sul tipo, dimensione e contesto del file.

Stadio

Pipeline di Compressione Avanzata

Oltre la selezione della modalità, LeanCTX applica una pipeline di ottimizzazione multi-stadio che si adatta al tipo di file, al contesto della sessione e all'intento del compito:

Thompson Sampling 5–15%

Impara soglie di compressione ottimali per tipo di file utilizzando l'esplorazione multi-armed bandit (esplora vs sfrutta)

AST Pruning 40–70%

Potatura consapevole del linguaggio tramite Tree-sitter - rimuove corpi di funzione, commenti e boilerplate preservando le firme API

IDF Dedup 10–30%

Dedoublificazione cross-file utilizzando la frequenza inversa dei documenti - elimina contenuti già visti nella sessione

IB Filter 15–25%

Filtraggio consapevole del compito utilizzando il principio dell'Information Bottleneck - mantiene solo i contenuti rilevanti per il compito corrente

Verbatim Compaction 5–20%

Collassa strutture ripetitive (importazioni, righe di log, boilerplate) in riassunti contati

Questi stadi sono cumulativi - applicati in sequenza, possono ridurre un file di 1000 righe a meno di 50 token preservando tutte le informazioni rilevanti per il compito. La pipeline è completamente automatica e non richiede configurazione.

Preservazione verificata

Compressione Qualità

Soglia di qualità (composita)

95%

L'output compresso viene utilizzato solo se il punteggio di qualità composito rimane al 95% o superiore.

Densità minima

15%

Blocca l'output a bassa informazione con una densità di segnale minima del 15% (ρ).

Ponderazione

50/30/20

Composito = AST 50% + identificatori 30% + righe 20% - quindi la struttura è più importante.

Principio di densità informativa

Perché meno token = Maggiore Densità di Segnale

Gli LLM hanno un budget di attenzione fisso. Ogni token nella finestra di contesto compete per i pesi di attenzione. Riempire la finestra con boilerplate significa meno attenzione sul codice che conta.

Rimuovendo il rumore prima che raggiunga il modello, LeanCTX aumenta la densità informativa di ogni richiesta. Il risultato: un rapporto segnale-rumore più alto, minore diluizione del contesto e il modello rimane entro limiti di contesto utili.

Rapporto segnale/rumore più elevato

10K token di contesto focalizzato superano 200K di boilerplate. Il modello concentra la sua attenzione sulla logica anziché sui commenti JSDoc e sul boilerplate degli import.

Rumore contestuale ridotto

Il rumore contestuale diluisce la finestra di attenzione del modello. Rimuoverlo aiuta il modello a rimanere ancorato alla reale struttura del codice e riduce la possibilità di allucinazioni.

Costo inferiore per risposta

Meno token di input significa costi API inferiori e più messaggi nel tuo limite di frequenza. La stessa quota va più lontano, per ogni strumento AI che usi.

Esempi del mondo reale

Misurato su Codice Reale

Snapshot rappresentativi - i tuoi numeri varieranno in base al file e alla codebase.

Componente React 88%

450 righe - modalità mappa

12,840 → 1,541

Modulo Rust 93%

820 righe - modalità firme

18,290 → 1,280

API Express 91%

1.200 righe - modalità aggressiva

31,500 → 2,835

Pipeline ML Python 83%

680 righe - modalità entropia

15,400 → 2,618

Configurazione TypeScript 95%

340 righe - modalità diff

8,750 → 437

Trasparenza

Benchmark
Metodologia

Ogni numero su questa pagina è riproducibile. Ecco esattamente come misuriamo.

Tokenizer

Tutti i conteggi di token utilizzano tiktoken con l'o200k_base encoding, lo stesso tokenizer utilizzato da GPT-4o, Claude e LLM moderni. Niente stime o approssimazioni.

Soglia di Qualità

L'output compresso viene utilizzato solo se il punteggio di qualità composito rimane al 95% o superiore. Composito = conservazione AST (50%) + conservazione identificatori (30%) + copertura delle righe (20%).

Riprodurre Localmente

Esegui lean-ctx benchmark run src/ sul tuo codebase. L'output mostra i conteggi esatti di token per ogni modalità di compressione, la percentuale di risparmio e i punteggi di conservazione della qualità.

Dichiarazione di Non Responsabilità

I risultati variano in base al tipo di file, dimensione, linguaggio e modalità di lettura. L'intervallo "60-99%" riflette la variazione del mondo reale: i piccoli file strutturati si comprimono di più, i grandi file non strutturati si comprimono di meno. Le riletture in cache (~13 token) rappresentano il caso migliore.

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.

Misura il tuo risparmio effettivo.

Installa LeanCTX ed esegui benchmark run sul tuo codebase. Numeri reali, i tuoi file, il tuo risparmio.

lean-ctx benchmark run src/

Funziona su qualsiasi codebase. Nessuna configurazione richiesta. Risultati in pochi secondi.

Inizia Stella su GitHub

Non fidarti.Verifica.

Misurato. Verificato.

Conteggio esatto dei token

Guardia di qualità

Riproducibile

Prima & Dopo

Indica. Misura. Verifica.

Indica qualsiasi file o directory

Misurazione esatta dei token

Risparmi per modalità

Benchmark in azione

Modalità di lettura Rispetto a

Pipeline di Compressione Avanzata

Compressione Qualità

Perché meno token = Maggiore Densità di Segnale

Misurato su Codice Reale

BenchmarkMetodologia

Tokenizer

Soglia di Qualità

Riprodurre Localmente

Dichiarazione di Non Responsabilità

Our Own Overhead, Measured

Deterministic Self-Verify

Misura il tuo risparmio effettivo.

Non fidarti.
Verifica.

Benchmark
Metodologia