Rlm

Recursive Language Model (RLM) Skill

Core Philosophy

"Context is an external resource, not a local variable."

When this skill is active, you are the Root Node of a Recursive Language Model system. Your job is NOT to read code, but to write programs (plans) that orchestrate sub-agents to read code.

Protocol: The RLM Loop

Phase 1: Choose Your Engine

Decide based on the nature of the data:

Phase 2: Index & Filter (The "Peeking" Phase)

Goal: Identify relevant data without loading it.

1. Native: Use find or grep -l.
2. Strict: Use python3 .../rlm.py peek "query".
   • RLM Pattern: Grepping for import statements, class names, or definitions to build a list of relevant paths.

Phase 3: Parallel Map (The "Sub-Query" Phase)

Goal: Process chunks in parallel using fresh contexts.

1. Divide: Split the work into atomic units.
   • Strict Mode: python3 .../rlm.py chunk --pattern "*.log" -> Returns JSON chunks.
2. Spawn: Use Task to launch parallel agents.
   • Constraint: Launch at least 3-5 agents in parallel for broad tasks.
   • Prompting: Give each background agent ONE specific chunk or file path.
   • Format: Task(agent="explore", prompt="Analyze chunk #5 of big.log: {content}...")

Phase 4: Reduce & Synthesize (The "Aggregation" Phase)

Goal: Combine results into a coherent answer.

1. Collect: Read the outputs from Task (via Task output).
2. Synthesize: Look for patterns, consensus, or specific answers in the aggregated data.
3. Refine: If the answer is incomplete, perform a second RLM recursion on the specific missing pieces.

Critical Instructions

1. NEVER use cat * or read more than 3-5 files into your main context at once.
2. ALWAYS prefer Task for reading/analyzing file contents when the file count > 1.
3. Use rlm.py for programmatic slicing of large files that grep can't handle well.
4. Python is your Memory: If you need to track state across 50 files, write a Python script (or use rlm.py) to scan them and output a summary.

Example Workflow: "Find all API endpoints and check for Auth"

Wrong Way (Monolithic):

• read src/api/routes.ts
• read src/api/users.ts
• ... (Context fills up, reasoning degrades)

RLM Way (Recursive):

1. Filter: grep -l "@Controller" src/**/*.ts -> Returns 20 files.
2. Map:
   • Task(prompt="Read src/api/routes.ts. Extract all endpoints and their @Auth decorators.")
   • Task(prompt="Read src/api/users.ts. Extract all endpoints and their @Auth decorators.")
   • ... (Launch all 20)
3. Reduce:
   • Collect all 20 outputs.
   • Compile into a single table.
   • Identify missing auth.

Recovery Mode

If Task is unavailable or fails:

1. Fall back to Iterative Python Scripting.
2. Write a Python script that loads each file, runs a regex/AST check, and prints the result to stdout.
3. Read the script's stdout.

Checklist

• Chose appropriate engine (Native or Strict) for the data type.
• Indexed and filtered before loading any file content.
• Spawned parallel Task agents (3-5 minimum for broad tasks).
• Each agent received ONE specific chunk or file path.
• Collected and synthesized all agent outputs.
• Refined with a second RLM pass if answer was incomplete.
• Never loaded more than 3-5 files directly into main context.

Cross-Skill Integration