                                                                                                                                                                                                                
                                    ╭──────────────────────────────────────────╮                                                             ╭──────────────────────────────────────────╮                       
                                    │  >>>>>>>>>>>>>>>  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 — это контекстный слой для context engineering AI-агентов. Он формирует данные, которые они читают (код, оболочка, документы, 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 Что такое context engineering

Читает меньше. Помнит больше. Доказывает это.

Пять вещей меняются в момент, когда 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 + дельта-загрузка Функция и скелет типов, тела по требованию 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)

Интеллект кода

Пакеры, карты символов и графы кода попадают прямо внутрь ctx_expand и ctx_callgraph.

RepomixSerenaMCP Code Context

Память

Внешние хранилища памяти питают тот же ctx_knowledge, который уже читает ваш агент.

Context-MemMem0Cognee

Рассуждения и планы

Серверы планирования и рассуждений подключаются рядом с остальными вашими инструментами.

Sequential ThinkingLean-MarkDown (lean-md)

Просмотреть реестр аддонов

Что вы создаёте?

Как команды используют контекстное проектирование. Выберите своё.

AI-кодинговые агенты Перестаньте платить своему кодинговому агенту за повторное чтение вашего репозитория. Более 30 инструментов, обнаружено автоматически. Сокращает количество токенов на чтение на 60–90% Пользовательские боты Предоставьте вашему боту контекстную инженерию: компактный, извлекаемый и управляемый вывод инструментов. /v1 API · Python, TS, Rust SDKs Парсеры и краулеры Парсите сырые данные. Подавайте lean. Чистый, дедуплицированный контекст, готовый для модели, с любой страницы. HTML · PDF · RSS · YouTube intake Исследовательские агенты Агенты, которые перестают повторяться: постоянные находки, вывод с цитированием источников. EvidenceLedger · хранилище знаний Автоматизация рабочих процессов Каждый вызов инструмента становится вводом для модели. Нормализуйте его, управляйте им, аудируйте его. 95+ шаблонов оболочек · провайдеры Корпоративные платформы агентов Управляйте тем, что ваши агенты могут видеть, использовать и запоминать, с подписанным, готовым к аудиту доказательством. PathJail · пакеты доказательств · аудит FinOps и контроль затрат Превратите подписанную экономию в отчетность уровня финансов: стоимость на команду, агента, модель и инструмент. FOCUS · CloudZero · Vantage · /metrics

От соло-разработчиков до регулируемых флотов.

Разработчики

Соло-разработчики и инди-хакеры, которые хотят, чтобы их агент читал меньше, запоминал больше и переставал сжигать токены — на одной локальной бинарной сборке, бесплатно навсегда.

Локально · на 60–90% меньше токенов Посмотреть конструкторы

Teams

Инженерные команды, которым нужна общая, аудируемая плоскость контекста: согласованные чтения, общий пул памяти и бюджеты для каждой роли для каждого агента и IDE.

Общая память · бюджеты по ролям Посмотреть команды

Enterprise

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

SSO · пакеты политик · наборы доказательств Посмотреть корпоративные решения

04 Управление и безопасность

Контроль, доказательства и безопасность в одном слое.

Управляйте тем, что видят агенты. Доказывайте то, что они сохраняют.

Элементы управления и квитанции, которые на самом деле запрашивают аудиторы — встроены, а не добавлены позже.

Evidence Bundle v1

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

Покрытие соответствию

Отчеты по соответствию требованиям 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 hooks; встраивается в любой агент через версионированный 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, сохраняют сигнатуры и структуру, шаблоны оболочки сохраняют ошибки и результаты. Ничего не теряется. Каждая исходная информация остается локально доступной через 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.