RLM Context Manager Skill

RLM Context Manager

Purpose: Enable Claude to process documents and contexts that exceed typical context window limits, matching Gemini's large context capabilities through intelligent chunking and recursive processing.

Architecture (RLM Paper Implementation)

Based on arXiv:2512.24601 - Recursive Language Models by Zhang, Kraska, Khattab (MIT CSAIL).

| Component | IRP Implementation | Model | |-----------|-------------------|-------| | Root LLM | Main Claude Code conversation | Claude Opus 4.5 | | Sub-LLM (llm_query) | rlm-subcall Task agent | Claude Haiku | | External Environment | Persistent Python REPL | Python 3 | | State Persistence | ${SKILLS_ROOT}/rlm-context-manager/state/ | Pickle |

Use Cases

Processing large codebases for analysis
Analyzing lengthy documents (research papers, legal docs, logs)
Working with Mnemosyne ledger archives
Cross-session context restoration
Bridging context between Claude and Gemini

Commands

/rlm init <context_path>     - Initialize REPL with large context file
/rlm status                  - Show current RLM state (chars loaded, chunks, buffers)
/rlm query <question>        - Query the loaded context
/rlm chunk                   - Materialize context into chunk files
/rlm synthesize              - Merge collected evidence into final answer
/rlm reset                   - Clear RLM state
/rlm export                  - Export buffers to file

Quick Start

# 1. Initialize with a large context file
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py init /path/to/large_document.txt

# 2. Check status
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py status

# 3. Scout the context (peek at beginning and end)
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py exec -c "print(peek(0, 3000))"

# 4. Create chunks for sub-LLM processing
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py exec <<'PY'
paths = write_chunks('${SKILLS_ROOT}/rlm-context-manager/state/chunks', size=200000, overlap=0)
print(f"Created {len(paths)} chunks")
PY

Step-by-Step Procedure

1. Initialize the REPL State

python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py init <context_path>
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py status

2. Scout the Context

# Peek at beginning
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py exec -c "print(peek(0, 3000))"

# Peek at end
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py exec -c "print(peek(len(content)-3000, len(content)))"

# Search for patterns
python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py exec -c "print(grep('pattern', max_matches=10))"

3. Choose Chunking Strategy

Semantic chunking: For structured formats (markdown headings, JSON, log timestamps)
Character chunking: Default ~200k chars with optional overlap

4. Materialize Chunks

python3 ${SKILLS_ROOT}/rlm-context-manager/scripts/rlm_repl.py exec <<'PY'
paths = write_chunks('${SKILLS_ROOT}/rlm-context-manager/state/chunks', size=200000, overlap=0)
print(len(paths))
print(paths[:5])
PY

5. Sub-LLM Processing Loop

For each chunk, invoke the rlm-subcall subagent:

Task: rlm-subcall
Prompt: "Query: <user_query>. Chunk file: <chunk_path>. Extract relevant information."
Model: haiku

The sub-LLM returns structured JSON:

{
  "chunk_id": "...",
  "relevant": [{"point": "...", "evidence": "...", "confidence": "high|medium|low"}],
  "missing": ["..."],
  "suggested_next_queries": ["..."],
  "answer_if_complete": "..."
}

6. Synthesis

Collect sub-LLM outputs and synthesize final answer in main conversation.

REPL Helper Functions

| Function | Description | |----------|-------------| | peek(start, end) | Return substring of context | | grep(pattern, max_matches, window) | Regex search with context window | | chunk_indices(size, overlap) | Calculate chunk boundaries | | write_chunks(out_dir, size, overlap) | Materialize chunks to files | | add_buffer(text) | Store intermediate results |

Guardrails

Do NOT paste large raw chunks into main chat context
Use REPL to locate exact excerpts; quote only what you need
Subagents cannot spawn other subagents (orchestration stays in main conversation)
Keep scratch/state files under ${SKILLS_ROOT}/rlm-context-manager/state/
Prefer chunk sizes ~100k-300k chars per subagent call

Integration with IRP Protocols

Mnemosyne Ledger

Use RLM to process large Mnemosyne archives
Export buffers as Mnemosyne packets for cross-session persistence

Cross-Model (Gemini Bridging)

Load Gemini's large context exports
Chunk and analyze for Claude consumption
Synthesize into Mnemosyne-compatible format

CRTP Packets

RLM outputs can be formatted as CRTP packets for multi-model relay

File Structure

rlm-context-manager/
├── SKILL.md              # This file
├── scripts/
│   └── rlm_repl.py       # Persistent Python REPL
├── agents/
│   └── rlm-subcall.md    # Sub-LLM agent definition
└── state/                # Runtime state (gitignored)
    ├── state.pkl         # Persisted REPL state
    └── chunks/           # Materialized chunk files

Credits

Based on the RLM paper by Zhang, Kraska, Khattab (MIT CSAIL) and the Claude Code RLM implementation by Brainqub3.

Agent Skills: RLM Context Manager

Install this agent skill to your local

Skill Files