3,583 papers
arXiv:2610.03010 78 2 окт. 2026 г. FREE

Лесенка сложности: начинайте с одного запроса, добавляйте агентов только при доказанной пользе

КЛЮЧЕВАЯ СУТЬ
Команда из «программиста, ревьюера и тестировщика» работает в среднем в 6 раз дольше одного запроса. В худшем случае разница доходит до 160 раз. Точнее она при этом становится редко: простой запрос выиграл по точности в 4 задачах из 5. Метод «лесенка сложности» позволяет решить, нужны ли тебе агенты, ещё до того как ты их построил. Начинай с одного запроса и добавляй агента, только если цифры на твоих примерах показали прирост. Для этого хватит проверки на своих примерах: 10-20 штук с известным ответом.
Адаптировать под запрос
⚡

TL;DR

Исследование сравнило четыре «ступени» одной и той же задачи: один запрос к модели без агентов, один агент, два агента и полноценная мультиагентная цепочка. Лучшая точность чаще всего получалась на самой простой ступени. На пяти задачах разработки (генерация кода, поиск технического долга, поиск уязвимостей, разбор логов, анализ логов) простой запрос выиграл по точности в четырёх. Мультиагентная схема выиграла только в поиске уязвимостей.

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

Вывод для практики: двигайтесь по лесенке снизу вверх. Сначала один хороший запрос и проверка на своих примерах. Следующую ступень берите, только если видите в цифрах, что она даёт прирост именно на вашей задаче. Модель и формулировка промпта при этом влияют сильнее, чем число агентов. Одна смена стратегии промпта подняла точность разбора логов с 3,4% до 54,3%.

🔬

Схема метода

В статье нет промпта-шаблона. Это сравнение конфигураций, и вывод сводится к порядку выбора:

СТУПЕНЬ 0: один запрос, одна модель, без агентов     → замерить точность на 10–20 своих примерах
СТУПЕНЬ 1: один агент (с проверкой или инструментом) → замерить; лучше ступени 0 на вашей задаче?
СТУПЕНЬ 2: два агента (исполнитель + проверяющий)    → замерить; оправдывает ли рост времени?
СТУПЕНЬ 3: мультиагентная цепочка                    → брать только при явном приросте на вашей задаче

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

🚀

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

Сильная зона вывода: типовая рабочая задача, где можно быстро проверить результат. Например, разбор логов.

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

Промпт (ступень 0, один запрос):

Ты разбираешь логи сервиса оплаты интернет-магазина.
Для каждой строки лога верни JSON с полями:
timestamp, service, level, error_code, order_id, message_template.
Переменные части (ID заказа, суммы в рублях, IP) замени в
message_template на плейсхолдеры , , .
Если поле не найдено, пиши null. Ничего, кроме JSON, не выводи.

Примеры:
2025-03-14 02:11:07 payment-gw ERROR E402 order=88231 sum=1490 timeout
→ {"timestamp":"2025-03-14 02:11:07","service":"payment-gw","level":"ERROR","error_code":"E402","order_id":"88231","message_template":"order= sum= timeout"}

Логи:
{строки_логов}

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

🧠

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

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

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

Как метод использует это. Лесенка заставляет платить за сложность только там, где вы её измерили. Мультиагентность в исследовании оказалась полезной в поиске уязвимостей. Там второй взгляд действительно находит то, что первый пропустил. Вывод: прирост зависит от задачи, и «агенты — это всегда лучше» не работает.

Рычаги управления: - Число агентов: убирайте по одному, пока точность не начнёт падать. - Стратегия промпта: пробуйте разные формулировки на одной выборке, разброс может быть огромным. - Модель: универсального победителя нет, перепроверяйте под каждую задачу. - Размер проверочной выборки: 10–20 примеров с известным ответом уже дают ориентир.

📋

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

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

Я хочу решить задачу: {задача}.
Критерий правильного ответа: {критерий}.
Мои тестовые примеры (с известным ответом): {примеры}.

Помоги пройти «лесенку сложности»:
1. Напиши лучший однозапросный промпт для этой задачи (без ролей и агентов).
2. Напиши вариант с одним проверяющим шагом («проверь свой ответ по критерию»).
3. Напиши вариант с двумя ролями: исполнитель и независимый проверяющий.
4. Для каждого варианта дай таблицу: ожидаемое время, число вызовов, на что смотреть при сравнении.
5. Скажи, при каком результате на моих примерах стоит остановиться на более простом варианте.
Не предлагай более сложную схему, если простая справляется.

Плейсхолдеры: {задача} — рабочая задача, {критерий} — как отличить верное от неверного, {примеры} — 10–20 образцов с эталоном.

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

Вот шаблон лесенки сложности. Адаптируй под мою задачу: [твоя задача].
Задавай вопросы, чтобы заполнить поля.

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

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

⚠️

Ограничения

⚠️ Модели не самые новые: тестировали открытые модели семейств Gemma, Qwen и DeepSeek-Coder. Как всё это выглядит на современных закрытых моделях и на моделях с «длинным рассуждением», статья не показывает.

⚠️ Нет универсального ответа: мультиагентность помогла в поиске уязвимостей. Если ваша задача из того же класса «найди то, что легко пропустить», проверяйте второго агента на практике, не отбрасывайте заранее.

⚠️ Измеряли энергию, а не вашу стоимость: прямой перенос на токены и рубли в API вероятен, но цифры 6× и 160× относятся к их оборудованию и задачам.

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

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

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

🔍

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

Команда из норвежского SINTEF и университетов Сингапура и Турции взяла пять рабочих задач разработчика. Задачи проверяли на четырёх наборах данных: HumanEval, MLCQ, PrimeVul и логи HDFS. Для каждой задачи построили четыре ступени сложности: один запрос, один агент, два агента и мультиагентная цепочка. Прогнали их через шесть открытых моделей, две стратегии промпта и три вида железа: рабочую станцию и два мощных сервера, один с 8 видеокартами H100. Всего получилось 1840 запусков. Измеряли точность, время ответа и потреблённую энергию.

Главный приём анализа — «фронт Парето». Это набор конфигураций, которые нельзя улучшить по одному показателю, не ухудшив другой. Из 66 таких «разумных» конфигураций лишь одна оказалась мультиагентной, 36 были вообще без агентов, 59 — лёгкими (без агентов или с одним). Мультиагентные схемы в среднем в 6,36 раза дороже по энергии и в 6,07 раза медленнее.

Удивили два результата. Во-первых, энергия и время почти идеально связаны (коэффициент 0,987), так что экономия одного означает экономию другого. Во-вторых, выбор промпта оказался сильнее выбора архитектуры: в разборе логов точность прыгала от 3,4% до 54,3%. Железо важно для тяжёлых схем: на мультиагентной конфигурации мощный сервер был в 3,4 раза быстрее рабочей станции.

💡

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

🔧 Техника: добавить критерий остановки → агент не усложняет сам себя

В файл инструкций агента (CLAUDE.md, AGENTS.md) можно добавить правило по духу вывода статьи. Это наша адаптация, в исследовании её не проверяли:

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

Прирост от такого правила нужно проверить на ваших задачах.

🔗

Ресурсы

  • Engineering Sustainable Agents: A Systematic Comparison of Agentic LLMs for Developer Workflows. Авторы: Merve Astekin, Yan Naing Tun, Arda Goknil, Erik Johannes Husom, Lwin Khin Shar, Hasan Sözer, Ratnadira Widyasari, Hui Song. Организации: SINTEF (Норвегия), Singapore Management University, Ozyegin University (Турция).
  • Наборы данных из статьи: HumanEval, MLCQ, PrimeVul, LogHub (HDFS).
  • В тексте упомянута работа Xia et al. о том, что неагентный трёхшаговый подход (локализация, исправление, проверка патча) может обходить сложные агенты на SWE-bench Lite.

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

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

Команда из «программиста, ревьюера и тестировщика» работает в среднем в 6 раз дольше одного запроса. В худшем случае разница доходит до 160 раз. Точнее она при этом становится редко: простой запрос выиграл по точности в 4 задачах из 5. Метод «лесенка сложности» позволяет решить, нужны ли тебе агенты, ещё до того как ты их построил. Начинай с одного запроса и добавляй агента, только если цифры на твоих примерах показали прирост. Для этого хватит проверки на своих примерах: 10-20 штук с известным ответом.

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

Идёшь по ступеням снизу вверх. Ступень 0: один запрос, без агентов. Ступень 1: один агент с проверкой. Ступень 2: исполнитель и проверяющий. Ступень 3: полная цепочка агентов. На каждой ступени замеряешь результат на тех же примерах. Следующая ступень не дала заметного прироста — остаёшься на предыдущей. Это как лифт в двухэтажном доме: можно построить, но по лестнице быстрее. Параллельно крутишь формулировку промпта и выбор модели. У них эффект сильнее, чем у числа агентов.

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

Каждый новый агент добавляет круг обмена текстом. Контекст пухнет, вызовов больше, время и стоимость растут почти один в один. Качество так не растёт. Агенты пересказывают друг другу одну и ту же ошибку. Иногда они «исправляют» уже верный ответ. Современные модели часто решают задачу за один проход, если чётко поставить её и показать формат. Одна смена стратегии промпта подняла точность разбора логов с 3,4% до 54,3%. Число агентов такого прыжка не давало. Мультиагентность выиграла только в поиске уязвимостей. Там второй взгляд правда находит то, что первый пропустил.

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

Разработка и рабочая рутина → разбор логов, генерация кода, поиск технического долга, особенно когда ответ можно быстро проверить руками. Тот же подход разумен для текстов, продаж и поддержки, но в статье он не проверялся. Для задач вида «найди то, что легко пропустить» (уязвимости) сразу проверь второго агента, не отбрасывай его заранее. НЕ подходит как готовое правило для новых закрытых моделей и моделей с длинными рассуждениями: тестировали только открытые Gemma, Qwen и DeepSeek-Coder. Цифры 6x и 160x — это энергия на их оборудовании, а не твои рубли в API.

Мини-рецепт

1. Собери 10-20 примеров: задача и правильный ответ, который ты знаешь точно.
2. Напиши один хороший запрос: без ролей и агентов, с чётким форматом и одним образцом.
3. Замерь: сколько ответов верно и сколько времени ушло.
4. Если мало, сначала крути промпт: меняй формулировку и примеры на той же выборке. Разброс может быть огромным.
5. Потом пробуй другую модель: универсального победителя нет.
6. Только после этого добавляй проверяющего: замерь снова. Время выросло сильно, а точность чуть-чуть? Откатывайся.
7. Попроси LLM помочь: вставь в чат Я хочу решить задачу: {задача}. Критерий правильного ответа: {критерий}. Мои примеры: {примеры}. Напиши лучший однозапросный промпт, потом вариант с одним проверяющим шагом, потом с двумя ролями. Для каждого дай ожидаемое время и число вызовов. Не предлагай сложную схему, если простая справляется.

Примеры

[ПЛОХО] : Сделай трёх агентов: парсер логов, проверяющий и аналитик. Пусть обсуждают и выдадут структуру ошибок оплаты.
[ХОРОШО] : Ты разбираешь логи сервиса оплаты. Для каждой строки верни JSON с полями: timestamp, service, level, error_code, order_id, message_template. ID заказа, суммы в рублях и IP замени в message_template на , , . Если поля нет, пиши null. Кроме JSON ничего не выводи. Пример: 2025-03-14 02:11:07 payment-gw ERROR E402 order=88231 sum=1490 timeout → {"timestamp":"2025-03-14 02:11:07","service":"payment-gw","level":"ERROR","error_code":"E402","order_id":"88231","message_template":"order= sum= timeout"} Логи: {строки_логов} Дальше возьми 20 строк с известным ответом и сравни. Устраивает — остановись. Нет — сначала поправь формулировку и образцы, и только потом добавляй проверяющего агента.
Источник: Engineering Sustainable Agents: A Systematic Comparison of Agentic LLMs for Developer Workflows
ArXiv ID: 2610.03010 | Сгенерировано: 2026-10-05 04:23

Проблемы LLM

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

Методы

МетодСуть
Лесенка сложности — платишь за агентов только там, где измерил пользуИдёшь снизу вверх и на каждой ступени замеряешь результат. Ступень 0: один запрос, без ролей. Ступень 1: один запрос плюс шаг самопроверки. Ступень 2: два агента, исполнитель и независимый проверяющий. Ступень 3: полная цепочка агентов. Замер: возьми 10–20 примеров с известным верным ответом. Сравни долю верных ответов, время и число вызовов. Если следующая ступень не даёт заметного прироста, остановись на предыдущей. Почему работает: современные модели часто решают задачу за один проход, если чётко поставить задачу и показать формат. Каждый новый агент умножает стоимость, а качество — не всегда. Когда да: типовая рабочая задача, где легко проверить результат (разбор текста, извлечение полей, генерация кода). Когда второй агент стоит проверить: задача вида «найди то, что легко пропустить», например поиск уязвимостей. Там второй взгляд реально находит пропущенное. Когда не работает: нет эталонных ответов. Тогда нечем сравнить ступени, и выбор будет на глаз
📖 Простыми словами

EngineeringSustainableAgents: A Systematic Comparison ofAgenticLLMsfor Developer Workflows

arXiv: 2610.03010

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

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

Факты бьют по лицу: обычный простой запрос без агентов всухую победил в 4 из 5 задач разработки. Он обошёл навороченные архитектуры в генерации кода, разборе логов, их анализе и поиске техдолга. Сложная мультиагентная схема смогла вырвать победу ровно в одном месте — поиске уязвимостей, где взаимная перепроверка и въедливость реально окупаются. Во всех остальных сценариях усложнение только портило итоговый ответ.

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

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

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

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

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