Почему агенты деградируют на длинных horizon (более 10 шагов)?

Краткий тезис

Агенты на длинных горизонтах (более 10 шагов) деградируют из-за четырёх взаимосвязанных проблем: накопления ошибок на каждом шаге, ограниченной памяти (взрыв KV-кэша, сжатие attention), задержки вознаграждения (агент не видит обратную связь до конца) и экспоненциального роста сложности планирования. Решения включают иерархические архитектуры, суммаризацию состояния, модели-верификаторы и древовидный поиск, но каждое имеет свои компромиссы.

1. Термин: Horizon (горизонт) в контексте агентов

Horizon (горизонт) — максимальное количество шагов (действий), которое агент может выполнить в одной траектории, прежде чем получит финальное вознаграждение или завершит задачу. В Agentic RAG горизонт — это число итераций: запрос → retrieval → размышление → действие → наблюдение → новый запрос.

• Короткий горизонт (1–5 шагов): агент легко справляется, ошибки малы.
• Средний горизонт (6–10 шагов): начинают проявляться эффекты накопления.
• Длинный горизонт (>10 шагов): резкая деградация качества.

Термин «Деградация агента» — ухудшение качества выполнения задачи (падение accuracy, увеличение числа неудачных завершений, рост числа лишних шагов) по мере увеличения длины траектории.

2. Проблема накопления ошибок (Error Accumulation)

На каждом шаге агент совершает действие с вероятностью ошибки ε. Даже если ε мала (например, 0.05), после N шагов вероятность хотя бы одной ошибки:

P(ошибка) = 1 - (1 - ε)^N

Для ε = 0.05, N = 10: 1 - 0.95^10 ≈ 0.401 (40% траекторий содержат ошибку).
Для N = 20: 1 - 0.95^20 ≈ 0.642 (64%).

Типы ошибок

• Retrieval miss: агент не находит нужный документ.
• Reasoning error: LLM делает неверный логический вывод.
• Action error: агент вызывает неправильный инструмент или передаёт неверные параметры.
• Observation misinterpretation: агент неправильно интерпретирует результат вызова.

Каждая ошибка может «заразить» последующие шаги, так как агент строит рассуждение на неверных предпосылках.

Формула накопления (упрощённая модель):

accuracy(N) ≈ (1 - ε)^N

Даже при ε=0.02 после 20 шагов accuracy падает ниже 70%. Это фундаментальное ограничение последовательных решений.

3. Ограниченная память (Memory Constraints)

Агент хранит историю шагов в контексте LLM. Длинные траектории приводят к двум проблемам:

3.1 Взрыв KV-кэша (KV Cache Explosion)

Каждый новый шаг добавляет токены в контекст. При длине шага ~500 токенов и 20 шагах контекст достигает 10 000 токенов. KV-кэш (ключи и значения attention) растёт квадратично относительно длины контекста, вызывая:

• Рост latency (время генерации увеличивается).
• Рост потребления GPU memory (OOM на маленьких картах).

3.2 Сжатие attention (Attention Sink / Lost in the Middle)

LLM склонны «забывать» информацию из середины контекста. Ранние шаги (первые 3–5) могут выпадать из внимания, хотя они критичны для понимания задачи. Это явление называется lost in the middle (LITM).

Экспериментальные данные (Liu et al., 2023): при длине контекста > 2K токенов точность ответа на вопросы по середине падает на 20–30% по сравнению с началом или концом.

3.3 Решения на уровне памяти

• Sliding window: хранить только последние K шагов.
• Summarization: сжимать историю в краткое резюме.
• Selective memory: использовать механизмы внимания, которые ранжируют важность шагов.

4. Задержка вознаграждения (Reward Delay)

В Agentic RAG вознаграждение (успех/неудача) обычно доступно только в конце траектории. Агент не получает промежуточных сигналов, чтобы скорректировать поведение.

Проблема credit assignment: агент не знает, какое действие привело к успеху или ошибке. Если на шаге 2 был сделан неверный retrieval, а на шаге 8 — правильный ответ, агент может ошибочно «наградить» шаг 8.

Влияние на обучение (если агент дообучается с RL):

• Разреженные награды (sparse rewards) замедляют сходимость.
• Требуется больше траекторий для обучения.
• Возможны локальные оптимумы.

Пример: агент для бронирования билетов. На шаге 5 он выбрал неправильный город, но на шаге 9 всё равно успешно завершил (благодаря случайному исправлению). При sparse reward агент не поймёт, что шаг 5 был ошибочным.

Методы смягчения:

• Промежуточные награды (shaped rewards): давать +0.1 за каждый успешный retrieval.
• Reward shaping на основе верификаторов (см. раздел 8).
• Имитационное обучение (imitation learning) на экспертных траекториях.

5. Сложность планирования (Planning Complexity)

Планирование последовательности действий — это NP-сложная задача в общем случае. LLM, даже самые мощные, имеют ограниченную способность к многошаговому планированию.

Почему LLM плохо планируют на длинных горизонтах:

• Отсутствие внутренней модели мира: LLM не строят явную модель переходов между состояниями.
• Экспоненциальный рост пространства поиска: число возможных последовательностей действий растёт как |A|^N, где |A| — количество доступных действий.
• Рекуррентные ошибки: LLM склонны к повторению одних и тех же паттернов (perseveration) или к «зацикливанию» (looping).

Эксперимент (Valmeekam et al., 2023): на задаче Blocks World (перестановка кубиков) GPT-4 решает задачи с 2–3 шагами с accuracy >80%, но с 5–6 шагами accuracy падает до 30%.

Связь с накоплением ошибок: чем длиннее план, тем выше вероятность, что одно из поддействий будет выполнено неверно, и весь план рухнет.

6. Решение: Иерархические агенты (Hierarchical Agents)

Разбиение задачи на подзадачи с разными уровнями абстракции.

Архитектура

• Высокоуровневый агент (manager): планирует крупные шаги (например, «найти документы по теме X», «проверить факты»).
• Низкоуровневые агенты (workers): выполняют конкретные действия (retrieval, вызов API, генерация ответа).

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

• Каждый уровень работает на своём горизонте (manager — 3–5 шагов, worker — 1–2 шага).
• Ошибки изолированы: если worker ошибся, manager может перепланировать.
• Память распределена: manager хранит только абстрактное состояние, worker — только текущий контекст.

Недостатки

• Усложнение архитектуры.
• Нужна чёткая спецификация интерфейсов между уровнями.
• Дополнительные вызовы LLM (overhead).

Пример кода (псевдо):

class HierarchicalAgent:
    def __init__(self):
        self.manager = LLMAgent(system_prompt="plan high-level steps")
        self.worker = LLMAgent(system_prompt="execute one step")
    
    def run(self, task, max_steps=20):
        plan = self.manager.plan(task)  # ["search", "verify", "answer"]
        for step in plan:
            result = self.worker.execute(step)
            if result.error:
                plan = self.manager.replan(task, context)
        return final_answer

7. Решение: Суммаризация состояния (State Summarization)

Сжатие истории шагов в компактное представление, чтобы избежать взрыва контекста.

Методы

• Регулярная суммаризация: каждые K шагов вызывать LLM для генерации краткого резюме.
• Ранжирование важности: использовать эмбеддинги для оценки релевантности каждого шага и выбрасывать наименее важные.
• Структурированная память: хранить историю в виде графа (шаги → узлы, связи → переходы).

Пример реализации

def summarize_history(history, max_tokens=2000):
    if len(history) > 5:
        summary_prompt = f"Summarize the following steps in 2-3 sentences: {history[:-3]}"
        summary = llm(summary_prompt)
        return summary + "\n" + "\n".join(history[-3:])
    else:
        return "\n".join(history)

Проблемы

• Потеря деталей при суммаризации.
• Дополнительные затраты на вызов LLM.
• Необходимость баланса между сжатием и информативностью.

8. Решение: Модели-верификаторы (Verifier Models)

Отдельная модель (обычно меньшего размера), которая проверяет корректность каждого шага агента и даёт промежуточный сигнал.

Как работает

1. Агент генерирует действие.
2. Верификатор оценивает действие (score от 0 до 1).
3. Если score ниже порога, агент перегенерирует или запрашивает уточнение.

Типы верификаторов

• Rule-based: проверка формата, допустимых значений.
• LLM-as-judge: промпт «Оцени, корректен ли этот шаг?».
• Обученный классификатор: fine-tune BERT на парах (шаг, метка корректности).

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

• Раннее обнаружение ошибок (до их накопления).
• Промежуточное вознаграждение для RL.
• Может работать на каждом шаге, не требуя полной траектории.

Недостатки

• Дополнительные вызовы модели.
• Сложность создания качественного верификатора.
• Ложные срабатывания (false positives) могут замедлить агента.

9. Решение: Древесный поиск (Tree Search)

Вместо линейной последовательности шагов агент исследует несколько альтернативных путей параллельно, выбирая лучший.

Методы

• Beam search: на каждом шаге сохранять top-K траекторий.
• Monte Carlo Tree Search (MCTS): симулировать случайные траектории, оценивать их и выбирать наиболее перспективное действие.
• Tree-of-Thoughts (ToT): LLM генерирует несколько вариантов следующего шага, оценивает их и ветвится.

Пример ToT для длинного горизонта

def tree_of_thoughts(problem, depth=3, branches=3):
    root = Node(state=problem)
    for _ in range(depth):
        leaves = get_leaves(root)
        for leaf in leaves:
            candidates = llm.generate(f"Given state: {leaf.state}, propose {branches} next steps")
            for cand in candidates:
                score = verifier.evaluate(cand)
                leaf.add_child(Node(state=cand, score=score))
        # select best path
        root = select_best_path(root)
    return root.path_to_answer()

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

• Устойчивость к ошибкам: если одна ветвь ошибочна, агент может переключиться.
• Лучшее планирование за счёт перебора вариантов.

Недостатки

• Экспоненциальный рост числа вызовов LLM.
• Высокая latency.
• Требует точной функции оценки (верификатора).

10. Сравнительная таблица решений

Пет-проект для закрепления

Задача Реализовать симуляцию агента, который выполняет последовательность действий (например, поиск информации в синтетической базе фактов) и измерить accuracy при разной длине горизонта. Сравнить базового агента (линейный) с иерархическим и агентом с верификатором.

Инструменты Python, LangChain (или просто OpenAI API), библиотека для тестирования (pytest).

Шаги:

1. Создать синтетический датасет: 100 задач, каждая требует от 5 до 20 шагов. Каждый шаг — вызов функции search(query), которая возвращает факт с вероятностью ошибки 5% (имитация неверного retrieval).
2. Реализовать базового агента: на каждом шаге LLM выбирает следующий запрос на основе истории.
3. Реализовать иерархического агента: manager разбивает задачу на 3–5 подзадач, worker выполняет каждую подзадачу за 1–2 шага.
4. Реализовать агента с верификатором: после каждого шага маленькая LLM (например, GPT-4o-mini) оценивает, корректен ли шаг; если нет — агент переспрашивает.
5. Запустить все три варианта на датасете, замерить accuracy (доля успешно завершённых задач) и среднее число шагов.

Ожидаемый результат

• Базовый агент: accuracy падает с 95% (5 шагов) до 30% (20 шагов).
• Иерархический: accuracy держится 80–90% на всех горизонтах, но число шагов может вырасти из-за overhead.
• С верификатором: accuracy 85–95%, но число шагов увеличивается на 10–20% из-за повторных попыток.

Вывод на длинных горизонтах иерархия и верификация дают наибольший выигрыш, но требуют дополнительных ресурсов.

Связь с другими вопросами

Навигация

• Предыдущий: 565
• Следующий: 567
• Индекс: 00. Индекс разборов