sRLM wraps a small open-source LLM in a persistent Python REPL loop where it can search a document, extract entities, and recursively spawn sub-agents to answer focused sub-questions — all without task-specific fine-tuning. It is evaluated on the RULER long-context benchmark.

---

Table of Contents

• Architecture
• Components
  • RLMAgent
  • RLMEnvironment
  • Toolset
  • Session Orchestration
  • Prompt Format
  • History Modes
  • Safety Mechanisms
• Benchmark & Results
• Usage
• Citation

---

Architecture

sRLM has four layers:

---

Components

RLMAgent

RLMAgent (src/models/srlm.py) wraps any AutoModelForCausalLM:

agent = RLMAgent("Qwen/Qwen2.5-Coder-7B-Instruct")
response = agent.generate(prompt, max_tokens=2000, stop_sequences=["[TURN]"])

• Single instance shared across the main session and all recursive sub-agents — no reload overhead.
• Deterministic decoding (do_sample=False) for reproducibility.
• Loaded with torch.float16 and device_map="auto".

Models available via --agent:

RLMEnvironment

RLMEnvironment (env.py) is a persistent, sandboxed Python execution scope:

• locals_dict — mutable state visible to the agent: P (full document text), result (answer slot), last_search, _history, _sub_history.
• globals_dict — Python builtins plus all pre-loaded tools.
• Stdout/stderr are captured and truncated to prevent context bloat.
• Setting result to any non-failure value terminates the session immediately.
• Common standard libraries (re, json, math, collections, statistics, …) are pre-loaded so the model never needs to import them.

Toolset

All tools are injected into globals_dict and called directly from model-generated code — no imports needed.

Core tools (active in all modes):

Embeddings for semantic_search are built once by the main session (SentenceTransformer('all-MiniLM-L6-v2')) and shared with sub-agents — no re-encoding on recursion.

Extended tools (available in --concise mode):

In concise mode each turn receives filtered [FINDINGS], [RELEVANT_HISTORY], and [RECENT_ERRORS] blocks drawn from MemoryDB instead of the full conversation history.

Session Orchestration

run_rlm_session() (src/utils/model_utils.py) is the core control loop:

for turn in range(max_turns):
    context = build_context(history | memory | summary)
    response = agent.generate(context)
    response = strip_hallucinated_output(response)
    code = extract_code(response)
    if duplicate(code): inject_error_message; continue
    output = env.execute(code)
    if env.locals_dict["result"] is valid: return result
    if error in output: inject REFLEXION_PROMPT
return "Failure: Max turns reached"

Recursive sub-agents. When model-generated code calls llm_query(question), the REPL invokes a registered recursive_hook that launches a nested run_rlm_session with:

• The same RLMAgent instance.
• Reduced budget (max_turns=5, max_tokens=1500).
• Incremented depth (hard-capped at max_depth).
• Shared embedder, chunks, and embeddings from the parent session.

Prompt Format

Every model response must follow this strict 3-part structure:

[REASONING]
<reflect on current state; identify next action>

[CODE]
```python
# ONE tool call or operation per turn
```

[NEXT]
<expected outcome and plan for next turn>

The loop extracts and executes only the Python inside [CODE]. One operation per turn is enforced by the system prompt.

History Modes

All reported results use Full History (default).

Safety Mechanisms

---

Benchmark & Results

Evaluated on RULER — 13 synthetic long-context tasks, 500 validation samples each, 4K token sequences. Metric: string-match accuracy.

Systems: sRLM with Qwen2.5-Coder-7B-Instruct vs. direct-prompting baselines with the same model and Llama-3.1-8B-Instruct.

---

Usage

pip install torch transformers sentence-transformers

# Run sRLM on a built-in task
python main.py --agent qwen7 --task RNIAH --max_turns 10 --max_tokens 2000

# Run against RULER (SLURM array job, one task per job)
sbatch scripts/run_ruler_srlm_array.sh

# Run baseline
sbatch scripts/run_ruler_baseline_array.sh

# Evaluate predictions
python eval/evaluate.py --data_dir eval_results/sRLM/preds_agent_qwen7 --benchmark synthetic

CLI arguments:

---

Citation

@misc{srlm2026,
  title = {Small Recursive Language Models: A Framework for Tool-Augmented
           Recursive Reasoning in Long-Context {NLP} Tasks},
  year  = {2026},
  url   = {[https://github.com/anishdash4/Small-Recursive-Language-Models](https://github.com/anishdash4/Small-Recursive-Language-Models)}
}

---