Zeno
Zeno - Unbounded context through recursive reading. Codex & Claude Code plugin. :)
Install / Use
/learn @anth0nylawrence/ZenoQuality Score
Category
Development & EngineeringSupported Platforms
README
Zeno
<p align="center"><img src="assets/zeno.png" width="50%" alt="Zeno"></p>Recursive decomposition for unbounded codebase analysis. Zeno is an evidence-first, read-only workflow that lets AI models analyze massive codebases without context rot—by keeping the corpus external and pulling only what's needed.
Table of Contents
- Why Zeno? The Problem It Solves
- What Makes Zeno Different
- Architecture
- Core Ideas
- When to Use Zeno
- Modes
- Triggering Zeno (Natural Language Examples)
- Indexing (Symbol + Dependency Map)
- Budgets and Guardrails
- JSONL REPL Protocol
- Output Blocks
- Persistence Artifacts
- Security and Privacy
- Performance Notes
- Repo Layout
- Choose Your Runtime
- How the Zeno Loop Works
- Evidence and Claims
- Pattern A (Persistence)
- Pattern B (Telemetry)
- Testing
- Troubleshooting
- Next Steps
- Acknowledgments
Why Zeno? The Problem It Solves
Picture this: You need to understand a 500k-line codebase—trace a security vulnerability, audit dependency wiring, or map out the architecture. Traditional approaches hit hard limits fast.
Without Zeno
📁 Your massive codebase (500k+ lines)
↓
🤖 "Paste the relevant files..."
↓
😤 Context window fills up after 3 files
↓
🔄 Model starts "forgetting" earlier context (context rot)
↓
❌ Hallucinated connections, missed dependencies
↓
🗑️ Unreliable analysis you can't verify or reproduce
With Zeno
📁 Your massive codebase (500k+ lines)
↓
🔍 Zeno keeps corpus external in REPL server
↓
📎 Model pulls only the 50-100 lines it needs per query
↓
🧠 Fresh context window for each recursive inspection
↓
📋 Every claim backed by evidence with file:line citations
↓
✅ Auditable, reproducible analysis with receipts
The key insight from Recursive Language Models (RLMs) research: instead of stuffing everything into the prompt, treat the codebase as an external environment that the model can programmatically explore, decompose, and query recursively.
What Makes Zeno Different
Zeno isn't just another RAG pipeline or code search tool. It's an evidence-first analysis workflow implementing the RLM paradigm—the same approach that achieved 2.7x accuracy improvements on long-context benchmarks by letting models manage their own context.
The RLM Advantage
Traditional approaches suffer from "context rot"—as token count increases, the model's ability to accurately recall and reason degrades. RLMs solve this by:
- Externalizing context: The corpus lives in a REPL server, not the prompt
- Recursive decomposition: Complex queries split into sub-queries over smaller slices
- Programmatic exploration:
grep,peek,read_file—surgical retrieval, not bulk loading - Evidence discipline: No claim without a citation; every answer is verifiable
Capability Comparison
| Capability | Zeno | RAG Pipelines | IDE Copilots | Code Search | Full-Context Models | |:-----------|:----:|:-------------:|:------------:|:-----------:|:-------------------:| | Unbounded corpus size | ✅ | ❌ | ❌ | ✅ | ❌ | | Evidence-cited claims | ✅ | ❌ | ❌ | ❌ | ❌ | | Recursive decomposition | ✅ | ❌ | ❌ | ❌ | ❌ | | Retrieval budgets | ✅ | Partial | ❌ | ❌ | ❌ | | Claim-evidence ledger | ✅ | ❌ | ❌ | ❌ | ❌ | | Multi-runtime support | ✅ | Partial | ❌ | ❌ | ❌ | | Read-only by design | ✅ | Varies | ❌ | ✅ | ✅ | | No external indexing | ✅ | ❌ | ❌ | ❌ | ✅ | | Telemetry/replay audit | ✅ | Partial | ❌ | ❌ | ❌ |
Why This Matters
RAG pipelines chunk and embed your code, but semantic similarity doesn't capture execution flow, dependency graphs, or cross-file relationships. You get "related snippets," not traced evidence.
IDE copilots work great for local edits but struggle with architectural questions spanning hundreds of files. They optimize for autocompletion, not audit trails.
Full-context models (even with 200k+ tokens) degrade on complex retrieval tasks. Reported results are benchmark-specific: OOLONG shows +28.4% (GPT-5) and +33.3% (Qwen3-Coder), and some settings show up to 2x gains vs long-context scaffolds and up to 3x lower cost vs summarization baselines. Results vary by model and task. (Source: https://arxiv.org/abs/2512.24601)
Zeno gives you: every claim traced to file:lines, strict budgets preventing runaway costs, and reproducible analysis sessions persisted to disk.
Architecture
High-Level Flow
┌─────────────────────────────────────────────────────────────────────────────┐
│ ZENO WORKFLOW │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌──────────────────┐ ┌───────────────┐ │
│ │ │ │ │ │ │ │
│ │ USER │────────▶│ LLM (Claude/ │────────▶│ JSONL REPL │ │
│ │ QUERY │ │ Codex) │◀────────│ SERVER │ │
│ │ │ │ │ │ │ │
│ └─────────────┘ └────────┬─────────┘ └───────┬───────┘ │
│ │ │ │
│ │ Zeno Blocks │ Corpus │
│ ▼ ▼ │
│ ┌──────────────────┐ ┌───────────────┐ │
│ │ │ │ │ │
│ │ PERSISTENCE │ │ YOUR │ │
│ │ LAYER │ │ CODEBASE │ │
│ │ │ │ │ │
│ └──────────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
REPL Server Operations
┌─────────────────────────────────────────────────────────────────────────────┐
│ JSONL REPL PROTOCOL │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ list_files │───▶ Discover files matching patterns │
│ └─────────────┘ │
│ │
│ ┌─────────────┐ │
│ │ peek │───▶ Tiny previews (first N lines) │
│ └─────────────┘ │
│ │
│ ┌─────────────┐ │
│ │ read_file │───▶ Specific line ranges only │
│ └─────────────┘ │
│ │
│ ┌─────────────┐ │
│ │ grep │───▶ Pattern-based narrowing │
│ └─────────────┘ │
│ │
│ ┌─────────────┐ │
│ │extract_sym │───▶ Heuristic symbol extraction │
│ └─────────────┘ │
│ │
│ ┌─────────────┐ │
│ │ stat │───▶ File size/timestamp checks │
│ └─────────────┘ │
│ │
└──────────────────────────────────────────────────────────────────────
