009. 2026-06-25 - RLM - Recursive Language Models

📄 RLM: Рекурсивные языковые модели — масштабирование инференса через декомпозицию контекста

Краткий обзор

Alexander Zhang представляет RLM (Recursive Language Models) — стратегию инференса, при которой модель рекурсивно декомпозирует не задачу, а контекст. В отличие от агентов, где схему задаёт человек, здесь модель сама решает, как “читать” длинный контекст через REPL-среду. Результаты: +34 пункта (~114%) над GPT-5 при той же стоимости на 132K токенов.

🔗 Оригинал: RLMs: Why Scale Test-Time Compute If You Can Scale Context? — alexzhang13.github.io

---

🏛️ Ключевые идеи

• Контекстно-ориентированная, а не проблемно-ориентированная декомпозиция: RLM делегирует модели решение о том, как читать и обрабатывать контекст, вместо того чтобы человек проектировал граф инструментов.
• Корневая модель не видит контекст: это принципиально — предотвращает “context rot” (деградацию внимания на длинных контекстах) и заставляет модель работать через инструменты.
• RLM ≠ агент: агенты декомпозируют задачу, RLM декомпозирует контекст. Это не “просуммировал и передал дальше” — модель адаптивно выбирает стратегию взаимодействия.
• Масштабируемость как свойство архитектуры: если frontier-модель завтра возьмёт 10M токенов, RLM сможет работать со 100M.

---

💡 Где использовать (Use Cases)

• Сверхдлинные контексты: анализ гигантских логов, код-баз, датасетов, где ни одна модель не справляется с полной загрузкой.
• Дистрибутивные запросы: “сколько записей удовлетворяют условию X” по всему корпусу — задача, где контекстное окно проседает первым.
• Multi-hop рассуждения на документах: поиск ответа, требующего связать информацию из нескольких источников среди тысяч документов.
• Модально-независимый анализ: теоретически контекст может быть любой модальности (изображения, аудио), загружаемой в память REPL.

---

🧩 Структура оригинала

• Introduction
• Background & Context
• What Makes RLM Unique
• Implementation
• Emergent Strategies
• Experiment 1 — OOLONG Benchmark
• Experiment 2 — BrowseComp-Plus
• Limitations
• Future Directions

---

🧠 Основная часть

Введение и контекст

Проблема длинных контекстов хорошо известна: даже модели с гигантскими контекстными окнами страдают от “context rot” — деградации качества ответов с ростом объёма входных данных. Традиционные решения включают:

• RAG: предварительный поиск релевантных фрагментов, но теряется глобальная структура.
• Агенты (ReAct): декомпозиция задачи человеком через инструменты, но схема жёсткая и не адаптируется к контексту.
• Суммаризация: сжатие контекста, но с потерей деталей.

RLM предлагает принципиально иной путь: ни одному отдельному вызову LM не нужно обрабатывать огромный контекст. Вместо этого модель получает инструмент для рекурсивного вызова самой себя на фрагментах контекста.

Что делает RLM уникальным

Автор выделяет три ключевых отличия:

1. Контекстно-ориентированная декомпозиция: агенты декомпозируют задачу (человек решает, какие инструменты нужны); RLM декомпозирует контекст (модель решает, как его читать).

2. Изолированная среда: каждый рекурсивный вызов получает собственное REPL-окружение — нет утечек состояния, нет путаницы между уровнями.

3. Эмерджентные стратегии: модель сама “придумывает” как работать с контекстом — peeking, grepping, partition+map — без явного программирования этих поведений.

Реализация

RLM — это тонкая обёртка вокруг LM. С точки зрения API: rlm.completion(messages) — прямая замена gpt5.completion(messages).

Цикл работы:

1. Корневая модель получает запрос q и указание, что контекст в переменной REPL
2. Модель выводит код для взаимодействия с контекстом:
   - peek(ctx, n) — посмотреть первые N символов
   - grep(ctx, pattern) — поиск по regex
   - rlm_call(subquery, ctx_subset) — рекурсивный вызов
3. REPL выполняет код и возвращает (усечённый) вывод
4. Повторять шаги 2-3 пока модель не выведет FINAL(answer)

Ключевые примитивы REPL-среды:

• peek(ctx, n) — подсмотреть начало контекста
• grep(ctx, pattern) — фильтрация по regex
• partition(ctx, n) — разбиение на N частей
• rlm_call(query, ctx_subset) — рекурсивный LM-вызов над фрагментом

Формальное определение: $RL{M}_M(q,C)$ над средой $\mathcal{E}$ предоставляет модели инструмент $RL{M}_M(\hat{q},\hat{C})$, порождающий изолированный под-RLM-экземпляр с собственным запросом $\hat{q}$, трансформированным контекстом $\hat{C}$ и изолированной средой $\hat{\mathcal{E}}$.

Эмерджентные стратегии

Автор наблюдал, как модели спонтанно вырабатывают поведенческие паттерны:

Peeking (подглядывание): корневая модель запрашивает первые N символов контекста, чтобы оценить его структуру (JSON? лог? текст?) и выбрать стратегию.

Grepping (поиск по шаблонам): модель предпочитает regex семантическому поиску — точные совпадения надёжнее для дистрибутивных запросов вроде “сколько записей содержат X”.

Partition + Map: модель разбивает контекст на части и запускает рекурсивные вызовы для семантической обработки каждого фрагмента (например, классификация записей). Это классический map-reduce, но orchestration полностью на стороне LM.

Summarization: обобщение подмножеств контекста для принятия решения корневой моделью — модель сама решает, что суммировать.

Long-input, long-output: рутинные вычислительные задачи (например, отслеживание git diff) делегируются REPL-коду, а не решаются моделью “вручную”.

Эксперимент 1 — OOLONG Benchmark

Задача: ответы на дистрибутивные запросы по списку из ~3000–6000 строк с пользовательскими ID и неразмеченными сущностями. Оценивались запросы с контекстом >128K токенов.

Результаты при 132K токенов:

• RLM(GPT-5-mini) превзошёл GPT-5 на 34+ пункта (прирост ~114%)
• Стоимость API-запроса — примерно та же

Результаты при 263K токенов:

• RLM(GPT-5-mini) превзошёл GPT-5 на 15+ пунктов (прирост ~49%)
• Производительность GPT-5-mini упала сильнее, чем у GPT-5 — “context rot” поражает меньшие модели сильнее

Абляция: REPL-среда без рекурсивных вызовов показала падение ~10%, подтверждая важность именно рекурсии для семантических подзадач.

Эксперимент 2 — BrowseComp-Plus

Задача: multi-hop запросы, требующие ассоциации информации из нескольких документов среди ~100K документов (~5K слов в среднем). Ответ есть в корпусе, но определить его правильность можно только связав информацию из нескольких источников.

Результаты:

• RLM(GPT-5) — единственный метод, сохранивший 100% производительности при масштабировании до 1000 документов
• Базовая GPT-5 показала явное падение с ростом числа документов — ни полный контекст, ни усечение, ни BM25 не помогли
• ReAct + BM25 уступил RLM и по качеству, и по стоимости

Ограничения

• Скорость: рекурсивные вызовы блокирующие, без префиксного кэширования. Запрос может занимать от секунд до минут.
• Стоимость: нет гарантий контроля над общим бюджетом API или временем выполнения.
• Глубина рекурсии: все эксперименты ограничены глубиной 1; большая глубина — открытый вопрос.
• Детерминизм: модель может выбрать неоптимальную стратегию взаимодействия с контекстом.

Направления развития

• Асинхронные вызовы: распараллеливание рекурсивных под-запросов для ускорения.
• RL-оптимизация траекторий: обучение модели выбирать оптимальные стратегии взаимодействия с контекстом через reinforcement learning.
• Большая глубина рекурсии: иерархическая декомпозиция контекста на множество уровней.
• Кросс-модальность: применение RLM к контекстам из изображений, аудио, видео.

---

🛠️ Технические детали и реализация

Базовая архитектура RLM:

# Псевдокод цикла RLM (один шаг)
def rlm_step(model, query, env):
    # model не видит env.ctx напрямую — только через инструменты
    response = model.completion(
        messages=[{
            "role": "user",
            "content": f"Query: {query}\nContext is in variable 'ctx'. Use tools to explore it."
        }],
        tools=[
            peek_tool,    # peek(ctx, n) -> first n chars
            grep_tool,    # grep(ctx, pattern) -> matching lines
            rlm_tool,     # rlm_call(subquery, ctx_fragment) -> FINAL answer
            final_tool,   # FINAL(answer) -> завершение
        ],
        environment=env   # Python REPL с ctx в памяти
    )
 
    if response.is_final:
        return response.answer
 
    # Выполнить код в REPL, получить вывод
    output = env.execute(response.code)
    # Передать вывод обратно модели (с усечением)
    return rlm_step(model, query, env.feed(output))

Ключевой принцип: rlm_tool создаёт изолированный экземпляр RLM — новый env со своим ctx, новый цикл, никакого разделения состояния с родителем.

# Упрощённая реализация rlm_tool
def rlm_call(subquery, ctx_fragment):
    sub_env = Environment(ctx=ctx_fragment)  # изолированная среда
    return rlm_step(model, subquery, sub_env)

---

⚖️ Плюсы и Минусы

👍 Плюсы	👎 Минусы
Контекстное окно корневой модели не перегружается — защита от context rot	Блокирующие вызовы — медленно, особенно без префиксного кэширования
Модель адаптивно выбирает стратегию чтения контекста	Нет гарантий по стоимости и времени выполнения
Модальная независимость — контекст может быть любым типом данных	Глубина рекурсии ограничена 1 в текущих экспериментах
Масштабируется с улучшением базовых моделей	Неоптимальная стратегия модели может привести к плохим результатам
Простая замена обычного completion-вызова	Требует REPL-среды с исполнением кода

---

🔗 Связи

• RLM (Recursive Language Model) — термин в глоссарии.
• Context Window — проблема “context rot”, которую RLM решает архитектурно.
• Agent — альтернативный подход: декомпозиция задачи вместо декомпозиции контекста.
• Inference — RLM как эволюция масштабирования времени инференса (после CoT и ReAct).

Теги: ai inference context rlm techreview