3,583 papers
arXiv:2610.10184 71 7 окт. 2026 г. FREE

Двухэтапный агент с документацией под рукой: формулировка отдельно, код отдельно

КЛЮЧЕВАЯ СУТЬ
Парадокс: современная LLM почти всегда правильно придумывает модель задачи, но код под конкретную библиотеку у неё падает. Без агентов рабочими выходят лишь около 15% скриптов. Метод позволяет получать скрипт, который запускается с первого раза: до 80% на простых задачах планирования, рост примерно в 4 раза. Сначала один агент формулирует модель без кода, потом второй пишет код и сверяет каждую функцию с документацией. Модель перестаёт вспоминать API по памяти и начинает его проверять.
Адаптировать под запрос
⚡

TL;DR

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

Главная находка: придумать модель современным LLM почти всегда по силам, а вот написать код под конкретную библиотеку не получается. Если просто попросить модель одним запросом, модель уверенно использует функции, которых нет, или вызывает существующие с неверными параметрами. Скрипт падает. В исследовании без агентов рабочими выходили лишь около 15% скриптов.

Суть метода: не заставлять модель вспоминать API по памяти, а дать ей возможность его проверить. С двухэтапной схемой и поиском по документации доля скриптов, которые запускаются сразу, выросла примерно в четыре раза. На простых задачах она дошла почти до 80%. Сложные, тесно связанные задачи (логистика склада с транспортом и сборкой) остались проблемой.

🔬

Схема метода

ШАГ 1 (Формулировщик, без инструментов):
  описание задачи + данные → план модели: переменные, ограничения, цель
  (до 10 обращений к LLM)

ШАГ 2 (Исполнитель, с инструментами документации):
  план → поиск функций в документации → проверка → сборка кода
  (до 6 инструментов поиска/проверки, до 50 обращений к LLM)

ВЫХОД: самостоятельный Python-скрипт, который читает данные,
       строит модель, решает и выводит расписание

СРАВНЕНИЕ:
  (б) один агент делает оба шага с инструментами
  (в) один запрос к LLM, без инструментов — базовый вариант

Шаги идут как отдельные агенты (в Langflow это отдельные компоненты). В обычном чате или в Claude Code это два последовательных этапа одной задачи.

🚀

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

Задача: Мебельная фабрика в Подмосковье. Восемь заказов проходят четыре станка: раскрой, кромление, сверление, сборка. У каждого заказа свой порядок операций и своё время на станке. Нужно расписание, при котором все заказы закончатся как можно раньше. Это классическая «задача цеха» (job-shop). Она в сильной зоне метода: простая структура, много готовых примеров.

Промпт (для Claude Code или другого агента с доступом к документации библиотеки):

Задача: составить расписание цеха мебельной фабрики и вывести код на Python.

ЭТАП 1. Формулировка. Пока не пиши код и не трогай документацию.
Опиши модель словами и списками:
- какие переменные решения нужны;
- какие ограничения (порядок операций внутри заказа, один станок = одна операция
  одновременно, время переналадки не учитываем);
- какая целевая функция.
Покажи мне план и остановись.

ЭТАП 2. Реализация (после моего «ок»).
Используй библиотеку OR-Tools CP-SAT.
Правила:
1. Перед использованием любой функции найди её в документации
   (папка docs/ или инструмент поиска) и проверь параметры.
2. Не используй функции, которых не нашёл в документации.
3. Если скрипт упал — прочитай ошибку, найди нужную функцию в документации,
   исправь. Не больше 5 попыток.
4. Результат: один самостоятельный скрипт, который читает данные из orders.csv,
   решает задачу и печатает расписание по станкам.

ДАННЫЕ:
8 заказов: шкаф-купе (раскрой 40 мин, кромление 30, сверление 25, сборка 60),
кухня «Милан» (раскрой 90, кромление 70, сверление 50, сборка 120),
...остальные заказы в orders.csv.
Станки: раскрой — 1, кромление — 1, сверление — 1, сборка — 1.
Цель: минимизировать время окончания последнего заказа.

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

🧠

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

Слабость LLM. Модель пишет код по памяти. Для популярных библиотек этого хватает, для узких (солверы, специфические API) нет. Она придумывает правдоподобные названия функций и неверные аргументы. Если формулировка и код делаются одним махом, ошибка в API ломает весь результат, а проверить её нечем.

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

Как метод это использует. Разделение убирает конкуренцию двух задач за внимание: сначала только «что моделируем», потом только «как это выразить в коде». Поиск по документации превращает «вспомни» в «найди и проверь». Не нужно загружать весь справочник в контекст: агент берёт только нужные куски. Это экономит токены и снижает шум.

Рычаги управления: - Лимит итераций (у авторов 10 у формулировщика, 50 у исполнителя). Для простых задач уменьшай, для сложных увеличивай. - Инструменты исполнителя (у авторов шесть: поиск функций, примеры, проверка). Меньше инструментов — проще агенту выбирать, больше — точнее проверка. - Остановка после плана (в промпте выше). Убери, если доверяешь формулировке, оставь, если задача новая. - Жёсткое правило «только из документации» — убирает самые частые ошибки с выдуманными функциями.

📋

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

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

Агент 1. Формулировщик (без инструментов):

Ты формулируешь математическую модель для задачи планирования.
Код не пиши.

ОПИСАНИЕ ПРОЦЕССА:
{описание процесса на обычном языке}

ДАННЫЕ:
{структура данных: таблицы, поля, единицы измерения}

ЦЕЛЬ:
{что минимизировать или максимизировать}

Выдай план модели в формате:
1. Переменные решения (имя, тип, область значений)
2. Ограничения (каждое — одной строкой на человеческом языке и формулой)
3. Целевая функция
4. Допущения, которые ты принял сам

Агент 2. Исполнитель (с доступом к документации):

Ты переводишь готовую формулировку модели в рабочий код.

БИБЛИОТЕКА: {название библиотеки и версия}
ФОРМУЛИРОВКА (от предыдущего этапа):
{план модели}

ИСТОЧНИК ДАННЫХ:
{файл или база данных, где лежат данные}

ПРАВИЛА:
1. Прежде чем использовать функцию, найди её в документации через
   инструмент {инструмент_поиска} и проверь параметры.
2. Не используй функции, которых нет в документации.
3. Запусти скрипт. При ошибке найди нужную функцию в документации
   и исправь. Не больше {число} попыток.
4. Результат: один самостоятельный скрипт, который читает данные,
   строит модель, решает её и печатает решение.

Что подставлять: - {описание процесса} — как работает цех, склад, смена, обычными словами; - {библиотека} — солвер или любая узкая библиотека, с которой модель работает плохо; - {инструмент_поиска} — MCP-сервер с документацией или папка с файлами документации; - {число} — лимит попыток, чтобы агент не крутился бесконечно.

🚀 Быстрый старт — вставь в чат или в Claude Code:

Вот шаблон двухэтапного агента (формулировщик + исполнитель с документацией).
Адаптируй под мою задачу: {твоя задача}.
Задавай вопросы, чтобы заполнить поля.

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

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

⚠️

Ограничения

⚠️ Неполный текст: В доступной части статьи нет таблиц результатов. Известны только итоговые цифры из аннотации. Сравнение «один агент против двух» в деталях не видно. Нельзя сказать, какую долю успеха даёт разделение ролей, а какую — поиск по документации.

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

⚠️ Запуск ≠ правильность: Скрипт, который запустился, может содержать неверные ограничения. Авторы отдельно измеряли точность модели и успех запуска, но на практике правильность расписания нужно проверять вам: на маленьком примере, где ответ известен.

⚠️ Нужна настройка: Авторы строили свой MCP-сервер и собирали агентов в Langflow. Читатель без программирования может повторить логику через готовые инструменты с документацией, но сами цифры к такой настройке не применимы.

⚠️ Узкая область: Проверяли один солвер (IBM CP Optimizer) на шести задачах планирования. Общий принцип «агент с документацией лучше, чем память» переносится на другие библиотеки, но статья этого не проверяла.

🔍

Как исследовали

Авторы взяли шесть производственных задач разной сложности: поточный цех (flow-shop), цех с разным порядком операций (job-shop), гибкий цех и три варианта складской логистики с транспортом и сборкой заказов. Сравнили три схемы: два агента, один агент и один запрос к LLM без инструментов. Каждую схему прогнали на трёх разных LLM с одинаковой температурой (0,15) и одинаковыми системными промптами. Различалась только архитектура.

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

Результаты: формулировка модели современным LLM почти всегда по силам. Главная проблема в реализации. Двухагентная схема подняла долю рабочих скриптов с 14,8% до 59,3%, а на четырёх менее сложных задачах дошла до 80,6%. Инсайт для практики: ошибки идут не от «непонимания задачи», а от незнания API. Лечить их надо доступом к документации, а не более длинным промптом с условием.

💡

Адаптации и экстраполяции

🔧 Техника: убрать инструменты у первого агента → формулировка не «прилипает» к знакомым функциям

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

Экстраполяция (в статье этого нет): правило «найди в документации, прежде чем использовать» можно вписать в CLAUDE.md или AGENTS.md для любой узкой библиотеки:

## Работа с {библиотека}
- Перед вызовом любой функции {библиотеки} найди её описание в docs/{библиотека}/.
- Если функции в документации нет — не используй её, спроси меня.
- После написания кода запусти его на тестовых данных из tests/small.csv
  и сравни с ожидаемым ответом из tests/expected.txt.

Это идея, достроенная по мотивам статьи, а не проверенный авторами приём.

🔗

Ресурсы

  • Название: Agentic AI-Assisted Modeling for Production Scheduling: Assessment in Constraint Programming
  • Авторы: Ángel Sánchez-Fernández, Javier Pernas-Álvarez, Diego Crespo-Pereira
  • Университет: Universidade da Coruña, Campus Industrial de Ferrol, CITENI, Grupo Integrado de Ingeniería
  • Инструменты из исследования: Langflow Desktop (сборка агентов), MCP-сервер документации docplex.cp (IBM ILOG CP Optimizer). Промпты и данные опубликованы в репозитории проекта (Sánchez-Fernández et al., 2026).
  • Близкие работы: Szeider (2025) — MCP-архитектура для генерации CP-моделей; OptiMUS-0.3 — многоагентная схема для линейных моделей.

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

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

Парадокс: современная LLM почти всегда правильно придумывает модель задачи, но код под конкретную библиотеку у неё падает. Без агентов рабочими выходят лишь около 15% скриптов. Метод позволяет получать скрипт, который запускается с первого раза: до 80% на простых задачах планирования, рост примерно в 4 раза. Сначала один агент формулирует модель без кода, потом второй пишет код и сверяет каждую функцию с документацией. Модель перестаёт вспоминать API по памяти и начинает его проверять.

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

Два агента, два разных права. Формулировщик работает без инструментов. Он выдаёт только план: переменные, ограничения, цель. Исполнитель получает этот план и пишет код. У него есть поиск по документации через MCP-сервер (способ подключить к модели внешние инструменты). Всю документацию в контекст не заливают. Агент сам ищет нужную функцию, смотрит параметры и только потом вставляет её в код. Правило исполнителя: нет в документации — не используй. Это как программист с открытым справочником вместо программиста, который клянётся, что всё помнит. Если скрипт упал, агент читает ошибку, снова идёт в документацию и чинит.

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

Модель пишет код по памяти. Для популярных библиотек хватает, для узких солверов (программ-решателей) нет. Она придумывает правдоподобные названия и неверные аргументы. Одним запросом это не поймать: ошибка в одной функции убивает весь скрипт. Разделение ролей снимает конкуренцию за внимание. Сначала думаем только «что моделируем», потом только «как это записать». Поиск по документации превращает «вспомни» в «найди и проверь». Модель плохо вспоминает, но хорошо читает то, что лежит перед глазами. Побочный плюс: в контексте только нужные куски справочника, а не вся документация. Это экономит токены и режет шум. Честная оговорка: в доступной части статьи нет таблиц. Какую долю даёт разделение ролей, а какую поиск по документации, неизвестно. Цифры взяты из аннотации.

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

Код под узкую библиотеку → солверы, планировщики, редкие API, свежие версии пакетов, особенно когда модель уверенно зовёт функции, которых нет. Лучше всего работает на задачах с простой структурой и множеством готовых примеров, как расписание цеха. НЕ подходит для сложных связанных задач вроде склада с транспортом и сборкой одновременно. Там авторы остались с открытой проблемой, правки руками неизбежны. Также учти: скрипт запустился не значит, что он правильный. Ограничения могут быть неверными, проверяй результат на маленьком примере с известным ответом. Проверяли один солвер (IBM CP Optimizer) на шести задачах, перенос на другие библиотеки логичен, но не доказан.

Мини-рецепт

1. Раздели работу: сначала план модели словами, без кода и без документации. Остановись и прочитай его.
2. Подключи документацию: MCP-сервер, папка docs/ или любой поиск по справочнику библиотеки.
3. Запрети выдумки: «Не используй функции, которых не нашёл в документации».
4. Заставь проверять: перед каждой функцией найти её и сверить параметры.
5. Дай чинить себя: при ошибке читать текст ошибки и снова идти в документацию.
6. Поставь лимит: не больше 5 попыток, чтобы агент не крутился вечно.
7. Проверь ответ: прогони на маленьком примере, где результат известен заранее.
8. Крути рычаги: задача простая — меньше итераций и инструментов, сложная — больше. Доверяешь формулировке — убери остановку после плана.

Примеры

[ПЛОХО] : Напиши на Python расписание для 8 заказов на 4 станках через OR-Tools
[ХОРОШО] : ЭТАП 1. Код и документацию пока не трогай. Опиши модель списками: переменные решения, ограничения (порядок операций в заказе, один станок = одна операция одновременно), целевая функция. Покажи план и остановись. ЭТАП 2 (после моего «ок»). Библиотека OR-Tools CP-SAT. Перед каждой функцией найди её в документации и проверь параметры. Чего там нет, того не используй. Скрипт упал — прочитай ошибку, найди функцию в документации, исправь. Не больше 5 попыток. Результат: один скрипт, читает orders.csv и печатает расписание по станкам. Первый вариант даёт скрипт с выдуманным вызовом, и он падает на второй строке. Второй сначала даёт план, который можно проверить глазами. Потом каждая функция в коде подтверждена документацией.
Источник: Agentic AI-Assisted Modeling for Production Scheduling: Assessment in Constraint Programming
ArXiv ID: 2610.10184 | Сгенерировано: 2026-10-08 06:00

Проблемы LLM

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

Методы

МетодСуть
Документация под рукой вместо памяти — рабочий код с первого запускаПодключи к агенту поиск по документации библиотеки. Это может быть инструмент поиска или папка с файлами. Весь справочник в контекст не грузи. Агент сам ищет нужные куски. Запрос: Перед использованием функции найди её в документации и проверь параметры. Не используй функции, которых там нет. Если скрипт упал — прочитай ошибку, найди нужную функцию в документации, исправь. Не больше 5 попыток. Почему работает: задача «вспомни» превращается в «найди и проверь». Модель хорошо читает текст, который лежит перед ней. Ошибки в вызовах она тоже умеет чинить по тексту ошибки. Лишнее не попадает в контекст, шума меньше. Усиление: сначала отдельный шаг, где модель описывает план модели (переменные, ограничения, цель) без кода. Потом второй шаг, где этот план переводится в код. Так формулировка и синтаксис не мешают друг другу. Остановка после плана нужна для новых задач. Когда да: узкие или редкие библиотеки, малоизвестные версии, любые решатели и специальные интерфейсы. Когда нет: популярные библиотеки, где память модели и так надёжна. Осторожно: скрипт, который запустился, не обязательно верный. Проверяй результат на маленьком примере с известным ответом. Сложные, тесно связанные задачи всё равно потребуют ручных правок
📖 Простыми словами

AgenticAI-AssistedModelingfor Production Scheduling: Assessment in Constraint Programming

arXiv: 2610.10184

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

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

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

Тестировали метод на расписании мебельного цеха, но принцип универсален. Любая сложная оптимизация — от логистики курьеров до распределения смен на заводе — с треском проваливается, если пихать всё в один запрос. Как только ты отделяешь логику задачи от API и даёшь модели справочник, код начинает работать с первой попытки, а не со сто пятого пинка.

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

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

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

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