ФАЗА 23. LLM-ПРИЛОЖЕНИЯ Мультиагентные системы

Шесть паттернов оркестрации агентов

Pipeline · Coordinator · Critic · Human

Несколько агентов полезны для разных ролей и контекстов, но добавляют стоимость и новые отказы на стыках.

1. Конвейер передаёт узкий результат

1 / 5

Каждый агент выполняет свою стадию и передаёт структурированный вывод следующей. Один общий чат не заменяет контракт.

  • Роли не дублируются.
  • Ошибка останавливает следующий этап.
  • Формат результата проверяется.
ResearchDesignBuildReview

2. Координатор распределяет независимые части

2 / 5

Центральный агент выдаёт самодостаточные задания и собирает результаты. Подзадачи не знают всей истории друг друга.

  • Задание содержит контекст и критерий.
  • Права выдаются по роли.
  • Итог проверяет координатор.
CoordinatorAgent AAgent BCombined resultverified

3. Параллельный разворот сокращает время

3 / 5

Независимые исследования идут одновременно, затем объединяются. Общее состояние не меняется до завершения веток.

  • Работа действительно независима.
  • Число веток ограничено бюджетом.
  • Ошибка ветки не скрывается.
Fan outCode researchDocs researchLogs researchFan in

4. Генератор и критик разводят роли

4 / 5

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

  • Рубрика известна заранее.
  • Число итераций ограничено.
  • Финальное решение принимает владелец.
GeneratorCriticAccepted resultrubric passed

5. Иерархия и человек ограничивают автономность

5 / 5

Руководитель раздаёт узкие задачи, человек утверждает рискованные переходы. Маленькая задача не требует всей системы.

  • Один агент часто дешевле.
  • Human-in-the-loop защищает необратимое.
  • Сложность оправдана измеримым выигрышем.
Lead agentWorker agentsRisky actionapproval requiredHuman

Мультиагентные системы: шесть паттернов оркестрации агентов

← назад к разделу

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

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

Почему одного агента перестаёт хватать

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

Разделение даёт ещё две вещи. Узкого агента можно проверить отдельно, своим набором примеров. И у него можно забрать опасные права: агенту, который пишет ответ клиенту, не нужен инструмент возврата денег.

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

Конвейер: агенты по очереди

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

письмо разбор структура поиск заказа заказ ответ клиенту порядок задан кодом, каждый видит только выход соседа

Конвейер: звенья идут в порядке, который написан в коде, и каждое получает только выход предыдущего.

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

Координатор: один решает, кому отдать

Здесь появляется агент-маршрутизатор. Он не решает задачу сам, а выбирает специалиста: вопрос про оплату уходит агенту оплаты, про доставку агенту доставки. Специалисты для координатора выглядят как инструменты с описанием, и выбирает он по этим описаниям.

вопрос клиента координатор выбирает по описаниям оплата доставка возвраты только оплата только доставка не про доставку

Координатор сам задачу не решает: выбирает одного специалиста по описанию и возвращает его ответ.

{
  "name": "refund_agent",
  "description": "Возвраты и отмены оплаченных заказов. Не отвечает на вопросы о доставке.",
  "input": { "order_id": "string", "reason": "string" }
}

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

Параллельный разворот и общее состояние

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

отзыв оскорбления персональные данные конкуренты общее состояние toxicity: false pii: phone competitors: false каждый пишет только свой ключ сборка читает после всех

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

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

{
  "review_id": "r-1042",
  "toxicity": { "found": false },
  "pii": { "found": true, "fields": ["phone"] },
  "competitors": { "found": false }
}

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

Иерархия: задача режется на подзадачи

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

главный агент наверх: абзац наверх: абзац модуль оплат модуль заказов тесты 20 файлов 20 файлов 20 файлов

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

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

Генератор и критик

Один агент делает черновик, второй его проверяет по критериям и возвращает замечания, первый исправляет. Цикл идёт до тех пор, пока критик не согласится или не кончится лимит итераций.

генератор критик черновик замечания одобрено лимит: 3 итерации номер заказа есть сумма как в базе сроков не обещает

Генератор и критик: работает, только когда у критика проверяемые критерии и у цикла есть лимит.

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

Человек в цикле

Последний паттерн ставит человека в ту точку, где ошибка дорогая. Агент готовит возврат денег, но не проводит его: создаёт черновик действия и ждёт подтверждения оператора. Оператор видит, что агент собирается сделать и почему, и нажимает «да» или «нет».

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

Человек в цикле: дорогое действие ждёт подтверждения, а пауза переживает перезапуск, потому что черновик лежит в базе.

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

Когда хватает одного агента

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

Коротко

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

Что почитать дальше