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

Lean Context Engineering

Контролюйте те, що
ваш AI може бачити.

LeanCTX — це контекстний шар для AI agents: він формує те, що вони читають (код, shell, доки, PDF, веб) і те, що вони надсилають моделі (кожен запит: системний промпт, історію та вивід інструменту, стиснутий на лінії). Він вирішує, що вони читають, запам'ятовує те, чого вони навчаються, захищає те, до чого торкаються, і підписує доказ — щоб усе, що перетинає межу моделі, було навмисним, стисненим та доказовим.

На 60–90% менше токенів. І це лише чек.

Встановити безкоштовно Приєднатися до Discord Зірки на GitHub

Open source · Local-first · Deterministic · Provable · Zero telemetry · Один бінарний файл Rust · Понад 30 AI-інструментів

170,523 встановлення

3,105 зірки GitHub

2.1 MWh Збережена енергія

lean-ctx session

$ lean-ctx read src/lib/auth.ts -m map

→ exports: authenticate(), validateToken(), refreshSession()

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

→ cached: 13 tokens on re-read

$ lean-ctx grep "authenticate" src/

→ 3 matches in 0.8ms

→ auth.ts:14, middleware.ts:8, routes.ts:23

$ lean-ctx -c "cargo build --release"

→ Compiling LeanCTX in 3.2s

→ compressed: 847 → 42 tokens

→ savings ledger: signed ✓

Файл на 2000 токенів. Перечитано до 13.

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

60–90% менше токенів за читання

~13 токени при кешованому перечитанні

30+ AI-інструменти, автоматично виявлені

26 мови, розібрані через AST

01 Чому зараз

Ера агентів має проблему контексту.

2026

Кожен розробник використовує кодові агенти. Витрати токенів — одна з трійки найбільших інженерних витрат.

2027

Флотилії: 5–10 агентів на розробника (фонове виконання, CI, рев'ю), які спілкуються між собою.

2028+

Агенти в кожному відділі. Регульовані, аудитовані, бюджетування.

Більше контексту погіршує роботу моделей.

Дослідження «гнилизни контексту» показують падіння точності з 98% до 64%, коли вікно заповнюється шумом. Обріжте шум, і точність повернеться. Дешевше — це побічний ефект.

Кожен провайдер отримує плату за токен.

Шари, які мінімізують кількість токенів, не можуть бути створені людьми, які їх продають. Вони мають знаходитися на вашому боці. Цей — так.

Тепер вони хочуть вашу пам'ять.

Агенти-постачальники тепер запам'ятовують вашу компанію у чорній скриньці, яку ви не можете перемістити — контекстне логінування, а не логінування моделі. LeanCTX залишає ров вашим: портативна, локальна пам'ять, під якою ви можете замінити будь-яку модель. Володійте своїм контекстом; не орендуйте його назад.

Три гарантії, які постачальник не може створити.

Коли вікно заповнюється, нативні агенти тихо стискають або відкидають прочитане — ви помічаєте це лише тоді, коли відповідь тихо погіршується (Claude Code #42542). Хмарні прозори компрісатори надсилають ваш контекст до навченої моделі та повторно виставляють рахунок за переписування. lean-ctx — це протилежний шар: локальний, на основі правил та явний. Це змінює те, що він може обіцяти.

Детермінований та незалежний від моделі.

Вивід є чистою функцією контенту, режиму та завдання — ідентичний по байтах при кожному запуску та протестований CI (#498). Жодне оновлення моделі постачальника ніколи не перекласифікує ваші токени в тиші, і ніщо не зникає за вашою спиною. Ніщо також не прив'язано до одного провайдера: змінюйте OpenAI, Anthropic чи Gemini, не втрачаючи контексту чи кешу.

Зберігання кешу промптів.

Історія обрізається лише на заморожених межах, усвідомлених кешем, тому кеші промптів Anthropic та OpenAI продовжують спрацьовувати — ви платите дешеві ставки за попередньо кешований префікс замість переписування по повній ціні.

100% локально. Нульовий вихід даних.

Одна бінарна Rust-файлова одиниця на вашій машині. Код та промпти ніколи не досягають стороннього сервісу — єдина чесна відповідь, коли правило управління даними говорить, що ніщо не залишає будівлі.

І ви не обмінюєте контроль чи широту: один повзунок агресивності від 0 до 1 та захищені регіони, які ви позначаєте як заборонені, дають таке ж відчуття нульової конфігурації, як хмарний шлюз — без хмари. Компресатори лише для оболонки зупиняються в терміналі; lean-ctx керує кожним читанням, пошуком, пам'яттю та викликом інструменту, і підписує доказ.

Прочитайте повний тез тазбек

02 Що означає контекстне інжиніринг

Читає менше. Запам'ятовує більше. Доводить це.

Пять вещей меняются в момент, когда LeanCTX становится вашим контекстным слоем context engineering.

Без LeanCTX ваш агент… З LeanCTX… Підсумок

читає все читає те, що важливо На 60–90% менше за читання

забуває все пам'ятає між сесіями Повторне читання коштує ~13 токенів

торкається чогось доторкається лише дозволеного PathJail · редакція · бюджети

нічого не доводить доводить кожну економію журнал, підписаний Ed25519

невозможно повторно просмотреть то, что было видно воспроизводит любое прошлое состояние подписанные снимки, привязанные к git

Компресія зменшує контекст. Context engineering робить його правильним. П'ять підсистем виконують роботу; компресія — одна з них.

Подивитися архітектуру

Подивіться, як це працює.

Один і той самий файл. Три інтенти. Три різні перегляди: дослідження отримує мапу, робота з API — сигнатури, редагування — повний код. Ви не обираєте режим — LeanCTX робить це за вас.

src/lib/auth.ts

import { verify, sign } from 'jsonwebtoken';
import { Redis } from 'ioredis';

const redis = new Redis(process.env.REDIS_URL);
const JWT_SECRET = process.env.JWT_SECRET!;

export async function authenticate(token: string) {
  const payload = verify(token, JWT_SECRET);
  const session = await redis.get(`session:${payload.sub}`);
  if (!session) throw new Error('Session expired');
  return JSON.parse(session);
}

export function refreshSession(userId: string) {
  return sign({ sub: userId }, JWT_SECRET, { expiresIn: '1h' });
}

→

lean-ctx map режим

вихід ctx_read

exports: authenticate(token), refreshSession(userId)
deps: jsonwebtoken, ioredis
types: string → Promise<object>, string → string
lines: 17  size: 4,200 → 180 tokens
cached: 13 tokens on re-read

fn authenticate(token: string): Promise<object>
fn refreshSession(userId: string): string

4,200 → 95 tokens
cached: 13 tokens

exports: authenticate(token), refreshSession(userId)
deps: jsonwebtoken (verify, sign), ioredis (Redis)
pattern: JWT auth + Redis sessions
4,200 → 150 tokens
cached: 13 tokens

Як накопичуються заощадження

Перестаньте годувати своїх агентів шумом.

Код, вивід оболонки, результати пошуку, веб-сторінки, документи: все, що отримують ваші агенти, LeanCTX перетворює на компактний контекст, готовий для моделі. Кожен тип має власну стратегію.

Що робить ваш AI Що робить LeanCTX Що потрапляє до моделі Типова економія

Прочитаний вихідний файл Підписи AST + delta-завантаження Скелет функції та типу, тіла за запитом 75–90%

Кешоване повторне читання Повертає кешований дельта, а не файл ~13 токенів, незалежно від розміру файлу ~95%

Вивід оболонки 95+ модулів за шаблоном (git, cargo, npm, docker…) Статус + рядки, які мають значення 70–90%

Пошук коду BM25 + щільне ранжування, дедупліковано Топ-хіти з точними розташуваннями 60–85%

Сканування каталогу Структурна карта з обмеженням глибини Дерево, без зайвого шуму 50–80%

Відповідь API Виділення полів із розумінням схеми Корисні поля, а не суп з даних 60–90%

Просканована сторінка Прибрано шаблонний текст та дублікати Чистий контент, готовий для моделі 70–95%

PDF та документи Витягнуто у факти та цитати Основні дані з посиланнями на джерела 80–95%

Ніколи не тупик. Кожен оригінал залишається локально доступним, лише за допомогою ctx_retrieve. LeanCTX повідомляє вашій AI агенту, коли саме запитувати його.

Ознайомтеся з усіма десятьма режимами читання

Clean code, a lower AI bill

LeanCTX compresses how code reaches the model — the Code Health Engine attacks the other half of the bill: the intrinsic cost of the code itself. Complex, cryptically named, tightly coupled code makes an agent load more context, take more turns and re-read more often, and you pay for that confusion in tokens on every turn that touches it. It rolls up into a navigability score (0–100) and the estimated USD token tax of your hotspots.

Cognitive complexity

SonarSource's S3776, not cyclomatic count — it penalises deep nesting and tangled control flow an agent has to hold in its head, and rewards code that reads top to bottom.

Naming quality

Cryptic, single-letter or meaningless identifiers that force an agent to re-read the surrounding code just to infer what something is.

Module coupling

Afferent / efferent coupling and instability — how entangled a file is with the rest of the repo, which widens the blast radius (and the context) of any change.

Explore the Code Health Engine

03 Universal

Створено для кожного агента. Включно з вашим.

30+ AI інструментів

Cursor, Claude Code, Codex, Copilot, Windsurf, Cline та інші. Автовиявлення, нульова конфігурація для кожного інструменту.

Будь-яка мова

Вбудуйте його у власного агента через lean-ctx serve: версіований API /v1 з SDK для Python, TypeScript та Rust.

Будь-яка сфера застосування

Персони контексту перетворюють шар для кодування, досліджень, підтримки чи аналізу даних. Або визначте власні.

Будь-які дані

Універсальний ввід: код, HTML, PDF, CSV, email, RSS та навіть транскрипції YouTube, стиснуті у факти та цитати.

IDE & Editor

Cursor CLI-Redirect

VS Code MCP

Windsurf MCP

JetBrains MCP

Zed MCP

Sublime Text MCP

Emacs MCP

Neovim MCP

Continue MCP

Trae MCP

CLI Agent

Claude Code CLI-Redirect

GitHub Copilot MCP

Codex CLI CLI-Redirect

Gemini CLI CLI-Redirect

Cline MCP

Roo Code MCP

OpenCode MCP

CodeBuddy MCP

OpenClaw MCP

Augment MCP

Aider Shell Hook

Amp Shell Hook

Platform

Amazon Q MCP

AWS Kiro MCP

Antigravity MCP

Pi MCP

Qwen Code MCP

Verdent MCP

Hermes MCP

Crush MCP

Qoder MCP

QoderWork MCP

Додайте свої інструменти вже використовуєте.

Аддон — це будь-який MCP інструмент, обгорнутий у мінімальний маніфест. lean-ctx запускає його через один шлюз і обробляє його вивід так, ніби це ваш власний код: стиснений, пошуковий, в тих самих ctx_ інструментах. Одна команда для додавання. Не потрібно форкувати чи перекомпілювати.

Стиснення

Підключіть ще один компресор. Те, що він повертає, зливається в той самий бюджет токенів, як і все інше.

HeadroomSophonRTK (Rust Token Killer)

Кодовий інтелект

Packers, symbol maps та code-graphs потрапляють прямо всередину ctx_expand та ctx_callgraph.

RepomixSerenaMCP Code Context

Пам'ять

Зовнішні сховища пам'яті живлять те саме ctx_knowledge, яке вже читає ваш агент.

Context-MemMem0Cognee

Роздуми та плани

Сервери планування та роздумів підключаються поруч з рештою ваших інструментів.

Sequential ThinkingLean-MarkDown (lean-md)

Переглянути реєстр аддонів

Що ви створюєте?

Як команди використовують контекстне проєктування. Виберіть своє.

AI-кодингові агенти Припиніть платити вашому кодинговому агенту за повторне читання вашого репозиторію. 30+ інструментів, автоматично виявлено. На 60–90% менше токенів на читання Кастомні боти Надайте вашому боту контекстне проєктування: компактний, відновлюваний, керований вивід інструментів. SDK для Python, TS, Rust Скрейпери та краулери Збирайте сирі дані. Живіть lean-ctx. Чистий, дедуплікований контекст, готовий для моделі, з будь-якої сторінки. HTML · PDF · RSS · YouTube для збору даних Дослідницькі агенти Агенти, які перестають повторювати себе: постійні висновки, вивід з посиланнями на джерела. EvidenceLedger · сховище знань Автоматизація робочих процесів Кожен виклик інструменту стає входом для моделі. Нормалізуйте його, керуйте ним, аудитуйте його. 95+ шаблонів оболонки · провайдери Корпоративні платформи агентів Керуйте тим, що ваші агенти можуть бачити, використовувати та пам'ятати, за допомогою підписаних, готових до аудиту доказів. PathJail · пучки доказів · аудит FinOps та контроль витрат Перетворіть підтверджену економію на показники рівня фінансів: вартість за команду, агента, модель та інструмент. FOCUS · CloudZero · Vantage · /metrics

Від незалежних розробників до регульованих флотилій.

Розробники

Незалежні розробники та інди-хакери, які хочуть, щоб їхній агент читав менше, запам'ятовував більше і припиняв витрачати токени — на одній локальній бінарній одиниці, безкоштовно завжди.

Локально · на 60–90% менше токенів Досліди Builders

Teams

Інженерні команди, яким потрібна спільна, аудитована контекстна рівень: узгоджені читання, об'єднана пам'ять та бюджети за ролями для кожного агента та IDE.

Спільна пам'ять · бюджети за ролями Досліди Teams

Enterprise

Керівники безпеки та платформи, які повинні довести, що до яких агентів було звернено: SSO, політики флоту, підписані докази та за замовчуванням локально-перший доступ у відключеному режимі.

SSO · пакети політик · набори доказів Досліди Enterprise

04 Управління та безпека

Контроль, доказ та безпека в одному шарі.

Керуйте тим, що бачать агенти. Доводьте те, що вони зберігають.

Контролі та підтвердження, які насправді вимагають аудитори — вбудовані, а не додані.

Evidence Bundle v1

Підписаний, офлайн-перевірений запис усього, що прочитав, виконав і змінив кожен агент — перевіряється за допомогою leanctx-verify.

Покриття відповідності

Зві reportи для відповідності EU AI Act, ISO 42001 та SOC 2 контролям.

Паки контекстних політик

Декларативні правила щодо того, що агенти можуть читати, виконувати та запам'ятовувати — застосовуються до всередини.

Реєстр агентів та журнал аудиту

Кожен агент є ідентичністю першого класу; кожне рішення потрапляє в корпоративний слід.

Compliance & frameworks Context Governance Benchmark Open Context Protocol Agent governance

Локально за замовчуванням. Доведено за задумом.

Кожне читання та кожна команда проходять через контекстний шар інженерії перед тим, як торкнутися вашої машини — або моделі.

Локально в першу чергу, нульова телеметрія

Усе працює на вашій машині. За замовчуванням ніщо не надсилається нікуди.

PathJail

Доступ до файлів обмежений шляхами, які ви дозволяєте — ніщо не виходить із песочниці.

Список дозволених команд оболонки

Небезпечні команди блокуються ще до того, як вони виконаються.

Захист від секретів та ін'єкцій

Секрети та спроби ін'єкції промптів перехоплюються до того, як досягнуть моделі.

Прочитайте модель безпеки

05 Benchmark

Ті самі моделі. Дрібчастина токенів

Виміряно на реальних операціях репозиторіїв, відтворювано кінцевий результат. Не довіряйте нашим цифрам: запустіть звіт бенчмарку lean-ctx . на вашому власному репо.

Режими стиснення: токени проти інформації

Звідки економія

Вихідний файл → режим мапингів -75%

3,000 tok

750 tok

Вихідний файл → авторежим -82%

3,000 tok

540 tok

Shell: git diff -75%

2,000 tok

500 tok

Shell: cargo test -88%

2,500 tok

300 tok

Типова сесія: ~10,500 → ~2,090 токенів Збережено 80%

Доказова економія.

Кожна заощадження потрапляє в журнал, підписаний Ed25519 та ланцюжкований за хешем на вашій машині. Експортуйте його для свого фінансового директора або перевірте насправді.

Як працює журнал

Переглянути повний бенчмарк та методологію

06 FAQ

Питання, на які ми знайшли відповіді.

Визначення в одному абзаці

LeanCTX (сокращение от Lean Context) — это open-source контекстный слой для context engineering AI агентов. Один локальный Rust бинарник решает, что читают агенты (10 режимов чтения, на 60–90% меньше токенов, ~13-токеновый кэшированный повторный проход), запоминает, что они узнали (постоянные сессии, граф знаний), защищает от доступа (PathJail, маскирование секретов, бюджеты, обнаружение инъекций), доказывает, что сохранили (реестр с подписью Ed25519, воспроизводимый бенчмарк) и воспроизводит то, что видели (git-привязанные, подписанные контекстные снимки, которые можно восстановить или которыми поделиться); опциональный локальный прокси сжимает то, что они отправляют — системный промпт, историю и вывод инструментов каждого запроса, безопасный для кэша промптов по сети. Сжатие — на стороне чтения и по сети — является одной из пяти подсистем, и каждый оригинал остается локально доступным. Работает с более чем 30 AI кодинговыми инструментами через MCP и shell-хуки; встраивается в любой агент через версионированный API /v1 с SDK для Python, TypeScript и Rust. Локальное использование бесплатно навсегда, что обеспечивается CI.

Читати повну історію

Що таке LeanCTX?

LeanCTX (скорочення від Lean Context) — це open-source контекстний рівень для AI-агентів. Один локальний Rust бінарник визначає, що ваші агенти читають і стискає те, що вони надсилають, запам'ятовує те, що вони вивчають, захищає те, до чого торкаються, і підтверджує те, що зберігає в підписаному реєстрі. Він працює з понад 30 AI-інструментами для кодування (Cursor, Claude Code, OpenAI Codex, GitHub Copilot та будь-яким клієнтом із підтримкою MCP) і інтегрується в будь-якого агента через API версії /v1.

Чи погіршує стиснення контексту якість відповідей?

Ні. Зазвичай воно її покращує. Дослідження «контекстної деградації» показують, що точність моделі падає з 98% до 64%, коли вікна заповнюються шумом. LeanCTX усуває надлишковість, зберігаючи при цьому зміст: AST-aware мапи зберігають сигнатури та структуру, шаблони оболонки — помилки та результати. Ніщо не втрачається. Кожне оригінальне значення залишається локально доступним через ctx_retrieve.

Як його встановити?

Одна команда, потім одна настройка. Встановіть за допомогою скрипта, Homebrew, npm або cargo і запустіть `lean-ctx setup`. LeanCTX автоматично виявляє ваші редактори та підключає правильні гачки й MCP-сервер для кожного з них. Оновлення — це просто `lean-ctx update`.

Чи надсилається якийсь мій код чи дані на сервер?

Ні. Стиснення, кешування, журнал збережень та пам'ять проєкту працюють локально на вашій машині; нічого не завантажується. Єдині мережеві функції (картка спільного доступу Wrapped та публічний рейтинг) є суворо опціональними і публікують лише анонімний, дозволений агрегат: кількість токенів та ім'я користувача, яке ви обираєте.

З якими AI-інструментами він працює?

Понад 30 і зростає: Cursor, Claude Code, OpenAI Codex, GitHub Copilot, Zed, Windsurf, Cline, Roo Code, Gemini CLI, OpenCode, JetBrains IDEs та будь-який клієнт із підтримкою MCP. Запустіть lean-ctx setup один раз, і кожен встановлений інструмент буде автоматично виявлено та налаштовано.

Що означає LeanCTX?

Lean Context. Назва описує завдання: чистий, точний контекст для AI-агентів замість сивго, шумного вводу. LeanCTX — це бренд та назва проєкту; lean-ctx — бінарний файл, пакет і команда CLI. (Не «Lean Cortex», орфографічна помилка, яка з'явилася у ранніх оглядах.)

Чим LeanCTX відрізняється від інструментів стиснення, таких як Headroom?

Інструменти, такі як Headroom, стискають запит на лінії — проксі-шар. LeanCTX вже надає цей шар: необов'язковий локальний проксі (lean-ctx proxy enable) знаходиться між вашим агентом та моделлю і стискає кожен запит — системний промпт, історію та результати інструментів — перед відправкою, безпечний для кешу промптів, вимірюючи реальні заощадження доларів. Тому зазвичай вам не потрібен окремий проксі-сервер стиснення запитів зверху. І LeanCTX йде на рівень глибше, до джерела: він вирішує, що читати взагалі (10 режимів читання, кешовані повторні читання ~13 токенів), пам'ятає між сесіями, захищає доступ до файлів та оболонки і підписує кожну збережену інформацію у перевірюваному реєстрі. Стиснення — з боку читання та з боку лінії — є однією з його п'яти підсистем, і воно повністю зворотне: кожен оригінал залишається доступним за допомогою одного ctx_retrieve.

Поверніть контроль над своїм контекстом.

Почніть зі збереження токенів. Залишайтеся, бо все, що ваші агенти вивчають, торкаються та зберігають, нарешті під вашим контролем. Безкоштовно для локального використання, назавжди. CI-ворота гарантують, що так і залишиться.

Встановити безкоштовно Переглянути плани

Контролюйте те, щоваш AI може бачити.