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

Confronto onesto

Hai già degli strumenti.
Ecco la differenza.

Gli strumenti di compressione riducono ciò che invii sul cavo. LeanCTX fa anche questo — e decide cosa viene letto in primo luogo, quindi lo protegge, lo ricorda e lo dimostra. Uno sguardo diretto su ciò che fa meglio, ciò che fa allo stesso modo e quando non ne hai affatto bisogno.

Lato a lato

Il tuo agente, con e senza.

Lo stesso agente, lo stesso repo. L'unica variabile è lo strato tra loro.

Feature	Nessuno Strumento	Regole Manuali	LeanCTX
Risparmio di Token	Nullo	Basso (regole statiche)	60–95% (cached: 99%)
Sforzo di Configurazione	Nessuno	Manuale per progetto	Un comando
Supporto Agenti	N/A	Solo un agente	29+ agenti
Caching	Nessuno	Nessuno	Automatico + delta
Compressione Shell	Nessuno	Nessuno	95+ pattern
Analisi Codice	Nessuno	Nessuno	AST Tree-sitter
Manutenzione	Nessuno	Aggiornamenti manuali	Automatico
Sicurezza e Governance	Nessu enforcement	ACL file di base	Allineato all'OWASP: PathJail, allowlist shell, ridazione segreti, esecuzione codice in sandbox OS (ctx_execute), traccia di audit
Compliance & Evidence	Screenshots	Raccolta manuale di prove	Bundle di Prove Firmate + offline leanctx-verify, copertura EU AI Act / ISO 42001 / SOC 2, CGB + copertura policy
SDK ed Estensibilità	Nessuno	Codice di incollaggio su misura	SDK Python + TypeScript (conformità a 14 controlli), /v1 OpenAPI + capacità, gateway ctx_tools, estensioni 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. Alternative

Come LeanCTX si confronta con Altri Strumenti

Un confronto funzione per funzione con RTK, Context+, MemGPT/Letta e Headroom, le alternative più comunemente citate. Basato sui fatti, dalla loro documentazione pubblica.

Feature	RTK	Context+	MemGPT / Letta	Headroom	lean-ctx
Modalità di lettura	Modalità singola	Filtraggio base	N/D (orientato alla memoria)	Comprime dopo la lettura	10 modalità (auto, map, signatures, diff, entropy...)
Compressione Shell	No	No	No	Nessuno	95+ pattern, auto-rilevati
Memoria della sessione	Stato base	Cronologia conversazione	Funzionalità principale (memoria a livelli)	Store cross-agent con dedup	Episodico + procedurale + knowledge graph
Multi-Agent	No	No	Limitato (focus su singolo agente)	Store condiviso	Handoff, sessioni condivise, context bus
Grafo di codice / AST	Indicizzazione di base	Nessuno	Nessuno	Nessuno	Tree-sitter AST, 26 linguaggi, risoluzione simboli
Governance & Budgets	Nessuno	Nessuno	Nessuno	Nessuno	Budget basati su ruoli, SLO, traccia di audit
Local-First / Privacy	Dipendente dal cloud	Locale	Basato su server	Pacchetto Python + proxy	100% locale, zero telemetria
Strumenti MCP	Limitati	Nessun MCP	Nessun MCP	Avvolge strumenti esterni	81 strumenti MCP granulari
Security Hardening	None	None	Basic auth	None	Sandboxing, signed bundles, audit reports

Basato su documentazione e codice sorgente pubblicamente disponibili al giugno 2026. RTK (github.com/rtk-ai/rtk), Context+ (github.com/ForLoopCodes/contextplus), MemGPT/Letta (arxiv.org/abs/2310.08560), Headroom (github.com/chopratejas/headroom). Tutti gli strumenti risolvono problemi reali. LeanCTX copre semplicemente più livelli del problema del contesto in un unico binario.

vs. strati di compressione

La compressione riduce ciò che è stato letto. L'ingegneria del contesto decide cosa viene letto.

Strumenti come Headroom comprimono la richiesta sul cavo. LeanCTX fornisce già quello strato — un proxy locale opzionale comprime ogni richiesta, sicuro per il cache dei prompt — e va un livello più in profondità, alla fonte: decide cosa deve essere letto. Compatibile con Headroom, ma di solito non è necessario sopra. Ecco la differenza onesta.

Dimension	Strato di compressione (es. Headroom)	LeanCTX
Dove si posiziona	Percorso del messaggio: comprime ciò che l'agente ha già letto	Alla fonte: decide cosa e come leggere (10 modalità, routing dell'intento, riletture memorizzate fino a ~13 token)
Memory	Store cross-agent con dedup	Conoscenza persistente: grafo di proprietà, sessioni, passaggi, registro delle prove
Governance	—	PathJail, allowlist shell, cancellazione segreti, budget, rilevamento iniezione
Prova	Endpoint statistici	Ed25519-signed, hash-chained ledger + benchmark riproducibile
Reversibilità	Archivio di recupero delle referenze	Anche reversibile: ogni originale rimane intatto `ctx_retrieve` lontano
Form	Pacchetto Python + proxy	Un singolo binario Rust, 30+ strumenti auto-rilevati, zero configurazione

Nota: alcune tabelle di confronto di terze parti elencano lean-ctx come "Reversible: No"; questo è errato. Ogni lettura compressa in LeanCTX viene archiviata localmente e recuperabile tramite ctx_retrieve. La compressione è uno dei cinque sottosistemi di LeanCTX. I due strumenti possono anche funzionare insieme; Headroom elenca lean-ctx come strumento context compatibile.

Perché non semplicemente…

Il tuo stack fa già parte di questo. Ecco cosa manca.

LeanCTX non sostituisce grep o il tuo editor. È lo strato che decide cosa merita l'attenzione della tua AI.

Perché non usare solo grep?

grep trova testo. LeanCTX trova i simboli giusti, li classifica per rilevanza e restituisce un contesto strutturale e bilanciato invece di 500 corrispondenze grezze che devi ancora leggere e filtrare.

Perché non leggere semplicemente i file?

Una lettura grezza scarica 4.200 token quando circa 920 ne trasmettono il segnale. LeanCTX mantiene il segnale e scarta il rumore, e una rilettura in cache costa circa 13 token invece dell'intero file di nuovo.

Perché non compattare più spesso?

La compattazione fa perdere la cronologia che potresti ancora aver bisogno. Con LeanCTX non c'è mai un vicolo cieco: ogni originale è archiviato su disco e il tuo agente lo recupera su richiesta. Nulla va perso silenziosamente.

Perché non un altro server MCP?

La maggior parte dei server MCP aggiunge overhead di definizione degli strumenti e restituisce output grezzo. LeanCTX è uno strato context cognitivo completo: caching, memoria persistente, hook shell e uno strato di governance, tutto in un unico binario locale.

Migliore Adattamento

Quando lean-ctx Eccelle

LeanCTX offre il massimo valore in questi scenari.

Codebase di grandi dimensioni

I progetti con centinaia o migliaia di file ne traggono il maggior beneficio. Più contesto c'è da gestire, maggiori sono i risparmi.

Flussi di lavoro multi-agente

Quando più agenti AI lavorano sullo stesso progetto, LeanCTX fornisce loro un cervello condiviso: un contesto coerente e governato per ogni agente.

Sviluppo iterativo

Le lunghe sessioni di codifica con letture ripetute di file colpiscono la cache: le riletture costano solo ~13 token invece di migliaia.

Trasparenza

Quando Hai Non Ti Serve

Crediamo negli strumenti onesti. LeanCTX è progettato per progetti con codebase sostanziali, non per tutto.

Non Sempre Necessario

Script single-file o piccole utilità
Progetti sotto i 50 file
Prompt usa e getta senza contesto di file

In questi casi, l'overhead di un layer di contesto non è giustificato. LeanCTX brilla quando i tuoi progetti crescono e la gestione del contesto diventa un collo di bottiglia.

FAQ

Confronti, risposte.

Come si confronta LeanCTX con l'ingegneria manuale dei prompt?

L'ingegneria manuale dei prompt richiede di creare a mano ogni finestra di contesto. LeanCTX automatizza questo con 10 modalità di lettura, compressione consapevole AST e memoria di sessione, risparmiando oltre l'88% dei token senza sforzo manuale.

LeanCTX è migliore degli altri strumenti di contesto MCP?

LeanCTX è un livello di contesto cognitivo completo piuttosto che un semplice server MCP: integrazione CLI, hook shell, 81 strumenti MCP, memoria persistente, grafici di intelligenza del codice e un livello di governance con ruoli e budget.

lean-ctx funziona con il mio strumento di coding AI?

Sì. LeanCTX supporta oltre 30 strumenti AI, tra cui Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, Codex e JetBrains IDEs. Esegui lean-ctx setup per una configurazione automatica.

In che modo LeanCTX è diverso dagli strumenti di compressione come Headroom?

Strumenti come Headroom comprimono la richiesta sul cavo — lo strato proxy. LeanCTX fornisce già quello strato: un proxy locale opzionale (lean-ctx proxy enable) comprime ogni richiesta — prompt del sistema, cronologia e risultati degli strumenti — sicuro per il cache dei prompt, misurando i dollari reali risparmiati, quindi di solito non hai bisogno di un proxy separato di compressione della richiesta sopra. E LeanCTX va un livello più in profondità, alla fonte: decide cosa viene letto in primo luogo (10 modalità di lettura, riletture memorizzate fino a ~13 token), ricorda la conoscenza tra le sessioni, protegge l'accesso ai file e al shell, e firma ogni salvataggio in un registro verificabile. La compressione — lato lettura e lato cavo — è uno dei suoi cinque sottosistemi ed è completamente reversibile: ogni originale rimane raggiungibile con un ctx_retrieve.

La compressione di LeanCTX è reversibile?

Sì. Ogni lettura compressa viene archiviata localmente e l'originale completo è recuperabile su richiesta tramite ctx_retrieve. Nulla va perso silenziosamente; LeanCTX dice anche al tuo agente quando chiedere il contenuto completo.

In che modo LeanCTX è diverso dalla memoria degli agenti fornitori come Claude in Slack o ClickUp Brain?

Questi fanno sì che il tuo AI fornitore ricordi la tua azienda — tu lo etichetti, fai seguito in una conversazione e costruisce una memoria. Ma quella memoria vive nella loro scatola nera: non puoi vedere dove si trova, muoverla o sostituire il modello sottostante. Quello è un login di contesto, non un login di modello — finisci per affittare la conoscenza della tua azienda stessa. LeanCTX mantiene il fossato dalla tua parte: sessioni, un grafo di conoscenza e pacchetti .ctxpkg portabili rimangono locali e ispezionabili, agnostici rispetto al modello su OpenAI, Anthropic e Gemini. Lo stesso flusso di lavoro agente-come-collega; tu mantieni il contesto.

Inizia Ora

Vederlo su il tuo repo.

Installa in meno di un minuto, esegui una sessione e poi controlla il registro. I tuoi numeri faranno l'argomento.

Inizia Ora Sicurezza e Fiducia

Hai già degli strumenti.Ecco la differenza.