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

So funktioniert's

Wie LeanCTX kontrolliert, was
deine KI sieht.

LeanCTX ist der Context-Engineering-Layer für KI-Agenten: eine kleine Rust-Binary, die bei jedem Read, Befehl und jeder Suche dieselbe Schleife durchläuft. Sie entscheidet, was deine Agenten lesen, erinnert sich an Gelerntes über Sessions hinweg, schützt, was sie anfassen, beweist in einem signierten Ledger, was sie sparen, und spult zurück, was sie gesehen haben. Reads werden über 26 Sprachen hinweg auf Struktur geparst und vom Rauschen befreit, sodass nur durchkommt, was bewusst, komprimiert und beweisbar ist. Du installierst es einmal. Alles andere ist automatisch.

Der Datenfluss

Wo sitzt LeanCTX?

LeanCTX sitzt auf zwei Pfaden. Auf dem Read-Pfad formt es, was hereinkommt — Datei-Reads, Code-Suche und Shell-Output, komprimiert, bevor der Agent sie überhaupt sieht. Auf dem Wire-Pfad sitzt ein optionaler lokaler Proxy zwischen Agent und Modell und komprimiert jeden ausgehenden Request — System-Prompt, vollständige History und Tool-Ergebnisse — mit Prompt-Cache-Sicherheit. Der eine kürzt, was in den Kontext gelangt; der andere kürzt jeden Request, den du bezahlst. Das Modell sieht dasselbe Signal in einem Bruchteil der Tokens.

Datenfluss: vorher vs. nachher

Ohne lean-ctx:

Du  →  KI-Tool  →  liest Datei  (voller Inhalt)  →  LLM verarbeitet alles

Mit lean-ctx:

Du  →  KI-Tool  →  lean-ctx komprimiert  →  nur Signal  →  LLM: 60–90% weniger Rauschen
                           ├─ PathJail-Sandbox + Size-Caps
                           ├─ AST-bewusste Kompression
                           ├─ Memory-Runtime (Wissen + Vergessen)
                           ├─ Session-Cache (Re-Read ≈ 13 tok)
                           └─ 10 Read-Modi pro Dateityp

Tief eintauchen: Shell-Patterns (95+ Patterns) · Read-Modi (10 Kompressionsmodi) · Caching

Du

Code wie gewohnt. Ändere nichts an deinem Workflow.

KI-Tool

Cursor, Claude Code, Copilot, Windsurf, …

LeanCTX

Entscheidet, komprimiert und erinnert via einen MCP-Server und Shell-Hook, die deine KI-Tools automatisch erkennen.

LLM

Sieht nur Signal. 60–90% weniger Tokens, gleiche Information.

Architektur

Eine Binary. Fünf Fähigkeiten.

Jede Fähigkeit läuft in einer einzigen Rust-Binary. So fließt eine Anfrage durch LeanCTX: von deinem KI-Tool, durch die kognitive Pipeline, zum Modell.

Dein KI-Tool Cursor · Claude Code · Copilot · Windsurf

MCP · CLI · HTTP

lean-ctx Cognitive Context Layer · Single Binary · 81 Tools

Verstehen

10 Read-Modi
Kontext-Sichtbarkeit
Token-Zählung
Intent-Erkennung

Komprimieren

Tree-sitter-AST (26 Sprachen)
95+ Shell-Patterns
CDC-Reorder (Rabin-Karp)
64 KB Budget, 500 ms Deadline

Erinnern

Session-Cache (zstd, in-memory)
13-Token-Re-Reads
Knowledge-Graph (SQLite)
Session-übergreifendes Gedächtnis

Verifizieren

PathJail-Sandbox
Isolation auf OS-Ebene
Shell-Allowlist (deny-by-default)
Vollständiger Audit-Trail

Verbinden

GitHub · GitLab · Jira · Linear
Postgres · REST · MCP Bridge
Hybride Suche (BM25 + semantisch)
Config-basierte Provider (TOML)

10Read-Modi

13Tokens pro Re-Read

18Sprachen (AST)

optimierter Kontext

LLM Weniger Lärm · Mehr Signal · Bessere Ergebnisse

Die fünf Subsysteme

Fünf Dinge, die LeanCTX mit jedem Token tut.

Zwischen deiner KI und deinem Code führt eine lokale Binary bei jedem Read, Command und jeder Suche dieselbe fünfstufige Schleife aus — wahrnehmen, komprimieren, erinnern, routen, steuern. Zusammen liefern sie die fünf Jobs: Sie entscheidet, was deine Agenten lesen, erinnert sich an Gelerntes, schützt, was sie anfassen, beweist, was sie sparen, und spult zurück, was sie gesehen haben.

Wahrnehmen

Sieh, was zählt, bevor du handelst.

Erfasse ein unbekanntes Repo, hebe die Dateien und Symbole hervor, die zählen, und lies Struktur statt ganzer Dateien — über 26 Sprachen hinweg mit Tree-sitter.

ctx_overview → repo mapped in one call

Komprimieren

Jedes Token trägt Signal.

Zehn Read-Modi, 95+ Shell-Output-Patterns und content-adressiertes Caching schrumpfen Reads um 60–90% und Re-Reads auf ~13 Tokens. Der Lärm erreicht das Modell nie.

ctx_read → 4,200 → 920 tokens (78% saved)

Erinnern

Kontinuität über Sessions hinweg.

Findings, Entscheidungen und berührte Dateien bleiben erhalten und werden automatisch in jede neue Session geladen — dein Agent erklärt Kontext nie neu und liest nie neu, was er bereits weiß.

ctx_session → restored · 0 re-reads

Routen

Der richtige Kontext zum richtigen Modell.

Erkenne die Absicht, wähle Read-Modus und Token-Budget und lade nur die Tools, die eine Aufgabe braucht — so sieht jedes Modell genau den Kontext, den es soll, und nicht mehr.

ctx_intent → right mode + budget per task

Steuern

Sicher, gemessen, durchgesetzt.

PathJail, eine Shell-Allowlist, Secret-Erkennung, Rollen-Policies und Token-Budgets halten jeden Tool-Call in den Grenzen — und Analytics beweisen exakt, was gespart wurde.

ctx_verify → paths ok · secrets blocked

Zwei Befehle. Das war's.

Was tust DU eigentlich?

Fast nichts. LeanCTX arbeitet nach einem einmaligen Setup unsichtbar. Du codest genau wie vorher weiter.

Installieren

Eine Rust-Binary. Keine Abhängigkeiten, keine Cloud, kein Account.

curl -fsSL https://leanctx.com/install.sh | sh

Setup

Erkennt deine Shell und KI-Tools automatisch. Konfiguriert alles in Sekunden.

lean-ctx setup

Fertig. Es läuft automatisch

Code wie gewohnt. Deine KI nutzt automatisch komprimierte Tools.

Gesparte Tokens: automatisch

Du vs. die Maschine

Was DU tust (einmal)	Was AUTOMATISCH passiert
lean-ctx setup	KI nutzt `ctx_read` statt Read — bis zu 99% weniger Tokens (gecachte Re-Reads)
	KI nutzt `ctx_shell` statt Shell — 60–90% weniger Tokens
	KI nutzt `ctx_search` statt Grep — 50–80% weniger Tokens
	Shell-Hook komprimiert CLI-Output transparent
	Session-Cache merkt sich Dateien über Reads hinweg (~13 Tokens für Re-Reads)
lean-ctx gain (optional)	Sieh dein Lifetime-Einsparungs-Dashboard

Vollständige Setup-Anleitung → Erste Schritte · Alle CLI-Befehle → CLI-Referenz

Sogar Vergessen ist eine Entscheidung.

Wenn der Session-Cache voll ist, entscheidet LeanCTX automatisch, was bleibt und was verdrängt wird. Es bewertet Einträge nach Aktualität, Häufigkeit und Größe und fusioniert diese Signale zu einem einzigen Score. Kein Tuning nötig.

Wie Caching funktioniert

Sicherheit

Schützt, worauf sie zugreifen.

LeanCTX setzt ein Defense-in-Depth-Sicherheitsmodell durch, damit LLM-Prompt-Injection nicht auf Dateien außerhalb des Projekts zugreifen kann:

[//]

PathJail — Alle Dateioperationen sind auf den Projekt-Root sandboxed. Symlink-Traversal, ../-Ausbrüche und absolute Pfade außerhalb des Jails werden am resolve_path-Chokepoint blockiert.

[##]

Shell-Allowlist + AST-Parsing — Wenn konfiguriert, wird jedes Segment zusammengesetzter Befehle (Pipes, Ketten) gegen die Allowlist validiert. Gefährliche Muster (eval, Backticks, $()) werden bedingungslos blockiert. Output bei 200 KB gekappt.

[]

Sicherer Dateizugriff — Datei-Reads lassen sich nicht austricksen, Symlinks aus deinem Projekt heraus zu folgen, und der lokale Proxy spricht ausschließlich mit deiner eigenen Maschine.

[ok]

Build-Integrität — Integritäts-Seed zur Compile-Zeit und Hash-Verifikation erkennen manipulierte Binaries. Automatisch geprüft via lean-ctx doctor.

Details zu Sicherheit & Vertrauen →

Willst du die Architektur verstehen?

Erkunde den Cognitive Context Layer: die sechsstufige Pipeline, Integrationsmodi, die Agent-Matrix, Context Field Theory und neun architektonische Säulen, die LeanCTX zum Laufen bringen.

Tief in die Architektur eintauchen

FAQ

So funktioniert es, beantwortet.

Was ist LeanCTX?

LeanCTX (kurz für Lean Context) ist der Open-Source-Context-Engineering-Layer für KI-Agenten. Eine lokale Rust-Binary entscheidet, was Agenten lesen, komprimiert, was sie senden, merkt sich, was sie lernen, schützt, was sie berühren, beweist, was sie sparen, und spult zurück, was sie gesehen haben — mit 60–90% Ersparnis pro Read als Beleg.

Schadet Kompression der Codequalität?

Nein. LeanCTX nutzt tree-sitter-AST-Parsing, um die Code-Struktur zu verstehen, und entfernt dann nur, was das LLM nicht braucht: redundante Whitespaces, Boilerplate-Imports und dekorative Kommentare. Im Schnitt bleiben 98% der AST-Struktur, 97% der Identifier und 96% der bedeutungstragenden Code-Zeilen erhalten. Du kannst das mit lean-ctx benchmark run verifizieren.

Wie installiere ich LeanCTX?

Installiere via cargo install lean-ctx oder curl -fsSL https://leanctx.com/install.sh | sh. Führe dann lean-ctx init für den Shell-Hook und lean-ctx setup aus, um deine KI-Tools zu verbinden. Null Konfiguration nötig.

Welche KI-Tools unterstützt LeanCTX?

LeanCTX funktioniert mit jedem großen KI-Coding-Tool: Cursor, GitHub Copilot, Claude Code, Windsurf, Cline, OpenAI Codex, Gemini CLI, Antigravity, Pi, Crush, Zed, Continue und OpenCode. Alle Tools profitieren sowohl vom Context Server als auch von der Shell-Hook-Kompression.

Loslegen

Sechzig Sekunden zu smarteren Agenten.

Eine Binary. Null Cloud-Abhängigkeiten. Apache-2.0. Deine nächste Session liest schlanker, und das Ledger hält den Beleg fest.

Loslegen Kompatibilität prüfen

Wie LeanCTX kontrolliert, wasdeine KI sieht.

Wo sitzt LeanCTX?

Du

KI-Tool

LeanCTX

LLM

Eine Binary. Fünf Fähigkeiten.

Fünf Dinge, die LeanCTX mit jedem Token tut.

Wahrnehmen

Komprimieren

Erinnern

Routen

Steuern

Was tust DU eigentlich?

Installieren

Setup

Fertig. Es läuft automatisch

Sogar Vergessen ist eine Entscheidung.

Schützt, worauf sie zugreifen.

Willst du die Architektur verstehen?

So funktioniert es, beantwortet.

Sechzig Sekunden zu smarteren Agenten.

Wie LeanCTX kontrolliert, was
deine KI sieht.