Chain (цепочка агентов)

Chain (chain of agents, цепочка агентов) — это последовательность шагов или агентов, где выход одного шага становится входом следующего. В официальных источниках тот же паттерн чаще называют workflow, graph, handoff или RunnableSequence.

Английский термин: chain of agents. Также встречается: workflow, graph, handoff, RunnableSequence. В русских текстах — «цепочка агентов», «агентный workflow», «цепочка шагов».

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

Простыми словами

Грубо говоря, это конвейер из нескольких «специалистов». Первый агент понимает запрос, второй добывает данные, третий пишет ответ, четвёртый проверяет качество или передаёт задачу человеку.

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

Как это работает

OpenAI в практическом руководстве описывает workflow как последовательность шагов, а multi-agent systems — как последовательности вызовов инструментов и handoffs между агентами. В линейной цепочке выход одного шага идёт прямо в следующий; в графовой — маршрут решают state и edges.

Вход → Агент 1 (классификация) → Агент 2 (данные) → Агент 3 (ответ) → Агент 4 (проверка) → Выход
                     ↘ при условии → Агент 5 (handoff человеку) → Выход

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

Линейная цепочка

1. Вы передаёте запрос первому шагу.
2. Шаг возвращает результат и, при необходимости, обновляет состояние.
3. Следующий шаг получает этот результат как вход.
4. Цепочка завершается, когда финальный шаг отдаёт ответ или вызывает ручную передачу.

Так описывается, например, RunnableSequence в LangChain: выход одного Runnable становится входом следующего. В Google ADK похожий смысл у SequentialAgent: подагенты выполняются по порядку и передают изменения состояния дальше.

Графовая цепочка

1. У вас есть State, Nodes и Edges.
2. Узлы делают работу, а рёбра определяют следующее действие.
3. Могут появляться ветвления, fan-out/fan-in, циклы, retry и human-in-the-loop.
4. Такой вариант удобен, когда линейный маршрут слишком хрупкий.

Именно так LangGraph описывает workflows как графы, а Google ADK — как graph-based execution engine для deterministic execution flows, routing, fan-out/fan-in, loops, retry, state management, dynamic nodes, HITL и nested workflows.

Где применяется

• Маршрутизация пользовательских запросов на специализированных агентов: один классифицирует намерение, другой отвечает по теме, третий передаёт сложный кейс дальше.
• RAG-пайплайны: retrieval → synthesis → verification, когда сначала поднимаются источники, потом формируется ответ, затем выполняется проверка.
• Редакционные и QA-процессы: черновик → факт-чек → правка → публикация.
• Детерминированные бизнес-сценарии, где важны retries, state, ручное подтверждение и воспроизводимый маршрут выполнения.

Если вы работаете в Python и нужен manager-style или handoff-based multi-agent workflow, OpenAI Agents SDK позиционируется как lightweight framework для таких сценариев. Если нужны ветвления и циклы — чаще смотрят на LangGraph; если нужен строгий порядок и контроль исполнения — на Google ADK. Такой подход удобен там, где задачу можно разбить на проверяемые этапы и каждый этап тестировать отдельно.

Практический пример

Ниже — не готовый код конкретного SDK, а схема цепочки для службы поддержки.

1. classify(request)
   → определяет тему и приоритет

2. retrieve_policy(topic)
   → поднимает нужные правила и базу знаний

3. draft_answer(request, policy)
   → собирает черновик ответа

4. verify_answer(draft)
   → проверяет риск, полноту и противоречия

5. if confidence low:
      handoff_to_human(draft)
   else:
      send_to_user(draft)

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

Чем отличается от…

Не путайте chain of agents с chain-of-thought: в первом случае речь о внешней оркестрации шагов и агентов, во втором — о цепочке рассуждений модели.

Ограничения и заблуждения

• Заблуждение: chain — это один фиксированный термин со стабильным API. На практике: в источниках вы встретите workflow, graph, handoff и sequence.
• Заблуждение: chain — это просто длинный prompt у одного агента. На практике: смысл цепочки именно в оркестрации шагов, state и маршрута выполнения.
• Заблуждение: цепочка всегда линейна. На практике: графы поддерживают ветвления, loops, retries и HITL.
• Заблуждение: чем больше агентов, тем лучше. На практике: лишние шаги добавляют задержку, сложность состояния и больше точек отказа.
• Редакционная оговорка: у OpenAI Agents SDK на момент снимка указаны версия 0.17.4, Python >=3.10 и MIT; release.md использует 0.Y.Z versioning и советует pinning 0.0.x, если вы хотите избежать breaking changes. У LangGraph на странице релизов указан langgraph==1.2.2 от 2026-05-18.
• Практический вывод: если задача линейная, начинайте с sequence; если есть выбор маршрута и состояние, проектируйте graph с самого начала.

Для разметки страницы: DefinedTerm, FAQPage, BreadcrumbList.

Связанные термины, инструменты и исследования

Если хотите сверить соседние понятия, начните с этих материалов:

• Chain-of-thought (цепочка рассуждений)
• Checkpoint (контрольная точка)
• Alignment (согласование ИИ)
• Как использовать Chain-of-Thought (CoT) промптинг

Вопросы и ответы

Это то же самое, что workflow?

Часто — да по смыслу, но workflow шире. Chain of agents обычно описывает именно последовательность шагов или агентов внутри workflow.

Когда линейной цепочки недостаточно?

Когда вам нужны ветвления, fan-out/fan-in, циклы, retries, human-in-the-loop или строгая работа со state. Тогда вместо линейной цепочки обычно проектируют graph.

Какую библиотеку выбрать для старта?

По источникам: OpenAI Agents SDK удобен для manager-style и handoff-based multi-agent workflows в Python; LangGraph — для graph-based sequential, branching и looping workflows; Google ADK — для deterministic execution flows и SequentialAgent-подобных пайплайнов.

Нужно ли хранить состояние между шагами?

Да, если следующий шаг должен видеть результаты предыдущего. В graph-based подходах state — базовая часть модели исполнения.

Можно ли обойтись без отдельного фреймворка?

Да, если у вас простая линейная последовательность. Но как только появляются state, ветвления, retries или handoff, отдельный фреймворк обычно делает схему понятнее и устойчивее.

Источники

Ниже — первичные и дополнительные официальные источники, на которых основаны определения и сравнения:

• A practical guide to building agents | OpenAI
• GitHub – openai/openai-agents-python: A lightweight, powerful framework for multi-agent workflows · GitHub
• release.md | openai-agents-python
• openai-agents-python pyproject.toml
• GitHub – langchain-ai/langgraph: Build resilient agents. · GitHub
• Releases · langchain-ai/langgraph
• Graph API overview – Docs by LangChain
• RunnableSequence — LangChain Core documentation
• GitHub – google/adk-python: An open-source, code-first Python toolkit for building, evaluating, and deploying sophisticated AI agents with flexibility and control. · GitHub
• AGENTS.md | google/adk-python
• adk-python.md | google/agents-cli