3,583 papers
arXiv:2606.18648 72 17 июня 2026 г. FREE

DelveAgent Framework: три принципа для сложных многошаговых задач — переплнирование, двухуровневая память, иерархическая проверка

КЛЮЧЕВАЯ СУТЬ
Разобрали 326 провалов лучших AI-агентов на сложных задачах — и нашли закономерность: 46% всех ошибок начинаются не с незнания, а с того что план разваливается на первом препятствии и модель везёт эту ошибку до самого конца. DelveAgent позволяет решать многошаговые задачи без накопления ошибок — через явное переплнирование, двойную память и двухуровневую проверку прямо в промпте. Три XML-блока в одном промпте создают три отдельных слоя контроля: план пересматривается после каждого шага, факты и выводы хранятся в разных журналах, финальный аудитор смотрит на весь ответ целиком — даже Gemini Deep Research справлялся лишь с третью задач без этой структуры.
Адаптировать под запрос

TL;DR

Когда просишь модель решить сложную многошаговую задачу, она часто "застревает" на ошибке в середине и везёт её до конца. Исследователи изучили 326 провалов лучших AI-агентов на сложных научных задачах и нашли три системных слабости: план разваливается при первой же неудаче (46% ошибок), решения из предыдущих шагов не переносятся дальше (23%), никто не проверяет промежуточные результаты (31%). Даже сильнейший агент — Gemini Deep Research — справился лишь с третью задач.

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

Принципы фреймворка — три отдельных промпт-слоя, которые можно дословно внедрить в обычный диалог с LLM. Метод работает за один длинный промпт или через серию запросов с явными фазами проверки.


🔬

Схема метода

(Один расширенный промпт ИЛИ три последовательных запроса)

ФАЗА 1 — Планирование (начало диалога)
  → Детальный пошаговый план с критериями проверки каждого шага
  → Фиксация ключевых фактов и ограничений задачи

ФАЗА 2 — Выполнение (цикл на каждый шаг)
  → Выполнить шаг
  → Локальная проверка: корректны ли детали этого шага?
  → Пересмотр плана: нужно ли скорректировать следующие шаги?
  → Обновить журнал "что сработало"

ФАЗА 3 — Финальная рефлексия (конец)
  → Глобальная проверка: отвечает ли итог на исходный вопрос?
  → Нет ли внутренних противоречий?
  → Если нашёл — исправь и укажи что было не так

🚀

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

Задача: У тебя небольшое кафе в Москве, хочешь понять — стоит ли открывать второй вид выручки: доставка ланч-боксов в офисы. Нужен структурированный анализ с цифрами, рисками и решением.

Промпт:


Оцени перспективность запуска доставки ланч-боксов в офисы 
для кафе ~30 посадочных мест в Москве (ЮЗАО, средний чек 600₽).
Цель: принять решение — запускать или нет, и если да — как именно.



Прежде чем начать — составь пошаговый план анализа.
Для каждого шага укажи: что исследуем, какие данные нужны, 
по каким критериям решим что шаг выполнен корректно.



  
    Зафикси ключевые факты и ограничения прямо сейчас:
    — бюджет на запуск: до 150 000₽
    — команда: 2 повара, 1 управляющий
    — рабочие часы: 8:00–20:00
    — целевой радиус доставки: 3 км
  
  
    После каждого шага анализа добавляй сюда:
    — какой подход сработал, что скорректировал, что важно помнить дальше
  



  Для каждого шага из плана выполни по порядку:
  1. Проведи анализ по шагу
  2. [Локальная проверка] Проверь: учтены ли все ограничения из KnowledgeBase? 
     Нет ли противоречий с предыдущими шагами?
  3. [Пересмотр плана] Нужно ли скорректировать следующие шаги с учётом выводов?
  4. Обнови ExperienceBase



  После завершения всех шагов — глобальная проверка итога:
  — Отвечает ли вывод на исходный вопрос "запускать или нет"?
  — Учтены ли все ограничения из KnowledgeBase?
  — Нет ли внутренних противоречий между шагами?
  — Если нашёл проблемы — исправь и явно укажи что пересмотрел.
  Финальный ответ: решение + 3 первых шага при запуске / 2 причины отказа.

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


🧠

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

LLM плохо держит план под давлением. Когда задача длинная и многошаговая, модель "съезжает" — первая ошибка в шаге 2 незаметно ломает шаги 3, 4, 5. Это не баг конкретной модели, это системный паттерн: модель генерирует следующий токен, опираясь на предыдущий контекст. Если контекст испорчен — ошибка множится.

LLM хорошо следует явным структурам. Когда в промпте прописаны конкретные действия ("после каждого шага проверь противоречия"), модель выполняет их буквально. Структура убирает двусмысленность — вместо "думай хорошо" мы говорим "вот точный алгоритм на каждой итерации".

Два журнала закрывают два разных разрыва. KnowledgeBase фиксирует факты до начала — модель не "теряет" ограничения в середине длинного ответа. ExperienceBase копит выводы по ходу — модель реально переносит инсайт из шага 2 в шаг 5, а не начинает с нуля. Финальная FinalReflection — это независимый аудитор, который смотрит на весь ответ целиком, а не на последний кусок.

Рычаги управления: - KnowledgeBase — добавь или убери ограничения. Больше ограничений → строже ответ - ExperienceBase — убери, если задача простая. Оставь, если шагов > 4 - Количество шагов в плане → явно попроси "не более 5 шагов" для экономии - FinalReflection → добавь конкретный критерий ("проверь, не превышает ли итоговый бюджет 150 000₽")


📋

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


{задача} — опиши кратко что нужно сделать и какой результат нужен.



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



  
    Ключевые факты и ограничения:
    {ограничение_1}
    {ограничение_2}
    {ограничение_3}
  
  
    [Заполняется по ходу выполнения: что сработало, что скорректировал]
  



  Для каждого шага плана:
  1. Выполни шаг
  2. [Локальная проверка] Учтены ли ограничения? Нет ли противоречий?
  3. [Пересмотр плана] Нужно ли скорректировать следующие шаги?
  4. Обнови ExperienceBase



  Глобальная проверка итога:
  — Отвечает ли на исходную задачу?
  — Нет ли противоречий между шагами?
  — Соблюдены ли все ограничения из KnowledgeBase?
  Исправь если нашёл проблему. Укажи что именно пересмотрел.
  Финал: {формат_результата}

Плейсхолдеры: - {задача} — что нужно сделать и зачем - {ограничение_1-3} — бюджет, сроки, аудитория, доступные ресурсы - {формат_результата} — например "решение + 3 первых шага" или "таблица плюсов и минусов"


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

Вот шаблон DelveAgent Framework. Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.

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

LLM спросит про ограничения задачи и желаемый формат результата — потому что KnowledgeBase и FinalReflection нужно заполнить конкретикой, иначе проверка будет пустой. Она возьмёт паттерн из шаблона и адаптирует под твою задачу.


⚠️

Ограничения

⚠️ Простые задачи: Метод избыточен для вопросов с одним шагом — модель будет имитировать процесс там, где он не нужен. Используй для задач с 4+ зависимыми шагами.

⚠️ Контекстное окно: Длинный промпт + несколько итераций ExperienceBase + финальная рефлексия могут съесть много токенов. В длинных задачах чисти ExperienceBase каждые 3-4 шага — оставляй только ключевые выводы.

⚠️ Экспериментальный дизайн: Даже сам DelveAgent не превзошёл базовый уровень в задачах создания экспериментальных протоколов с нуля. Метод лучше работает на аналитике и многошаговом рассуждении, чем на открытом творческом синтезе.

⚠️ Фактическая точность: Двухуровневая проверка снижает внутренние противоречия, но не защищает от галлюцинаций — если модель уверенно придумала факт, она так же уверенно его "проверит". Для задач где точность критична — верифицируй факты отдельно.


🔗

Ресурсы

Название: Deep Research in Physical Sciences: A Multi-Agent Framework and Comprehensive Benchmark

Авторы: Yigeng Jiang, Tengchao Yang, Taoyong Cui и др.

Организации: Shanghai Artificial Intelligence Laboratory, Xiamen University, Institute of Physics (Chinese Academy of Sciences), Tongji University, UCL, Wuhan University

Бенчмарк: PhySciBench — 200 вопросов по физике и химии, 6 категорий задач

Агенты-бейслайны: Gemini Deep Research, OpenAI Deep Research, ODR-smolagents


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

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

Разобрали 326 провалов лучших AI-агентов на сложных задачах — и нашли закономерность: 46% всех ошибок начинаются не с незнания, а с того что план разваливается на первом препятствии и модель везёт эту ошибку до самого конца. DelveAgent позволяет решать многошаговые задачи без накопления ошибок — через явное переплнирование, двойную память и двухуровневую проверку прямо в промпте. Три XML-блока в одном промпте создают три отдельных слоя контроля: план пересматривается после каждого шага, факты и выводы хранятся в разных журналах, финальный аудитор смотрит на весь ответ целиком — даже Gemini Deep Research справлялся лишь с третью задач без этой структуры.

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

Модель не "думает хуже" на длинных задачах. Она генерирует следующий токен опираясь на предыдущий контекст. Если шаг 2 испорчен — шаги 3, 4, 5 строятся на гнилом основании. Явная структура убирает двусмысленность: вместо "думай хорошо" — точный алгоритм на каждой итерации. Три фазы в промпте: планирование с критериями проверки → цикл выполнения с локальным аудитором → финальная рефлексия со взглядом на весь ответ целиком. Это как конвейер на заводе — каждый этап делает своё, а не всё разом.

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

LLM хорошо следует явным алгоритмам и плохо держит неявный контроль качества. Два журнала закрывают два разных разрыва. KnowledgeBase фиксирует ограничения до начала — модель не теряет их в середине длинного ответа. ExperienceBase копит выводы по ходу — инсайт из шага 2 реально переносится в шаг 5, а не сбрасывается. 31% ошибок — это выполнение без проверки, не незнание. Локальный аудитор на каждом шаге режет эти 31% прямо в процессе, не в конце. Финальная рефлексия — независимый взгляд на весь ответ, а не на последний кусок. Она ловит то, что локальные проверки пропустили.

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

Многошаговый анализ с 4+ зависимыми шагами — бизнес-анализ, исследования, стратегические решения, разбор конкурентов, финансовые оценки. Особенно когда ошибка в начале ломает всё дальше и нужен прозрачный ход рассуждений. НЕ подходит для простых одношаговых запросов — модель будет имитировать сложный процесс там где он не нужен. Также слабее работает на открытом творческом синтезе (создание исследовательских протоколов с нуля) — метод сильнее на аналитике и рассуждениях, чем на генерации.

Мини-рецепт

1. Опиши задачу и результат: В блоке — что нужно сделать и какой формат результата нужен на выходе. Не просто "разбери тему", а "разбери и дай решение + 3 первых шага".

2. Зафикси ограничения заранее: В — бюджет, сроки, аудитория, ресурсы до начала работы. Модель не "потеряет" их в середине длинного ответа.

3. Пропиши цикл явно: В — для каждого шага плана: выполни → локальная проверка на противоречия с ограничениями → нужно ли скорректировать следующие шаги → обнови журнал выводов.

4. Добавь финального аудитора: В — глобальная проверка: отвечает ли итог на исходный вопрос, нет ли внутренних противоречий, соблюдены ли все ограничения. Если нашёл проблему — исправь и назови что именно пересмотрел.

Примеры

[ПЛОХО] : Проанализируй стоит ли мне запустить доставку ланч-боксов в офисы. Кафе в Москве, 30 мест, средний чек 600₽. Модель выдаст общие рассуждения. Может забыть про ограничение по бюджету к шагу 4. Финальный вывод не будет проверен на противоречия.
[ХОРОШО] : Оцени перспективность запуска доставки ланч-боксов в офисы для кафе в Москве (ЮЗАО, 30 мест, средний чек 600₽). Цель: решение — запускать или нет + 3 первых шага при запуске. бюджет на запуск: до 150 000₽ команда: 2 повара, 1 управляющий рабочие часы: 8:00–20:00 целевой радиус доставки: 3 км [заполняется по ходу: что сработало, что скорректировал] Для каждого шага плана: 1. Выполни шаг 2. [Локальная проверка] Учтены ли ограничения из KnowledgeBase? Нет ли противоречий с предыдущими шагами? 3. [Пересмотр плана] Нужно ли скорректировать следующие шаги? 4. Обнови ExperienceBase Глобальная проверка: отвечает ли итог на исходный вопрос? Нет ли противоречий между шагами? Соблюдены ли все ограничения из KnowledgeBase? Если нашёл проблему — исправь и укажи что пересмотрел. Финал: решение + 3 первых шага. Модель явно пройдёт все фазы. Напишет план с критериями, потом каждый шаг с маркером локальной проверки, накопит выводы в журнале. В конце — явная рефлексия: нашла противоречие — назовёт, не замолчит.
Источник: Deep Research in Physical Sciences: A Multi-Agent Framework and Comprehensive Benchmark
ArXiv ID: 2606.18648 | Сгенерировано: 2026-06-18 04:32

Проблемы LLM

ПроблемаСутьКак обойти
Ошибка в середине длинной задачи портит все следующие шагиМодель строит каждый следующий шаг на предыдущем контексте. Ошибка в шаге 2 незаметно "въезжает" в шаг 3, 4, 5. Модель не останавливается и не проверяет — просто едет дальше. Это системный паттерн, а не проблема конкретной моделиПосле каждого шага явно попроси проверить: "есть ли противоречия с предыдущими шагами? Нужно ли скорректировать следующие?" Модель не делает это сама — но делает если попросить
Ограничения из начала промпта тонут к середине ответаЗадал в начале "бюджет 150 000₽, команда 2 человека". К шагу 5 модель об этом "не помнит" — не потеряла, но ранний контекст слабее влияет на поздние токены. В длинных задачах ограничения перестают работатьВынеси ограничения в отдельный блок . Добавь в петлю выполнения явную проверку: "учтены ли все ограничения из KnowledgeBase?" — модель будет возвращаться к ним на каждом шаге

Методы

МетодСуть
Двухуровневая память — факты отдельно, выводы отдельноРаздели контекст на два блока. Первый: — факты и ограничения задачи, заполняешь сам до начала ("бюджет 150к", "срок 2 недели"). Второй: — выводы по ходу, заполняет модель ("шаг 3 скорректирован, потому что..."). Почему работает: два разных разрыва закрываются разными инструментами. KnowledgeBase не даёт ограничениям "утонуть" в длинном контексте. ExperienceBase переносит вывод из шага 2 в шаг 5 — без него модель начинает каждый шаг почти с нуля. Когда применять: задачи с 4+ зависимыми шагами. Для простых вопросов излишне
Явная петля: перепланирование + проверка на каждом шагеПосле каждого шага задачи добавь в промпт два вопроса: (1) "есть ли противоречия с предыдущими шагами и ограничениями?" — локальная проверка, (2) "нужно ли скорректировать следующие шаги с учётом выводов?" — пересмотр плана. В конце добавь глобальную проверку: "отвечает ли итог на исходный вопрос? нет ли внутренних противоречий?". — петля на каждый шаг. — аудитор всего ответа целиком. Почему работает: без явной инструкции модель не проверяет — просто генерирует следующий токен. С инструкцией делает это буквально

Тезисы

ТезисКомментарий
Почти половина провалов в сложных задачах — это план, а не знанияКогда LLM ошибается в многошаговой задаче, причина распределяется примерно так: 46% — план разваливается при первой неудаче, 31% — ошибка в выполнении шага, 23% — потеря нужного факта или ограничения. Это значит: чаще всего ломается не то что модель "не знает", а то что она не пересматривает маршрут. Применяй как диагностику: если модель дала плохой результат — сначала проверяй план, потом шаги, потом факты
📖 Простыми словами

Deep Research in Physical Sciences: A Multi-AgentFramework and Comprehensive Benchmark

arXiv: 2606.18648

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

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

Исследование выделило три конкретных косяка, на которых горят даже топы вроде Gemini Deep Research. Почти в половине случаев (46%) у агентов просто разваливается план при первой же неудаче — они тупят и не знают, что делать дальше. Еще в 23% случаев они тупо теряют данные между шагами, как будто у них деменция: нашли важное число в начале, но забыли вставить его в итоговую формулу. И самое дикое — в 31% случаев никто не проверяет промежуточный результат. Модель просто верит себе на слово, даже если цифры противоречат законам физики.

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

Короче, доверять AI-агентам «под ключ» пока нельзя — они справляются максимум с 30% реальных вызовов. Главный вывод: если хочешь адекватный результат, не давай модели делать всё за один присест. Нужно либо дробить задачу на куски и проверять каждый лично, либо внедрять жесткие фильтры на каждом этапе. Пока у нейронок не появится функция «стоп, я несу херню», они так и будут выдавать уверенный бред вместо глубоких исследований.

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

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

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