rlm

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.

⭐4stars🔀1forks📁View on GitHub🕐Updated Jan 9, 2026

When & Why to Use This Skill

RLM (Recursive Language Model) is an advanced inference-time scaling tool designed to process large-scale contexts exceeding 50KB. By treating prompts as external objects and utilizing a Go-based REPL environment, it allows Claude to programmatically explore data through recursive sub-queries. This skill significantly optimizes LLM performance by achieving up to 40% token savings, making it an essential solution for complex analysis tasks where context window limits and token efficiency are critical constraints.

Use Cases

  • Large-Scale Log Analysis: Efficiently scanning massive server logs to identify unique error patterns and frequencies without hitting context limits.
  • Complex Document Data Extraction: Processing extensive JSON datasets or structured files to extract specific records, such as failed transaction IDs, through iterative exploration.
  • Deep Codebase Auditing: Analyzing entire directories of source code to map exported functions, identify architectural patterns, and understand cross-file dependencies.
  • Token-Efficient Research: Summarizing and synthesizing information from very long manuscripts or technical reports by programmatically chunking and querying relevant sections.
namerlm
descriptionRecursive 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.

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.

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