3,583 papers
arXiv:2608.14216 71 14 авг. 2026 г. FREE

MazeRunner: три роли-агента и общая память задач против зацикливания LLM на провальных ветках

КЛЮЧЕВАЯ СУТЬ
Обнаружено: LLM-агент, застряв в тупике, винит не ту причину — и из-за этой ошибки бросает рабочий путь, который на самом деле вёл к цели. Метод MazeRunner позволяет вести сложное расследование с несколькими гипотезами без зацикливания на одной мёртвой ветке. Фишка — отдельная роль-Ревьюер не продолжает работу, а только копается в причине провала, не смешивая это с попыткой попробовать снова. Вся история задач и находок живёт в отдельной таблице, а не тонет в диалоге — зацепка с 30-го шага не потеряется к 90-му.
Адаптировать под запрос

TL;DR

MazeRunner — система из трёх ролей-агентов (Стратег, Исполнитель, Ревьюер), которые работают по кругу и делятся общей памятью задач и найденных зацепок. Стратег решает, что делать дальше, Исполнитель делает и приносит результат, а отдельный Ревьюер занимается только разбором неудач — не продолжает работу, а копается в причине провала.

Главная находка: когда LLM-агент долго работает над сложной задачей с множеством возможных путей, он застревает на одной неудачной ветке. После провала он не переключается на альтернативу, а повторяет попытки заново — авторы называют это "глубокой ямой" (depth-first trap). Хуже того, модель часто неправильно определяет причину провала — связывает её с далёким прошлым шагом, а не с реальной проблемой, и из-за этой ошибки бросает рабочий путь, который на самом деле был верным.

Метод решает это разделением функций: пока одна роль ("Исполнитель") продолжает пробовать, отдельная роль ("Ревьюер") специально анализирует, почему именно не получилось, не смешивая диагностику с попытками продолжить. А вся структура задач и найденных зацепок хранится отдельно от диалога — как внешняя таблица, а не в "голове" модели — чтобы важная находка с 50-го шага не потерялась к 90-му.


🔬

Схема метода

ШАГ 1 (Стратег): Разбивает общую цель на задачи → обновляет граф задач (что сделано, что в очереди, какие ветки открылись)
ШАГ 2 (Исполнитель): Берёт одну конкретную задачу, выполняет → записывает результат и новые зацепки в общую память
ШАГ 3 (Ревьюер) — включается ТОЛЬКО при провале: Анализирует именно причину неудачи (не продолжает работу) → выдаёт диагноз и рекомендацию: повторить иначе, откатиться, переключиться на другую ветку

Цикл повторяется. Задачи и зацепки хранятся в отдельной "таблице состояния", не растворяются в общем диалоге.

Все три роли — это один и тот же LLM, который последовательно играет разные функции. В реальной системе это отдельные запросы с разным контекстом; в чате это можно эмулировать одним длинным промптом с явным разделением ролей.


🚀

Пример применения

Задача: Вы предприниматель, продажи в интернет-магазине упали, и непонятно почему. Есть пять гипотез: реклама перестала работать, цена неконкурентна, сайт тормозит, конкурент демпингует, сезонный спад. Проверка каждой гипотезы требует нескольких шагов, и есть риск залипнуть на одной, пока остальные важнее.

Промпт:

Ты работаешь в трёх ролях по очереди: Стратег, Исполнитель, Ревьюер.

ЦЕЛЬ: найти реальную причину падения продаж в интернет-магазине {название}.

СТРАТЕГ: разбей цель на проверяемые гипотезы-задачи. Веди список:
[Задача] — [статус: не начата/в работе/провалена/подтверждена] — [зависит от]

ИСПОЛНИТЕЛЬ: возьми одну задачу из списка, распиши что нужно проверить и какие данные/шаги нужны. Зафиксируй результат и любые новые "зацепки" — детали, которые могут быть важны позже, даже если сейчас не относятся к текущей гипотезе.

РЕВЬЮЕР: если задача провалилась (гипотеза не подтвердилась) — не переходи сразу к следующей. Сначала разбери:
1) Почему конкретно не подтвердилось (данные? неверная методика проверки? гипотеза неверна?)
2) Есть ли зацепки из провала, которые указывают на другую гипотезу
3) Рекомендация: закрыть гипотезу / проверить иначе / переключиться на другую

Начни с составления списка задач у Стратега. Данные о магазине: {вставь метрики, что знаешь}.

Результат: Модель сначала выдаст таблицу из 5 гипотез со статусами. Затем начнёт проверять первую — например, рекламу. Если гипотеза не подтвердится, вместо того чтобы просто написать "гипотеза не верна, дальше", отдельным блоком разберёт: почему не подтвердилась, какие детали заметила по пути (например, "трафик стабилен, но конверсия упала именно на странице оплаты") — и это станет новой зацепкой для проверки гипотезы про сайт. Весь список гипотез и статусов останется видимым на протяжении всего разговора, вместо того чтобы забыться через 10 сообщений.


🧠

Почему это работает

LLM плохо держит длинную цепочку причинно-следственных связей в контексте — чем дальше назад находка, тем выше риск, что модель её "забудет" или свяжет провал с неправильным шагом. Это не потому что модель "глупая" — просто в потоке диалога всё сливается в общий текст, и важная деталь с 30-го сообщения теряется среди остального шума.

При этом LLM хорошо умеет играть отдельную, узкую роль, если её явно попросить сфокусироваться только на одной задаче — например, только на диагностике, без отвлечения на "что делать дальше". Разделение ролей заставляет модель не смешивать два разных типа мышления: "давай попробуем ещё раз" и "давай разберёмся, что пошло не так" — это разные режимы, и смешивание их в одном потоке ведёт к зацикливанию.

Рычаги для адаптации: - Количество ролей можно урезать до двух (Исполнитель + Ревьюер), если задача проще - Таблицу задач/зацепок можно вести вручную в отдельном сообщении и просить модель обновлять её каждый раунд — так она не потеряется в длинном диалоге - Критерий "провал" можно заменить под свою задачу — не только "не сработало", но и "результат неубедительный", "данных недостаточно"


📋

Шаблон промпта

Ты работаешь в трёх ролях по очереди: Стратег, Исполнитель, Ревьюер.

ЦЕЛЬ: {опиши конечную цель}

СТРАТЕГ: разбей цель на задачи/гипотезы. Веди таблицу:
[Задача] — [статус] — [зависит от]

ИСПОЛНИТЕЛЬ: возьми задачу из очереди, выполни/проверь её. Зафиксируй результат и любые побочные "зацепки" — детали, которые могут быть полезны позже.

РЕВЬЮЕР (включается при провале задачи): не продолжай сразу дальше. Разбери:
1) Почему именно не получилось
2) Какие зацепки из этого провала стоит использовать
3) Рекомендация: повторить иначе / переключиться на другую ветку / отложить

Данные: {вставь то, что уже известно}

🚀 Быстрый старт — вставь в чат:

Вот шаблон MazeRunner (Стратег-Исполнитель-Ревьюер). Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.

[вставить шаблон выше]

LLM спросит про конечную цель и что уже известно — потому что без этого Стратег не сможет разбить задачу на проверяемые шаги. Она возьмёт паттерн трёх ролей и таблицы состояния и подстроит под вашу ситуацию.


⚠️

Ограничения

⚠️ Нет настоящей персистентной памяти в чате: в исследовании таблица задач и улик хранится во внешней системе отдельно от диалога модели. В обычном чате это придётся эмулировать вручную — просить модель каждый раз выводить обновлённую таблицу, иначе она всё равно может "потерять" зацепку через много сообщений.

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

⚠️ Оригинальная система требует инфраструктуру: сама система MazeRunner работает с реальными инструментами (сканирование сети, выполнение команд) через код — это неприменимо напрямую в чате. Извлекать стоит только принцип оркестрации ролей, не саму систему.


🔗

Ресурсы

MazeRunner: Nonlinear Task and Clue Orchestration for LLM-driven Black-Box Automated Penetration Testing. Zhenyuan Li, Yi Jiang, Junjie Cheng, Yaokun Li, Jing Qiu, Shouling Ji — Zhejiang University, Guangzhou University. Sci China Inf Sci (на рецензии).


📋 Дайджест исследования

Ключевая суть

Обнаружено: LLM-агент, застряв в тупике, винит не ту причину — и из-за этой ошибки бросает рабочий путь, который на самом деле вёл к цели. Метод MazeRunner позволяет вести сложное расследование с несколькими гипотезами без зацикливания на одной мёртвой ветке. Фишка — отдельная роль-Ревьюер не продолжает работу, а только копается в причине провала, не смешивая это с попыткой попробовать снова. Вся история задач и находок живёт в отдельной таблице, а не тонет в диалоге — зацепка с 30-го шага не потеряется к 90-му.

Принцип работы

Три роли работают по кругу, не смешивая функции. Стратег смотрит на карту целиком и решает, куда идти дальше. Исполнитель делает один конкретный шаг и записывает результат. Если шаг провалился — включается отдельный Ревьюер: не продолжает движение, а разбирает — почему не сработало, есть ли скрытые зацепки, стоит ли вообще возвращаться на этот путь. Три разные головы вместо одной запутавшейся в собственных попытках.

Почему работает

LLM плохо держит длинную цепочку причин и следствий в контексте. Чем дальше назад находка, тем выше шанс, что модель свяжет провал с неправильным шагом. Дело не в том, что модель глупая — просто в потоке диалога всё сливается в общий текст, и деталь с 30-го сообщения тонет в шуме. Зато LLM отлично играет узкую роль, если попросить её сфокусироваться на одном деле — только диагностика, без "что делать дальше". Разделение ролей не даёт смешать два разных режима мышления — "пробуем ещё раз" и "разбираемся, что пошло не так". Именно это смешивание и ведёт к зацикливанию на одной ветке.

Когда применять

Сложные многошаговые расследования → конкретно для диагностики с несколькими гипотезами и развилками, особенно когда есть риск залипнуть на одной ветке, пока другие важнее. Не подходит для простых задач с одним понятным путём — там три роли и таблица только замедлят работу и сожгут лишние токены.

Мини-рецепт

1. Раздели роли: Стратег решает что делать, Исполнитель делает и приносит результат, Ревьюер включается только при провале
2. Веди таблицу: задача — статус — от чего зависит, проси модель обновлять её каждый раунд
3. При провале — стоп: не переходи сразу дальше, сначала отдельным блоком разбери причину
4. Собирай зацепки: даже провальный шаг может выдать деталь, полезную для совсем другой гипотезы

Примеры

[ПЛОХО] : Проверь гипотезу про рекламу. Не сработало? Ладно, проверяй цену.
[ХОРОШО] : Гипотеза про рекламу не подтвердилась. Прежде чем перейти к цене — разбери отдельно: почему именно не подтвердилась, какие детали заметил по пути (например: трафик стабилен, но конверсия упала на странице оплаты), и стоит ли из-за этой детали сначала проверить сайт, а не цену.
Источник: MazeRunner: Nonlinear Task and Clue Orchestration for LLM-driven Black-Box Automated Penetration Testing
ArXiv ID: 2608.14216 | Сгенерировано: 2026-08-17 05:24

Проблемы LLM

ПроблемаСутьКак обойти
Застревание на провальной веткеМодель работает над сложной задачей с несколькими путями решения. После неудачи не переключается на альтернативу, а повторяет тот же провальный путь заново. Проблема проявляется в любых длинных многошаговых задачах с ветвлением: расследованиях, диагностике, планированииВведи отдельную роль, которая только диагностирует провал и явно рекомендует: повторить иначе, откатиться или переключиться на другую ветку. Не позволяй модели продолжать работу и анализировать причину провала в одном и том же шаге
Неверное определение причины провалаКогда что-то не получается, модель часто связывает неудачу с давним шагом, а не с реальной проблемой. Из-за этой ошибки она может бросить рабочий путь, который на самом деле верный. Возникает потому что модель держит в контексте длинную цепочку шагов и путает, где именно случился сбойПопроси модель явно перед выводом диагноза перечислить все шаги от начала ветки и указать, на каком именно шаге и почему сломалось. Требуй конкретную привязку к шагу, а не общий вывод "не сработало"

Методы

МетодСуть
Отдельная роль-ревьюер только для разбора провалаПосле неудачи не проси модель сразу "попробовать снова" или "перейти к следующему". Сначала запусти отдельный шаг: "разбери только почему не получилось, не предлагай следующий шаг". 1) причина провала 2) какие детали заметил по пути 3) рекомендация: повторить/откатиться/переключиться. Работает потому что "продолжать работу" и "искать причину сбоя" — разные типы мышления, и смешение их в одном ответе ведёт к автоматическому повторению старой стратегии вместо реального анализа. Применяй в длинных расследованиях и диагностике с несколькими гипотезами. Не нужен для задач с одним понятным путём без веток
Внешняя таблица задач и зацепок вместо памяти в диалогеВеди отдельную таблицу состояния: [Задача][статус][зависит от], плюс список побочных находок ("зацепок"), которые пока не относятся к текущей гипотезе, но могут понадобиться позже. Проси модель выводить обновлённую таблицу целиком каждый раунд, а не держать её "в голове". Работает потому что в потоке диалога детали растворяются в общем тексте, и находка с 30-го сообщения теряется среди шума — отдельная таблица не даёт ей исчезнуть. Применяй когда диалог длинный (20+ сообщений) и есть несколько параллельных гипотез. Избыточно для короткой задачи в 2-3 шага

Тезисы

ТезисКомментарий
Разделение "действовать" и "разбирать провал" на разные шаги снижает зацикливаниеКогда модель в одном ответе и продолжает работу, и объясняет неудачу — она склонна просто повторить прежнюю стратегию, потому что не выделяет отдельного "режима анализа". Разбивка на два явных шага (сначала только диагноз, потом только действие) заставляет модель реально разобрать причину, а не проскочить её. Применяй: после любой неудачи в чате сначала пиши отдельным сообщением "только разбери почему не сработало, не предлагай что делать дальше" — и лишь затем проси следующий шаг
📖 Простыми словами

MazeRunner: Nonlinear Task and Clue Orchestration forLLM-driven Black-Box Automated Penetration Testing

arXiv: 2608.14216

Суть MazeRunner в том, что обычные нейронки тупеют, когда задача становится слишком длинной и запутанной. В пентесте — взломе систем на заказ — нельзя просто идти по прямой, там миллион тупиков. Стандартная LLM в таких условиях быстро превращается в золотую рыбку: она забывает, что нашла три шага назад, и начинает долбиться в закрытую дверь, пока не кончится контекст. Авторы решили эту проблему через нелинейное управление задачами, разделив «мозги» системы на три изолированные роли, которые общаются через общую базу знаний.

Это как если бы ты пытался выбраться из огромного лабиринта не в одиночку, а целой командой с рациями. Один стоит на вышке и рисует карту, второй бегает по коридорам, а третий — самый нудный — сидит у каждого тупика и дотошно выясняет, почему здесь не пройти. Формально ты всё ещё один игрок, но по факту у тебя есть внешняя память, которая не дает забыть, что в левом крыле ловить нечего, даже если ты провел там пять часов.

Внутри работают три агента: Стратег, Исполнитель и Ревьюер. Стратег не лезет в код, он только раскидывает приоритеты в «списке дел». Исполнитель — это рабочая лошадка, которая берет задачу, получает по лицу от системы защиты и приносит логи. Но главный кайф здесь в Ревьюере. Он не пытается исправить ошибку на ходу, его работа — провести «вскрытие» неудачи и обновить общую базу зацепок. Благодаря этому система не галлюцинирует, а опирается на структурированную память, где каждая находка — это твердый факт, а не кусок рыхлого диалога.

Хотя систему гоняли на кибербезопасности, принцип универсален. Это идеальная схема для любого сложного процесса, где есть риск «залипнуть» на одной гипотезе: от отладки огромного кода до маркетингового анализа, когда у тебя падают продажи и причин может быть десяток. Вместо того чтобы просить чат-бота «решить проблему», ты заставляешь его работать через внешний стек задач, где провал на одном этапе не ломает всю логику, а просто добавляет данных в общую копилку.

Короче: MazeRunner доказывает, что для решения сложных задач не нужна «супер-умная» модель, нужна правильная архитектура. Разделение на роли и внешнюю память лечит главную болезнь LLM — потерю фокуса в длинных цепочках рассуждений. Если хочешь, чтобы нейронка не тупила на 50-м сообщении, перестань кормить её простынями текста и заставь её работать как команду с жестким менеджментом. Кто не структурирует хаос, тот обречен бесконечно перечитывать свои же ошибки.

Работа с исследованием

Адаптируйте исследование под ваши задачи или создайте готовый промпт на основе техник из исследования.

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с