                                                                                                                                                                                                                
                                    ╭──────────────────────────────────────────╮                                                             ╭──────────────────────────────────────────╮                       
                                    │  >>>>>>>>>>>>>>>  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 एजेंट्स के लिए context engineering layer है — यह आकार देता है कि वे क्या पढ़ते हैं (कोड, शेल, डॉक्स, PDFs, वेब) और मॉडल को क्या भेजते हैं (हर अनुरोध: सिस्टम प्रॉम्प्ट, हिस्ट्री और टूल आउटपुट, वायर पर कंप्रेस्ड)। यह तय करता है कि वे क्या पढ़ते हैं, जो वे सीखते हैं उसे याद रखता है, जो वे छूते हैं उसकी रक्षा करता है, और प्रमाण पर हस्ताक्षर करता है — ताकि मॉडल सीमा को पार करने वाली हर चीज़ जानबूझकर, संपीड़ित (compressed), और सिद्ध की जा सके।

60–90% कम टोकन। और यह सिर्फ रसीद है।

मुफ्त में इंस्टॉल करें डिस्कॉर्ड में शामिल हों GitHub पर स्टार करें

ओपन सोर्स · लोकल-फर्स्ट · डिटरमिनिस्टिक · प्रूवएबल · जीरो टेलीमेट्री · एक 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 ✓

2,000-टोकन वाली फ़ाइल। 13 के लिए फिर से पढ़ें।

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

60–90% रीड प्रति कम टोकन

~13 कैश्ड री-रीड प्रति टोकन

30+ AI उपकरण, स्वचालित रूप से पता लगाए गए

26 AST के माध्यम से पार्स की गई भाषाएँ

01 अब क्यों

एजेंटिक युग में एक context समस्या है।

2026

हर डेवलपर कोडिंग एजेंट चलाता है। टोकन खर्च शीर्ष-3 इंजीनियरिंग लागतों में से एक है।

2027

फ्लीट्स: प्रति डेवलपर 5–10 एजेंट (बैकग्राउंड, CI, समीक्षा) आपस में बात कर रहे हैं।

2028+

हर विभाग में एजेंट। विनियमित, ऑडिट किया गया, बजट बनाया गया।

अधिक संदर्भ मॉडल को खराब बनाता है।

Context-rot रिसर्च दिखाता है कि जैसे ही शोर विंडो भरता है तो सटीकता 98% से गिरकर 64% हो जाती है। शोर कम करें और सटीकता वापस बढ़ जाएगी। सस्ता होना एक दुष्प्रभाव है।

हर प्रदाता प्रति टोकन कमाता है।

वह लेयर जो टोकन को न्यूनतम करती है, वह उन लोगों से नहीं आ सकती जो उन्हें बेचते हैं। इसे आपकी तरफ बैठना होगा। यह ऐसा करता है।

अब वे आपकी मेमोरी चाहते हैं।

विक्रेता एजेंट अब एक ब्लैक बॉक्स में आपकी कंपनी को याद करते हैं जिसे आप नहीं हिला सकते — यह एक संदर्भ लॉगिन है, न कि एक मॉडल लॉगिन। LeanCTX खाई आपके पास रखता है: पोर्टेबल, स्थानीय मेमोरी जिसे आप किसी भी मॉडल के नीचे बदल सकते हैं। अपने संदर्भ का स्वामित्व रखें; इसे किराए पर न लें।

तीन गारंटी जो देता है विक्रेता ऐसा नहीं कर सकता।

जब विंडो भर जाती है, तो नेटिव एजेंट चुपचाप जो पढ़ते हैं उसे कॉम्पैक्ट या ड्रॉप करते हैं — आप तभी नोटिस करते हैं जब जवाब धीरे-धीरे खराब होता है (Claude Code #42542)। क्लाउड प्रोज़ कंप्रेसर आपके संदर्भ को एक प्रशिक्षित मॉडल पर भेजते हैं और रीराइट का बिल फिर से बनाते हैं। lean-ctx इसके विपरीत लेयर है: स्थानीय, नियम-आधारित और स्पष्ट। यह बदल देता है कि यह क्या वादा कर सकता है।

नियतात्मक और मॉडल-अज्ञेयवादी।

आउटपुट सामग्री, मोड और कार्य का एक शुद्ध फ़ंक्शन है — हर रन पर बाइट-समान और CI-परीक्षणित (#498)। कोई विक्रेता मॉडल अपडेट कभी भी चुपचाप आपके टोकन को पुनर्वर्गीकृत नहीं करता है, और कुछ भी आपकी पीठ पीछे नहीं गिराया जाता है। यह किसी एक प्रदाता से बंधा हुआ भी नहीं है: संदर्भ या कैश खोए बिना OpenAI, Anthropic या Gemini बदलें।

Prompt-cache संरक्षित।

इतिहास केवल फ्रीज किए गए, कैश-जागर सीमाओं पर छँटा (pruned) जाता है, इसलिए Anthropic और OpenAI प्रॉम्प्ट कैश हिट होते रहते हैं — आप पूरे-मूल्य के रीराइट के बजाय सस्ते कैश-प्रीफ़िक्स दरों का भुगतान करते हैं।

100% स्थानीय। शून्य egress।

आपकी मशीन पर एक Rust बाइनरी। कोड और प्रॉम्प्ट कभी भी किसी तीसरे पक्ष की सेवा तक नहीं पहुँचते — एकमात्र ईमानदार जवाब जब आपका डेटा-शासन नियम कहता है कि इमारत से कुछ बाहर नहीं जाता।

और आप नियंत्रण या चौड़ाई का व्यापार नहीं करते हैं: एक एकल 0–1 आक्रामकता डायल और संरक्षित क्षेत्र जिन्हें आप ऑफ-लिमिट्स के रूप में चिह्नित करते हैं, क्लाउड गेटवे जितना ही शून्य-कॉन्फ़िगर महसूस कराते हैं — बिना क्लाउड के। शेल-केवल कंप्रेसर टर्मिनल पर रुक जाते हैं; lean-ctx हर रीड, सर्च, मेमोरी और टूल कॉल को नियंत्रित करता है, और प्रमाण पर हस्ताक्षर करता है।

पूरा थीसिस पढ़ें

02 context engineering का क्या मतलब है

कम पढ़ता है। ज़्यादा याद रखता है। इसे साबित करता है।

पाँच चीज़ें बदल जाती हैं जिस पल LeanCTX आपका context engineering layer बन जाता है।

LeanCTX के बिना, आपका एजेंट… LeanCTX के साथ… रसीद

सब कुछ पढ़ता है जो मायने रखता है वह पढ़ता है हर रीड में 60–90% कम

सब कुछ भूल जाता है सेशन के पार याद रखता है री-रीड की लागत ~13 टोकन

कुछ भी नहीं छूता केवल अनुमत चीज़ों को छूता है PathJail · redaction · बजट

कुछ भी साबित नहीं करता हर बचत को साबित करता है Ed25519-signed ledger

जो देखा उसे दोबारा नहीं देख सकता किसी भी पिछले स्टेट को फिर से चलाता है git-anchored, signed snapshots

कंप्रेशन संदर्भ को छोटा बनाता है। 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 उसे कॉम्पैक्ट, मॉडल-तैयार context में बदल देता है। हर प्रकार को अपनी रणनीति मिलती है।

आपका AI क्या करता है LeanCTX क्या करता है मॉडल तक क्या पहुँचता है सामान्य बचत

स्रोत फ़ाइल पढ़ना AST सिग्नेचर + डेल्टा-लोडिंग फ़ंक्शन और प्रकार का कंकाल, आवश्यकतानुसार बॉडीज़ 75–90%

कैश्ड री-रीड फ़ाइल नहीं, कैश्ड डेल्टा लौटाता है ~13 टोकन, फ़ाइल आकार की परवाह किए बिना ~95%

शेल आउटपुट 95+ पैटर्न मॉड्यूल (git, cargo, npm, docker…等) स्थिति + वे लाइनें जो मायने रखती हैं 70–90%

कोड खोज BM25 + सघन रैंकिंग, डीडुपलिकेटेड सटीक स्थानों के साथ शीर्ष हिट्स 60–85%

डायरेक्टरी स्कैन गहराई-सीमित संरचनात्मक मानचित्र अव्यवस्था के बिना, पेड़ 50–80%

API प्रतिक्रिया स्कीमा-जागर फील्ड एक्सट्रैक्शन उपयोगी फ़ील्ड, न कि पेलोड सूप 60–90%

स्क्रैप किया गया पेज बोलेरप्लेट हटा दिया गया, डीडुप्लीकेटेड साफ़, मॉडल-तैयार कंटेंट 70–95%

PDFs और डॉक्स फैक्ट्स और कोट्स में निकाला गया साइटेशन-समर्थित ज़रूरी जानकारी 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 के माध्यम से अपने स्वयं के एजेंट में एम्बेड करें: Python, TypeScript और Rust SDKs के साथ एक संस्करणित /v1 API।

कोई भी डोमेन

Context personas कोडिंग, रिसर्च, सपोर्ट या डेटा विश्लेषण के लिए लेयर को आकार देते हैं। या अपना परिभाषित करें।

कोई भी डेटा

सार्वभौमिक इनटेक: कोड, HTML, PDF, CSV, ईमेल, 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)

ऐडऑन रजिस्ट्री ब्राउज़ करें

आप क्या बना रहे हैं ?

टीमों द्वारा context engineering का उपयोग कैसे किया जाता है। अपना चुनें।

AI कोडिंग एजेंट अपने कोडिंग एजेंट से अपने रेपो को दोबारा पढ़ने के लिए पैसे देना बंद करें। 30+ उपकरण, ऑटो-डिटेक्टेड। पढ़ने पर 60–90% कम टोकन कस्टम बॉट अपने बॉट को context engineering दें: कॉम्पैक्ट, रिट्रीवएबल, गवर्नड टूल आउटपुट। /v1 API · Python, TS, Rust SDKs स्क्रैपर और क्रॉलर कच्चा स्क्रैप करें। lean को फीड करें। किसी भी पेज से साफ़, डी-डुप्लीकेटेड, मॉडल-रेडी context। HTML · PDF · RSS · YouTube इनटेक रिसर्च एजेंट एजेंट जो दोहराना बंद कर दें: स्थायी निष्कर्ष, उद्धरण-समर्थित आउटपुट। EvidenceLedger · knowledge store वर्कफ़्लो ऑटोमेशन हर टूल कॉल मॉडल इनपुट बन जाता है। इसे सामान्य करें, नियंत्रित करें, ऑडिट करें। 95+ shell patterns · providers एंटरप्राइज एजेंट प्लेटफॉर्म गवर्न करें कि आपके एजेंट्स क्या देख सकते हैं, उपयोग कर सकते हैं और याद रख सकते हैं, साइन किए गए, ऑडिट-तैयार प्रूफ के साथ। PathJail · साक्ष्य बंडल · ऑडिट FinOps और लागत नियंत्रण साइन की गई बचत को फाइनेंस-ग्रेड शोबैक में बदलें: प्रति टीम, एजेंट, मॉडल और टूल की लागत। FOCUS · CloudZero · Vantage · /metrics

सोलो बिल्डरों से लेकर विनियमित बेड़े (regulated fleets) तक।

बिल्डर

सोलो डेवलपर्स और इंडी हैकर्स जो चाहते हैं कि उनका एजेंट कम पढ़े, अधिक याद रखे, और टोकन जलाना बंद कर दे — एक स्थानीय बाइनरी पर, हमेशा के लिए मुफ्त।

लोकल-फ्री · {count} कम टोकन बिल्डर्स एक्सप्लोर करें

Teams

इंजीनियरिंग टीमें जिन्हें एक साझा, ऑडिट किया गया context plane चाहिए: हर एजेंट और IDE में सुसंगत रीड्स, पूल की गई मेमोरी, और प्रति-भूमिका बजट।

साझा मेमोरी · प्रति-भूमिका बजट टीमों को एक्सप्लोर करें

Enterprise

सुरक्षा और प्लेटफॉर्म लीडर्स जिन्हें यह साबित करना होता है कि एजेंट ने क्या छुआ: SSO, फ़्लीट नीतियाँ, हस्ताक्षरित साक्ष्य, और डिफ़ॉल्ट रूप से एयर-गैप्ड, लोकल-फर्स्ट।

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 benchmark report . चलाएं।

कम्प्रेशन मोड: टोकन बनाम जानकारी

बचत कहाँ से होती है

सोर्स फ़ाइल → मैप मोड -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-signed, hash-chained ledger में दर्ज होती है। इसे अपने CFO के लिए निर्यात करें, या हमारे खिलाफ सत्यापित करें।

लेजर कैसे काम करता है

पूरा बेंचमार्क और कार्यप्रणाली देखें

06 FAQ

प्रश्न, उत्तर दिए गए।

एक पैराग्राफ परिभाषा

LeanCTX (Lean Context का संक्षिप्त रूप) AI agents के लिए ओपन-सोर्स context engineering layer है। एक स्थानीय Rust बाइनरी यह तय करती है कि एजेंट्स क्या पढ़ते हैं (10 रीड मोड, 60–90% कम टोकन, ~13-टोकन कैश किए गए री-रीड्स), वे क्या सीखते हैं उसे याद रखती है (स्थायी सत्र, नॉलेज ग्राफ), वे क्या छूते हैं उसकी रक्षा करती है (PathJail, सीक्रेट रेडैक्शन, बजट, इंजेक्शन डिटेक्शन), वे क्या बचाते हैं उसका प्रमाण देती है (Ed25519-signed ledger, reproducible benchmark) और जो उन्होंने देखा उसे फिर से चलाती है (git-anchored, signed context snapshots जिन्हें आप पुनर्स्थापित या साझा कर सकते हैं); एक वैकल्पिक स्थानीय प्रॉक्सी उनके द्वारा भेजे गए डेटा को संपीड़ित करता है — हर अनुरोध का सिस्टम प्रॉम्प्ट, इतिहास और टूल आउटपुट, वायर पर prompt-cache-safe। कम्प्रेशन — रीड-साइड और वायर-साइड — पाँच उपप्रणालियों में से एक है, और हर मूल डेटा स्थानीय रूप से पुनर्प्राप्त करने योग्य रहता है। MCP और शेल हुक्स के माध्यम से 30+ AI कोडिंग टूल्स के साथ काम करता है; Python, TypeScript और Rust SDKs के साथ एक वर्ज़न किए गए /v1 API के माध्यम से किसी भी एजेंट में एम्बेड होता है। स्थानीय उपयोग हमेशा के लिए मुफ्त है, जो CI द्वारा लागू किया जाता है।

पूरी कहानी पढ़ें

LeanCTX क्या है?

LeanCTX (Lean Context का संक्षिप्त रूप) AI एजेंट्स के लिए ओपन-सोर्स context engineering layer है। एक लोकल Rust बाइनरी यह तय करती है कि आपके एजेंट्स क्या पढ़ते हैं और वे जो भेजते हैं उसे कंप्रेस करती है, वे जो सीखते हैं उसे याद रखती है, वे जो छूते हैं उसकी सुरक्षा करती है, और signed ledger में वे जो सेव करते हैं उसका प्रमाण देती है। यह 30+ AI कोडिंग टूल्स (Cursor, Claude Code, OpenAI Codex, GitHub Copilot और कोई भी MCP-capable client) के साथ काम करता है और एक versioned /v1 API के माध्यम से किसी भी एजेंट में एम्बेड हो जाता है।

क्या context को कंप्रेस करने से उत्तर की गुणवत्ता पर असर पड़ता है?

नहीं। यह आमतौर पर इसे सुधारता है। Context-rot रिसर्च दिखाती है कि नॉइज़ से भरते विंडो के साथ मॉडल की सटीकता 98% से गिरकर 64% हो जाती है। LeanCTX अनावश्यकता को हटा देता है जबकि अर्थ को बनाए रखता है: AST-aware maps सिग्नेचर और संरचना को बनाए रखते हैं, शेल पैटर्न त्रुटियों और परिणामों को बनाए रखते हैं। कुछ भी खोता नहीं है। हर मूल ctx_retrieve के माध्यम से स्थानीय रूप से पुनर्प्राप्त किया जा सकता है।

मैं इसे कैसे इंस्टॉल करूं?

एक कमांड, फिर एक सेटअप। स्क्रिप्ट, Homebrew, npm, या cargo के माध्यम से इंस्टॉल करें और `lean-ctx setup` चलाएं। LeanCTX आपके एडिटर्स का स्वतः पता लगाता है और प्रत्येक के लिए सही हुक्स और MCP सर्वर को जोड़ देता है। अपग्रेड एक ही `lean-ctx update` से हो जाते हैं।

क्या मेरा कोई कोड या डेटा किसी सर्वर पर भेजा जाता है?

नहीं। कंप्रेसन, कैशिंग, सेविंग्स लेजर और प्रोजेक्ट मेमोरी सभी आपकी मशीन पर स्थानीय रूप से चलते हैं; कुछ भी अपलोड नहीं होता। एकमात्र नेटवर्क सुविधाएँ (Wrapped share card और public leaderboard) सख्ती से ऑप्ट-इन होती हैं और केवल एक गुमनाम, श्वेतसूचीकृत एग्रीगेट प्रकाशित करती हैं: एक टोकन काउंट और एक डिस्प्ले नाम जो आप चुनते हैं।

यह किन AI टूल्स के साथ काम करता है?

30+ और बढ़ रहा है: Cursor, Claude Code, OpenAI Codex, GitHub Copilot, Zed, Windsurf, Cline, Roo Code, Gemini CLI, OpenCode, JetBrains IDEs, और कोई भी MCP-capable client। एक बार lean-ctx setup चलाएं और हर इंस्टॉल किया गया टूल स्वतः पता लगाया और कॉन्फ़िगर हो जाता है।

LeanCTX का मतलब क्या है?

लीन कॉन्टेक्स्ट। नाम काम बताता है: AI एजेंटों के लिए कच्चा, शोरगुल वाला इनपुट नहीं, बल्कि लीन, सटीक संदर्भ। LeanCTX ब्रांड और प्रोजेक्ट का नाम है; lean-ctx बाइनरी, पैकेज और CLI कमांड है। (यह "Lean Cortex" नहीं है, एक गलत वर्तनी जो शुरुआती कवरेज में दिखाई दी थी।)

Headroom जैसे संपीड़न उपकरणों से LeanCTX कैसे अलग है?

Headroom जैसे उपकरण वायर पर अनुरोध को संपीड़ित करते हैं — प्रॉक्सी लेयर। LeanCTX पहले से ही वह परत भेजता है: एक वैकल्पिक लोकल प्रॉक्सी (lean-ctx proxy enable) आपके एजेंट और मॉडल के बीच बैठता है और हर अनुरोध को संपीड़ित करता है — सिस्टम प्रॉम्प्ट, इतिहास और टूल परिणाम — इससे पहले कि इसे भेजा जाए, prompt-cache-safe, वास्तविक डॉलर बचाए जाने का मापन करता है। इसलिए आमतौर पर आपको ऊपर एक अलग request-compression proxy की आवश्यकता नहीं होती है। और LeanCTX एक परत गहरा जाता है, स्रोत पर: यह तय करता है कि क्या पढ़ा जाना चाहिए (10 रीड मोड, ~13-टोकन कैश किए गए री-रीड्स), सत्रों में याद रखता है, फ़ाइल और शेल एक्सेस को सुरक्षित करता है, और हर बचत पर एक सत्यापन योग्य लेजर में हस्ताक्षर करता है। संपीड़न — रीड-साइड और वायर-साइड — इसके पाँच उपप्रणालियों में से एक है, और यह पूरी तरह से प्रतिवर्ती है: हर मूल ctx_retrieve के एक कदम दूर रहता है।

अपने संदर्भ पर नियंत्रण वापस लें।

टोकन बचाकर शुरुआत करें। इसलिए रहें क्योंकि आपके एजेंट जो कुछ भी सीखते हैं, छूते हैं और सेव करते हैं वह आखिरकार आपके नियंत्रण में है। स्थानीय उपयोग के लिए मुफ़्त, हमेशा के लिए। एक CI गेट यह सुनिश्चित करता है कि ऐसा ही रहे।

मुफ्त में इंस्टॉल करें प्लान देखें

नियंत्रित करें किआपका AI क्या देख सकता है।