rlm

RLM Plugin v3.0 — Recursive Language Models for Claude Code

Enhanced for Claude Opus 4.5 with dual execution modes, git-aware incremental analysis, memory persistence, token-aware processing, and structured sub-agent output.

Based on "Recursive Language Models" by Zhang, Kraska, and Khattab (2025).

Architecture

                        /rlm <task> <path>
                              |
                        Phase 0: Mode Detection
                        ┌─────┴──────┐
                        │            │
                  Quick Scan    Deep Audit
                   (~5K tok)   (~30-60K tok)
                        │            │
                  ┌─────┘     ┌──────┴──────────┐
                  │           │                  │
            memory_recall   Phase 1            Phase 1
                  │         Assessment         Assessment
            Grep+Read      ┌────┴────┐       ┌────┴────┐
            (bounded)      │  memory  │      │ CLAUDE.md │
                  │        │  recall  │      │  git diff │
            Inline        │  glob    │      │  bg scan  │
            Answer        └────┬────┘      └────┬────┘
                               │                  │
                         Phase 2: Explore    Phase 2: Explore
                         Peek + Grep count   Peek + Grep count
                         .rlm/<date>/        .rlm/<date>/
                               │                  │
                         Phase 3: Decompose ──────┘
                         Parallel sub-agents
                         FINAL protocol
                         Adaptive budgets
                               │
                         Phase 4: Synthesize
                         Dedup + rank + cross-ref
                               │
                         Phase 5: Output
                         Report + memory_store
                         Checkpoint cleanup

What's New in v3.0

#	Enhancement	Impact
E1	Dual Execution Modes — Quick Scan vs Deep Audit	87% fewer tokens for simple queries
E2	Smart Directory Pruning — auto-exclude noise dirs	30-50% scan reduction
E3	Git-Aware Incremental — diff-based re-analysis	80-90% faster on repeats
E4	Timestamped Checkpoints — .rlm/<date>/	Multi-session resilience
E5	CLAUDE.md Awareness — skip structure discovery	~10K tokens saved
E6	FINAL Output Protocol — structured sub-agent output	Reliable dedup + ranking
E7	Background Scanning — parallel inventory	20-30% wall-clock reduction
E8	Adaptive Budgets — auto-split large scopes	Prevents context overflow
E9	Binary Filtering — skip 30+ binary extensions	Clean results

Quick Start

Installation

# Clone
git clone https://github.com/adibirzu/rlm-plugin.git ~/.claude/plugins/repos/rlm-plugin

# Install (creates settings entry, clears cache)
bash ~/.claude/plugins/repos/rlm-plugin/install.sh

# Restart Claude Code

Verify

ls ~/.claude/plugins/repos/rlm-plugin/commands/rlm.md
grep rlm ~/.claude/settings.json

Usage

/rlm <task description> <context path>

Quick Scan (simple queries, ~5K tokens):

/rlm "find all TODO comments" src/
/rlm "where is the auth middleware defined?" .
/rlm "list all API endpoints" backend/
/rlm "how many test files are there?" .

Deep Audit (comprehensive analysis, ~30-60K tokens):

/rlm "full review of the project — deployment, code quality, security" .
/rlm "audit for OWASP top 10 vulnerabilities" backend/
/rlm "analyze architecture and find coupling issues" src/
/rlm "review what changed since the last analysis" .

How It Works

Quick Scan Pipeline

1. memory_recall — check for known project structure
2. Grep with head_limit: 50 — find matches
3. Read with limit: 100 — examine top hits
4. Return inline answer with file:line citations

Deep Audit Pipeline

1. Assessment — Memory recall, CLAUDE.md, git check, scope sizing
2. Exploration — Peek, grep counts, write .rlm/<date>/scan_results.md
3. Decomposition — Parallel sub-agents with FINAL protocol, adaptive budgets
4. Synthesis — Dedup, cross-reference, rank, write .rlm/<date>/synthesis.md
5. Output — Report file, memory store, checkpoint cleanup, gitignore check

Strategy Selection