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

Comparación honesta

Ya tienes herramientas.
Aquí está la diferencia.

Las herramientas de compresión reducen lo que envías por el cable. LeanCTX también hace eso, pero además decide qué se lee en primer lugar, luego protege esa información, la recuerda y prueba su validez. Una mirada sencilla a lo que hace mejor, lo que hace igual y cuándo no lo necesitas en absoluto.

Lado a lado

Tu agente, con y sin.

El mismo agente, el mismo repositorio. La única variable es la capa entre ellos.

Feature	Sin Herramienta	Reglas Manuales	LeanCTX
Ahorro de Tokens	Ninguno	Bajo (reglas estáticas)	60–95% (caché: 99%)
Esfuerzo de Configuración	Ninguno	Manual por proyecto	Un comando
Soporte de Agentes	N/A	Solo un agente	29+ agentes
Caching	Ninguno	Ninguno	Automático + delta
Compresión de Shell	Ninguno	Ninguno	95+ patrones
Análisis de Código	Ninguno	Ninguno	AST Tree-sitter
Mantenimiento	Ninguno	Actualizaciones manuales	Automático
Seguridad y Gobernanza	Sin aplicación	ACL de archivos básico	Alineado con OWASP: PathJail, lista blanca de shell, redacción de secretos, ejecución de código en sandbox OS (ctx_execute), pista de auditoría
Compliance & Evidence	Screenshots	Recolección manual de evidencia	Paquete de Evidencia Firmada + leanctx-verify sin conexión, cobertura EU AI Act / ISO 42001 / SOC 2, CGB + cobertura de políticas
SDKs y Extensibilidad	Ninguno	Código pegamento personalizado	SDKs en Python + TypeScript (conformidad de 14 comprobaciones), /v1 OpenAPI + capacidades, gateway ctx_tools, extensiones WASM y de 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. Alternativas

Cómo se compara LeanCTX con Otras Herramientas

Una comparación característica por característica con RTK, Context+, MemGPT/Letta y Headroom, las alternativas más citadas. Basado en hechos, de su documentación pública.

Feature	RTK	Context+	MemGPT / Letta	Headroom	lean-ctx
Modos de lectura	Modo único	Filtrado básico	N/A (centrado en memoria)	Comprime después de la lectura	10 modos (auto, map, signatures, diff, entropy...)
Compresión de Shell	No	No	No	No	95+ patrones, auto-detectados
Memoria de sesión	Estado básico	Historial de conversación	Característica principal (memoria por niveles)	Almacén entre agentes con desduplicación	Episódica + procedimental + grafo de conocimiento
Multi-Agent	No	No	Limitado (enfoque en agente único)	Almacén compartido	Traspaso, sesiones compartidas, bus de contexto
Grafo de código / AST	Indexación básica	No	No	No	AST de Tree-sitter, 26 lenguajes, resolución de símbolos
Governance & Budgets	No	No	No	No	Presupuestos basados en roles, SLOs, pista de auditoría
Local-First / Privacy	Dependiente de la nube	Local	Basado en servidor	Paquete de Python + proxy	100% local, cero telemetría
Herramientas MCP	Limitado	Sin MCP	Sin MCP	Envuelve herramientas externas	81 herramientas MCP granulares
Security Hardening	None	None	Basic auth	None	Sandboxing, signed bundles, audit reports

Basado en documentación y código fuente disponibles públicamente hasta junio de 2026. RTK (github.com/rtk-ai/rtk), Context+ (github.com/ForLoopCodes/contextplus), MemGPT/Letta (arxiv.org/abs/2310.08560), Headroom (github.com/chopratejas/headroom). Todas las herramientas resuelven problemas reales. LeanCTX simplemente cubre más capas del problema de contexto en un único binario.

vs. capas de compresión

La compresión reduce lo que fue leído. La ingeniería de contexto decide qué se lee.

Herramientas como Headroom comprimen la solicitud en el cable. LeanCTX ya incluye esa capa: un proxy local opcional comprime cada solicitud, seguro para prompt-cache, y va una capa más profundo, en la fuente: decide qué se lee. Compatible con Headroom, pero normalmente no lo necesitas encima. Aquí está la diferencia honesta.

Dimension	Capa de compresión (ej. Headroom)	LeanCTX
Dónde reside	Ruta del mensaje: comprime lo que el agente ya leyó	En la fuente: decide qué y cómo leer (10 modos, enrutamiento de intención, relecturas en caché de ~13 tokens)
Memory	Almacén multiagente con desduplicación	Conocimiento persistente: grafo de propiedades, sesiones, traspasos, libro mayor de evidencia
Governance	—	PathJail, lista blanca de shell, redacción de secretos, presupuestos, detección de inyección
Prueba	Endpoint de estadísticas	Firmado con Ed25519, libro de contabilidad encadenado por hash + benchmark reproducible
Reversibilidad	Almacén de recuperación de referencias	También reversible: cada original permanece intacto `ctx_retrieve` lejos
Form	Paquete de Python + proxy	Un binario Rust, 30+ herramientas auto-detectadas, cero configuración

Nota: algunas tablas comparativas de terceros listan a lean-ctx como "Reversible: No"; esto es incorrecto. Cada lectura comprimida en LeanCTX se archiva localmente y se recupera mediante ctx_retrieve. La compresión es uno de los cinco subsistemas de LeanCTX. Incluso las dos herramientas pueden ejecutarse juntas; Headroom lista a lean-ctx como una herramienta de contexto compatible.

¿Por qué no simplemente…

Tu pila ya hace algo de esto. Esto es lo que no hace.

LeanCTX no reemplaza a grep ni a tu editor. Es la capa que decide qué merece la atención de tu IA.

¿Por qué no usar solo grep?

grep encuentra texto. LeanCTX encuentra los símbolos correctos, los clasifica por relevancia y devuelve contexto estructural presupuestado en lugar de 500 coincidencias sin procesar que aún tienes que leer y filtrar.

¿Por qué no leer los archivos directamente?

Una lectura bruta descarga 4.200 tokens cuando ~920 contienen la señal. LeanCTX mantiene la señal y elimina el ruido, y una nueva lectura en caché cuesta unos 13 tokens en lugar de todo el archivo de nuevo.

¿Por qué no compactar más a menudo?

La compactación desecha historial que aún podrías necesitar. Con LeanCTX nunca hay un callejón sin salida: cada original se archiva en disco y tu agente lo recupera bajo demanda. Nada se pierde silenciosamente.

¿Por qué no otro servidor MCP?

La mayoría de los servidores MCP añaden sobrecarga de definición de herramientas y devuelven resultados sin procesar. LeanCTX es una capa cognitiva de contexto completa: almacenamiento en caché, memoria persistente, hooks de shell y una capa de gobernanza, todo en un único binario local.

Mejor Ajuste

Cuando lean-ctx Destaca

LeanCTX ofrece el mayor valor en estos escenarios.

Bases de Código Grandes

Los proyectos con cientos o miles de archivos se benefician más. Cuanto más contexto hay que gestionar, mayores son los ahorros.

Flujos de Trabajo Multi-Agente

Cuando múltiples agentes de IA trabajan en el mismo proyecto, LeanCTX les proporciona un cerebro compartido: un contexto consistente y gobernado para cada agente.

Desarrollo Iterativo

Las largas sesiones de codificación con lecturas repetidas de archivos golpean la caché: las relecturas cuestan solo ~13 tokens en lugar de miles.

Transparencia

Cuando Tú No lo Necesitas

Creemos en herramientas honestas. LeanCTX está diseñado para proyectos con bases de código sustanciales, no para todo.

No Siempre Es Necesario

Scripts de archivo único o utilidades pequeñas
Proyectos con menos de 50 archivos
Prompts puntuales sin contexto de archivos

En estos casos, la sobrecarga de una capa de contexto no está justificada. LeanCTX brilla cuando tus proyectos crecen y la gestión del contexto se convierte en un cuello de botella.

FAQ

Comparativas, respondidas.

¿Cómo se compara LeanCTX con la ingeniería manual de prompts?

La ingeniería manual de prompts requiere crear a mano cada ventana de contexto. LeanCTX automatiza esto con 10 modos de lectura, compresión consciente del AST y memoria de sesión, ahorrando más del 88% de tokens sin esfuerzo manual.

¿Es LeanCTX mejor que otras herramientas de contexto MCP?

LeanCTX es una capa de contexto cognitiva completa en lugar de un servidor MCP simple: integración CLI, ganchos de shell, 81 herramientas MCP, memoria persistente, gráficos de inteligencia de código y una capa de gobernanza con roles y presupuestos.

¿Funciona LeanCTX con mi herramienta de codificación IA?

Sí. LeanCTX es compatible con más de 30 herramientas de IA, incluyendo Cursor, Claude Code, GitHub Copilot, Windsurf, Gemini CLI, Codex y JetBrains IDEs. Ejecuta lean-ctx setup para una configuración automática.

¿En qué se diferencia LeanCTX de las herramientas de compresión como Headroom?

Herramientas como Headroom comprimen la solicitud en el cable —la capa proxy. LeanCTX ya incluye esa capa: un proxy local opcional (lean-ctx proxy enable) comprime cada solicitud —prompt, historial y resultados de herramientas— seguro para prompt-cache, midiendo los dólares reales ahorrados, por lo que normalmente no necesitas un proxy de compresión de solicitudes separado encima. Y LeanCTX va una capa más profundo, en la fuente: decide qué se lee en primer lugar (10 modos de lectura, relecturas en caché de ~13 tokens), recuerda el conocimiento a través de sesiones, protege el acceso a archivos y shell, y firma cada guardado en un libro mayor verificable. La compresión —tanto a nivel de lectura como de cable— es uno de sus cinco subsistemas, y es totalmente reversible: cada original permanece accesible con un ctx_retrieve.

¿Es reversible la compresión de LeanCTX?

Sí. Cada lectura comprimida se archiva localmente y el original completo es recuperable bajo demanda a través de ctx_retrieve. Nada se pierde silenciosamente; incluso LeanCTX le indica a tu agente cuándo solicitar el contenido completo.

¿En qué se diferencia LeanCTX de la memoria del agente de proveedores como Claude en Slack o ClickUp Brain?

Esos hacen que tu IA proveedor recuerde a tu empresa — tú lo etiquetas, haces seguimiento en un hilo y construye memoria. Pero esa memoria vive en su caja negra: no puedes ver dónde está, moverla o cambiar el modelo debajo. Eso es un inicio de sesión de contexto, no un inicio de sesión de modelo: terminas alquilándote tu propio conocimiento empresarial. LeanCTX mantiene la ventaja de lado tuyo: las sesiones, un grafo de conocimiento y paquetes .ctxpkg portátiles permanecen locales e inspeccionables, agnósticos del modelo en OpenAI, Anthropic y Gemini. El mismo flujo de trabajo de agente-como-compañero; tú mantienes el contexto.

Empezar

Véalo en tu repositorio.

Instálalo en menos de un minuto, ejecuta una sesión y luego revisa el libro mayor. Tus números harán el argumento.

Empezar Seguridad y Confianza

Ya tienes herramientas.Aquí está la diferencia.