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

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

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

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

Два базовых паттерна: в конвейере порядок задан кодом, у координатора его выбирает модель.

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

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

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

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

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

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

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

Координатор: один решает, кому отдатьспросят на собеседовании

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

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

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

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

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

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

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

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

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

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

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

Генератор и критикспросят на собеседовании

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

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

Человек в циклеспросят на собеседовании

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

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

Когда хватает одного агентаспросят на собеседовании

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

Коротко

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

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