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

Comparaison Honnête

Vous avez déjà des outils.
Voici la différence.

Les outils de compression réduisent ce que vous envoyez sur le réseau. LeanCTX fait cela aussi — et décide de ce qui est lu en premier lieu, puis le protège, s'en souvient et le prouve. Un aperçu direct de ce qu'il fait mieux, de ce qu'il fait pareil, et quand vous n'en avez pas du tout besoin.

Cote à Cote

Votre agent, avec et sans.

Le même agent, le même dépôt. La seule variable est la couche entre les deux.

Feature	Aucun Outil	Règles Manuelles	LeanCTX
Économies de Tokens	Aucune	Faible (règles statiques)	60–95 % (cache : 99 %)
Effort de Configuration	Aucun	Manuel par projet	Une commande
Support des Agents	N/A	Un seul agent	Plus de 29 agents
Caching	Aucun	Aucun	Automatique + delta
Compression Shell	Aucune	Aucune	Plus de 95 modèles
Analyse de code	Aucun	Aucun	AST Tree-sitter
Maintenance	Aucun	Mises à jour manuelles	Automatique
Sécurité et Gouvernance	Pas de mécanisme d'application	ACL de fichiers basique	Aligné OWASP : PathJail, liste blanche shell, redaction de secrets, exécution de code dans un OS sandbox (ctx_execute), piste d'audit
Compliance & Evidence	Screenshots	Collecte manuelle des preuves	Bundle de Preuves Signées + vérification hors ligne avec leanctx-verify, couverture EU AI Act / ISO 42001 / SOC 2, CGB + couverture des politiques
SDK et extensibilité	Aucun	Code de liaison sur mesure	SDK Python + TypeScript (conformité à 14 points), /v1 OpenAPI + capacités, passerelle ctx_tools, extensions WASM et plugins

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 Alternatives

Comment LeanCTX se compare aux autres outils

Une comparaison fonctionnalité par fonctionnalité avec RTK, Context+, MemGPT/Letta et Headroom, les alternatives les plus couramment référencées. Basé sur des faits, tiré de leur documentation publique.

Feature	RTK	Context+	MemGPT / Letta	Headroom	lean-ctx
Modes de lecture	Mode unique	Filtrage basique	N/A (axé mémoire)	Compresses après la lecture	10 modes (auto, map, signatures, diff, entropie...)
Compression Shell	Non	Non	Non	Non	95+ patterns, auto-détectés
Mémoire de session	État de base	Historique de conversation	Fonctionnalité principale (mémoire à niveaux)	Stockage inter-agents avec déduplication	Épisodique + procédural + graphe de connaissances
Multi-Agent	Non	Non	Limité (focus sur un seul agent)	Stockage partagé	Transfert, sessions partagées, bus de contexte
Graphe de code / AST	Indexation de base	Non	Non	Non	AST Tree-sitter, 26 langages, résolution de symboles
Governance & Budgets	Non	Non	Non	Non	Budgets basés sur les rôles, SLOs, piste d'audit
Local-First / Privacy	Dépend du cloud	Local	Basé sur le serveur	Package Python + proxy	100% local, zéro télémétrie
Outils MCP	Limité	Pas de MCP	Pas de MCP	Enveloppe des outils externes	81 outils MCP granulaires
Security Hardening	None	None	Basic auth	None	Sandboxing, signed bundles, audit reports

Basé sur la documentation et le code source publiquement disponibles au 2026.06. RTK (github.com/rtk-ai/rtk), Context+ (github.com/ForLoopCodes/contextplus), MemGPT/Letta (arxiv.org/abs/2310.08560), Headroom (github.com/chopratejas/headroom). Tous les outils résolvent de vrais problèmes. LeanCTX couvre simplement plus de couches du problème de contexte dans un seul binaire.

vs. couches de compression

La compression réduit ce qui a été lu. L'ingénierie du contexte décide ce qui est lu.

Des outils comme Headroom compressent la requête sur le fil. LeanCTX fournit déjà cette couche — un proxy local optionnel compresse chaque requête, safe pour le cache de prompts — et va une couche plus loin, à la source : il décide ce qui doit être lu. Compatible avec Headroom, mais vous n'en avez généralement pas besoin au-dessus. Voici la différence honnête.

Dimension	Couche de compression (ex. Headroom)	LeanCTX
Où elle se situe	Chemin du message : compresse ce que l'agent a déjà lu	À la source : décide quoi et comment lire (10 modes, routage d'intention, re-lectures mises en cache de ~13 tokens)
Memory	Stockage inter-agents avec déduplication	Connaissances persistantes : graphe de propriétés, sessions, transferts, registre des preuves
Governance	—	PathJail, allowlist shell, rédaction de secrets, budgets, détection d'injection
Preuve	Endpoint statistiques	Registre signé Ed25519, chaîne de hachage + benchmark reproductible
Réversibilité	Stockage de récupération de référence	Également réversible : chaque original est conservé `ctx_retrieve` éloigné
Form	Package Python + proxy	Un binaire Rust, 30+ outils auto-détectés, zéro configuration

Remarque : certains tableaux comparatifs tiers listent lean-ctx comme "Réversible : Non" ; ceci est incorrect. Chaque lecture compressée dans LeanCTX est archivée localement et récupérable via ctx_retrieve. La compression n'est qu'un des cinq sous-systèmes de LeanCTX. Les deux outils peuvent même fonctionner ensemble ; Headroom liste lean-ctx comme un outil contextuel compatible.

Pourquoi ne pas simplement…

Votre stack fait déjà une partie de cela. Voici ce qu'elle ne fait pas.

LeanCTX ne remplace ni grep, ni votre éditeur. C'est la couche qui décide ce qui mérite l'attention de votre IA.

Pourquoi pas juste grep ?

grep trouve du texte. LeanCTX trouve les bons symboles, les classe par pertinence et renvoie un contexte structuré et budgétisé au lieu des 500 correspondances brutes que vous devez toujours lire et filtrer.

Pourquoi pas juste lire les fichiers ?

Une lecture brute déverse 4 200 tokens alors que ~920 en contiennent le signal. LeanCTX conserve le signal et élimine le bruit, et une relecture mise en cache coûte environ 13 tokens au lieu du fichier entier à nouveau.

Pourquoi pas compacter plus souvent ?

La compaction jette un historique dont vous pourriez encore avoir besoin. Avec LeanCTX, il n'y a jamais de cul-de-sac : chaque original est archivé sur disque et votre agent le récupère à la demande. Rien n'est perdu silencieusement.

Pourquoi pas un autre serveur MCP ?

La plupart des serveurs MCP ajoutent une surcharge de définition d'outils et renvoient des résultats bruts. LeanCTX est une couche contextuelle cognitive complète : mise en cache, mémoire persistante, hooks shell et une couche de gouvernance, le tout dans un seul binaire local.

Meilleur choix

Quand lean-ctx Mise en évidence

LeanCTX apporte le plus de valeur dans ces scénarios.

Grandes bases de code

Les projets avec des centaines ou des milliers de fichiers en bénéficient le plus. Plus il y a de contexte à gérer, plus les économies sont importantes.

Flux de travail multi-agents

Lorsque plusieurs agents IA travaillent sur le même projet, LeanCTX leur fournit un cerveau partagé : un contexte cohérent et gouverné pour chaque agent.

Développement itératif

Les longues sessions de codage avec lectures répétées de fichiers utilisent le cache - les relectures coûtent seulement ~13 tokens au lieu de milliers.

Transparence

Quand vous n'en avez pas besoin

Nous croyons en des outils honnêtes. LeanCTX est conçu pour les projets avec des bases de code substantielles - pas pour tout.

Pas toujours nécessaire

Scripts sur un seul fichier ou petites utilitaires
Projets de moins de 50 fichiers
Prompts ponctuels sans contexte de fichier

Dans ces cas, la surcharge d'une couche de contexte n'est pas justifiée. LeanCTX excelle lorsque vos projets grandissent et que la gestion du contexte devient un goulot d'étranglement.

FAQ

Comparaisons, répondues.

Comment LeanCTX se compare-t-il à l'ingénierie de prompt manuelle ?

L'ingénierie de prompt manuelle nécessite de créer chaque fenêtre de contexte à la main. LeanCTX automatise cela avec 10 modes de lecture, une compression sensible aux AST et une mémoire de session, économisant plus de 88 % des jetons sans effort manuel.

LeanCTX est-il meilleur que les autres outils de contexte MCP ?

LeanCTX est une couche contextuelle cognitive complète plutôt qu'un simple serveur MCP : intégration CLI, hooks shell, 81 outils MCP, mémoire persistante, graphes d'intelligence du code et une couche de gouvernance avec des rôles et des budgets.

LeanCTX fonctionne-t-il avec mon outil de codage IA ?

Oui. LeanCTX prend en charge plus de 30 outils IA, y compris Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, Codex et les IDE JetBrains. Exécutez lean-ctx setup pour une configuration automatique.

En quoi LeanCTX est-il différent des outils de compression comme Headroom ?

Des outils comme Headroom compressent la requête sur le fil — la couche proxy. LeanCTX fournit déjà cette couche : un proxy local optionnel (lean-ctx proxy enable) qui compresse chaque requête — prompt système, historique et résultats d'outils — safe pour le cache de prompts, mesurant les dollars réels économisés, vous n'avez donc généralement pas besoin d'un proxy de compression de requête séparé au-dessus. Et LeanCTX va une couche plus loin, à la source : il décide ce qui est lu en premier lieu (10 modes de lecture, re-lectures mises en cache de ~13 tokens), se souvient des connaissances entre les sessions, protège l'accès aux fichiers et au shell, et signe chaque sauvegarde dans un registre vérifiable. La compression — côté lecture et côté fil — est l'un de ses cinq sous-systèmes, et elle est entièrement réversible : chaque original reste accessible via un ctx_retrieve.

La compression de LeanCTX est-elle réversible ?

Oui. Chaque lecture compressée est archivée localement et l'original complet est récupérable à la demande via ctx_retrieve. Rien n'est perdu silencieusement ; LeanCTX indique même à votre agent quand demander le contenu complet.

En quoi LeanCTX est-il différent de la mémoire d'agent fournisseur comme Claude dans Slack ou ClickUp Brain ?

Ces outils permettent à votre IA fournisseur de se souvenir de votre entreprise — vous le taguez, faites un suivi dans un fil et il construit une mémoire. Mais cette mémoire vit dans leur boîte noire : vous ne pouvez pas voir où elle est située, la déplacer ou remplacer le modèle qu'elle contient. C'est une connexion contextuelle, pas une connexion de modèle — au final, vous finissez par louer votre propre connaissance d'entreprise. LeanCTX garde les défenses de votre côté : les sessions, un graphe de connaissances et des paquets .ctxpkg portables restent locaux et inspectables, agnostiques quant au modèle entre OpenAI, Anthropic et Gemini. Même flux de travail agent-comme-collègue ; vous gardez le contexte.

Commencer

Voyez-le sur votre dépôt.

Installez en moins d'une minute, lancez une session, puis consultez le registre. Vos chiffres feront l'argumentaire.

Commencer Sécurité & Confiance

Vous avez déjà des outils.Voici la différence.