rlm

name	rlm
description	Recursive Language Model for processing large contexts (>50KB). Use for complex analysis tasks where token efficiency matters. Achieves 40% token savings by letting the LLM programmatically explore context via Query() and FINAL() patterns.
allowed-tools	["Bash"]

RLM - Recursive Language Model

RLM is an inference-time scaling strategy that enables LLMs to handle arbitrarily long contexts by treating prompts as external objects that can be programmatically examined and recursively processed.

• License: MIT
• Repository: https://github.com/XiaoConstantine/rlm-go

When to Use

Use rlm instead of direct LLM calls when:

• Processing large contexts (>50KB of text)
• Token efficiency is important (40% savings on large contexts)
• The task requires iterative exploration of data
• Complex analysis that benefits from sub-queries

Do NOT Use When

• Context is small (<10KB) - overhead not worth it
• Simple single-turn questions
• Tasks that don't require data exploration

Command Usage

# Basic usage with context file
~/.local/bin/rlm -context <file> -query "<query>" -verbose

# With inline context
~/.local/bin/rlm -context-string "data" -query "<query>"

# Pipe context from stdin
cat largefile.txt | ~/.local/bin/rlm -query "<query>"

# JSON output for programmatic use
~/.local/bin/rlm -context <file> -query "<query>" -json

Options

Flag	Description	Default
-context	Path to context file	-
-context-string	Context string directly	-
-query	Query to run against context	Required
-model	LLM model to use	claude-sonnet-4-20250514
-max-iterations	Maximum iterations	30
-verbose	Enable verbose output	false
-json	Output result as JSON	false
-log-dir	Directory for JSONL logs	-

How It Works

RLM uses a Go REPL environment where LLM-generated code can:

1. Access context as a string variable
2. Make recursive sub-LLM calls via Query() for focused analysis
3. Use standard Go operations for text processing
4. Signal completion with FINAL() when done

The Query() Pattern

// LLM generates code like this inside the REPL:
chunk := context[0:10000]
summary := Query("Summarize the key findings in this text: " + chunk)
// ... iterate through more chunks
FINAL(combinedResult)

The FINAL() Pattern

The LLM signals completion by calling:

• FINAL("answer") - Return a string answer
• FINAL_VAR(variableName) - Return value of a variable

Token Efficiency Benefits

For large contexts (>50KB), RLM typically achieves 40% token savings by:

• Only sending relevant context chunks to sub-queries
• Avoiding repeated full-context processing
• Using programmatic iteration instead of full-context reasoning

Examples

Analyze Log Files

rlm -context server.log -query "Find all unique error patterns and their frequencies"

Process JSON Data

rlm -context data.json -query "Extract all user IDs with failed transactions" -verbose

Code Analysis

cat src/*.go | rlm -query "Identify all exported functions and their purposes"

Requirements

• ANTHROPIC_API_KEY environment variable must be set
• Binary installed at ~/.local/bin/rlm

Installation

# Quick install
curl -fsSL https://raw.githubusercontent.com/XiaoConstantine/rlm-go/main/install.sh | bash

# Or with Go
go install github.com/XiaoConstantine/rlm-go/cmd/rlm@latest