RLM (Reasoning Language Models) для Agents

Дата: 2026-01-25 Автор: Research by Claude

Что такое RLM?

RLM (Reasoning Language Models) — также известны как Large Reasoning Models (LRMs) — это новый класс моделей, расширяющих LLM продвинутыми механизмами рассуждения.

Ключевые примеры:

OpenAI o1, o3 — пионеры, hidden chain-of-thought
DeepSeek-R1 — open-source, чистый RL без SFT
Alibaba QwQ — implicit reasoning
LLaMA-Berry — explicit tree-of-chains + MCTS

Принципиальное отличие от LLM:

LLM	RLM
Интерполяция — паттерны из training data	Экстраполяция — выход за пределы обучения
Next-token prediction	Step-by-step structured reasoning
Мгновенный ответ	"Thinking time" перед ответом
System 1 (быстрое интуитивное)	System 2 (медленное логическое)

Архитектура RLM: Blueprint

Согласно статье Reasoning Language Models: A Blueprint, RLM состоит из модульных компонентов:

1. Reasoning Structures (Структуры рассуждения)

Chain:     [A] → [B] → [C] → [Answer]
           (линейная последовательность)

Tree:          [Root]
              /   |   \
           [A]  [B]   [C]
           /\    |    /\
         ... ... ... ...
         (ветвление гипотез)

Graph:     [A] ←→ [B]
            ↓  ╲  ↓
           [C] → [D]
           (произвольные связи)

Nested:    [Node containing sub-tree]
           (узлы содержат подструктуры)

2. Reasoning Strategies

MCTS (Monte Carlo Tree Search) — баланс exploration/exploitation через симуляции
Beam Search — сохранение top-k кандидатов
Best-of-N — параллельная генерация + выбор лучшего
Diverse Verifier Tree Search (DVTS) — разнообразие траекторий

3. Operators (Операторы над структурами)

Structure Operators:

Generate — добавить новые шаги
Aggregate — объединить пути
Prune — удалить неперспективные ветки
Restructure — реорганизовать (tree → chain)

Traversal Operators:

Select — выбрать шаг для развития
Backtrack — вернуться назад, попробовать другой путь

Update Operators:

Refine — улучшить качество шага
Backpropagate — распространить оценки

Evaluation Operators:

Terminal evaluation (финальный ответ)
Intermediate evaluation (промежуточные шаги)

4. Models

Модель	Функция
Policy Model	Генерирует новые шаги рассуждения
Value Model	Оценивает качество пути от текущего узла
Reward Model	Оценивает качество отдельного шага

Training Paradigms

Supervision Schemes

Outcome-Based Supervision (OBS)
- Только input → final output
- Проще собрать данные
- Меньше guidance для intermediate steps
Process-Based Supervision (PBS)
- Полные reasoning traces с оценками каждого шага
- Granular обучение
- Дорого аннотировать
Trace-Based Supervision (TBS) (новое)
- Последовательности операторов
- Учит динамику рассуждения

Training Approaches

┌─────────────────────────────────────────────────────────┐
│  Base LLM                                               │
│      ↓                                                  │
│  Cold Start SFT (опционально)                          │
│      ↓                                                  │
│  Reinforcement Learning (GRPO/PPO/DPO)                 │
│      ↓                                                  │
│  Rejection Sampling + SFT                              │
│      ↓                                                  │
│  Alignment RL (human preferences)                      │
│      ↓                                                  │
│  RLM                                                    │
└─────────────────────────────────────────────────────────┘

DeepSeek-R1: Case Study

DeepSeek-R1 — прорывная open-source модель, демонстрирующая emergence reasoning через чистый RL.

GRPO Algorithm

Group Relative Policy Optimization — упрощённая альтернатива PPO:

1. Для каждого вопроса сэмплируем группу из 16 ответов
2. Вычисляем advantage: A_i = (r_i - mean(rewards)) / std(rewards)
3. Policy gradient с KL-regularization
4. Нет отдельной value network!

Преимущества:

Меньше compute (нет critic model)
Избегает reward hacking
Работает с rule-based rewards

Emergent Behaviors ("Aha Moment")

Без какого-либо supervised fine-tuning, чистый RL привёл к emergence:

Self-reflection: "Wait, let me reconsider..."
Self-verification: проверка промежуточных шагов
Strategy switching: смена подхода при неудаче
Extended reasoning: рост длины ответов с 100s до 1000s токенов

"Wait, wait. That's an aha moment I can flag here." — Модель спонтанно начала использовать reflection

Результаты

Benchmark	DeepSeek-R1-Zero	DeepSeek-R1	OpenAI o1
AIME 2024 (pass@1)	71.0%	79.8%	~80%
AIME 2024 (majority)	86.7%	97.3%	~90%
MATH-500	92.2%	97.3%	96.4%

Distillation

RL на маленьких моделях — дорого и нестабильно. Решение:

DeepSeek-R1 (671B) 
    ↓ генерирует 800k примеров
    ↓ SFT distillation
Qwen-14B-Distill → превосходит QwQ-32B!

OpenAI o1/o3: Hidden Chain of Thought

Архитектура

Transformer с "thinking block" — внутренний диалог
Hidden CoT — reasoning не показывается пользователю
Test-time Search — генерация нескольких путей, выбор лучшего

Почему скрытый CoT?

Competitive advantage
Safety monitoring
UX (raw thinking хаотичный)

OpenAI показывает только summary reasoning.

Test-Time Compute

Традиционно:     Больше параметров → лучше качество
o1/o3:           Больше "thinking time" → лучше качество

Ключевой insight: Маленькая модель с augmented TTC может превзойти модель в 14x больше!

o3 на ARC-AGI

88% accuracy (рекорд!)
96.7% на AIME
10x больше training compute чем o1
Модель сама научилась стратегии: пишет brute-force решение, использует для верификации оптимизированного

Test-Time Scaling: Что работает?

Исследование Revisiting Test-Time Scaling of o1-like Models

Неожиданный finding: Longer CoT ≠ Better accuracy!

Правильные ответы:  короче
Неправильные:       длиннее

Sequential vs Parallel Scaling

Подход	Результат
Sequential revision	Деградация performance
Self-revision rate	<10% успешных исправлений
Parallel sampling	Значительно лучше!

Shortest Majority Vote

Новый метод: комбинация parallel sampling + предпочтение коротких ответов

score(answer) = frequency(answer) * length_penalty(answer)

→ Значительно превосходит обычный majority voting

RLM для Agents: Test-Time Compute

Scaling Test-Time Compute for LLM Agents

Агенты ≠ single-turn reasoning. Проблема: sequential error accumulation.

Что работает для агентов:

Parallel Sampling (Best-of-N)
- 63% vs 56% baseline на GAIA
- +8 points improvement
Selective Reflection
- НЕ постоянная рефлексия
- Триггер по threshold score <2
- 56.4% vs 55.2% constant reflection
List-wise Verification
- Лучше чем scoring или voting
- 63% vs 59% (scoring) vs 57% (voting)
Multi-Agent Diversity
- 4 разных модели → 74.5% pass@4
- Превосходит SOTA

Agentic Reasoning Frameworks

Taxonomy (LLM-based Agentic Reasoning Frameworks Survey)

Level 1: Single-Agent
├── Prompt Engineering (roles, few-shot)
└── Self-Improvement (reflection, iteration)

Level 2: Tool-Based
├── Tool Integration (API, plugins)
├── Tool Selection (autonomous, rule-based, learned)
└── Tool Utilization (sequential, parallel, iterative)

Level 3: Multi-Agent
├── Architectures (centralized, decentralized, hierarchical)
└── Interactions (cooperation, competition, negotiation)

Action Space агента:

A = {a_reason, a_tool, a_reflect}

На каждом шаге агент выбирает: думать, использовать инструмент, или рефлексировать.

Explicit vs Implicit RLMs

Explicit RLMs

Reasoning структура внешняя, манипулируемая
Примеры: LLaMA-Berry, Marco-o1, MCTS-based systems
✅ Интерпретируемость
✅ Контролируемость
❌ Больше compute overhead

Implicit RLMs

Reasoning внутри весов (black box)
Примеры: QwQ, DeepSeek-R1
Анализ output → implicit backtracking, summarization, critique
✅ Эффективнее inference
❌ Меньше transparency

Recursive Language Models (бонус)

Другой смысл RLM — Recursive Language Models:

Проблема: Context window ограничен

Решение: Модель сама управляет своим контекстом
├── Делегирует в Python scripts
├── Вызывает sub-LLMs для подзадач
└── НЕ summarizes (no info loss)

Результат: Обработка 10M+ токенов, двузначный % improvement.

Key Insights

1. Emergence через RL

DeepSeek-R1-Zero доказал: чистый RL без supervised data может вызвать emergence сложного reasoning.

2. Test-Time Compute > Parameters

Маленькая модель с достаточным "thinking budget" может превзойти большую.

3. Parallel > Sequential для scaling

Self-revision работает плохо. Parallel sampling + smart aggregation — лучше.

4. Agents требуют специальных стратегий

Sequential error accumulation делает naive TTS неэффективным для агентов.

5. Distillation эффективнее RL для маленьких моделей

800k examples от large RLM → SFT → маленькая модель превосходит direct RL.

6. Process supervision важнее outcome

PBS (step-level rewards) даёт более granular обучение чем OBS.

Benchmarks для RLM

Benchmark	Домен	Метрика
AIME 2024	Math olympiad	pass@1, majority
MATH-500	Mathematics	accuracy
ARC-AGI	Abstract reasoning	accuracy
GSM8K	Grade school math	accuracy
HumanEval	Code generation	pass@k
GAIA	Agent tasks	success rate

Практические рекомендации

Для использования RLM:

Выделяй thinking budget — больше compute на сложные задачи
Parallel sampling — генерируй несколько решений, выбирай лучшее
Shorter = better — при equal voting предпочитай короткие ответы
Selective reflection — не каждый шаг, только при низкой confidence

Для обучения RLM:

Cold start matters — начни с quality CoT examples
GRPO > PPO — проще, дешевле, эффективнее
Rule-based rewards — избегают reward hacking
Distillation — эффективнее direct RL для маленьких моделей

Ссылки

Reasoning Language Models: A Blueprint — основной survey
DeepSeek-R1 — emergence через RL
Revisiting Test-Time Scaling — critical analysis
Scaling TTC for Agents — agents + TTS
LLM-based Agentic Reasoning Survey — frameworks taxonomy
Understanding R1-Zero Training — critical perspective
OpenAI o1 Learning to Reason
Recursive Language Models — context management

Generated with Claude Code

niquola/research-rlm-agents-2026-01-25.md