Архитектура мультиагентных ИИ-систем: паттерны проектирования и production (2026)

Монолитный Agent — один LLM, который маршрутизирует, рассуждает и исполняет — легко собрать в прототипе и ломается при любом серьёзном масштабе. Проблемы структурные, а не модель-специфичные: окно контекста забивается промежуточным состоянием и режет качество рассуждений ; универсальный Agent размывает экспертизу ; последовательное исполнение суммирует латентности ; один сбойный вызов LLM парализует весь pipeline.

Внутренний эксперимент Google (Agent Bake-Off, MLflow 2026) показал, что распределённая мультиагентная архитектура сократила время обработки с 60 минут до 10 — ускорение более чем в 6 раз. AdaptOrch (2026) формально доказывает: топология оркестрации влияет на системную производительность сильнее, чем выбор базовой модели, давая 12–23 % прироста на SWE-bench и смежных бенчмарках при правильном паттерне.

• Потолок контекста: промежуточные результаты заполняют окно и деградируют последующие шаги.
• Размытая экспертиза: Agent, который делает всё, редко делает что-то хорошо.
• Нет параллелизма: суммарная латентность = сумма шагов.
• Single point of failure: один bad call LLM — весь workflow стоит.
• Невозможность точечного апгрейда: обновление подсистемы требует переписывания целого.

Мультиагентная система (MAS) — набор независимых AI-агентов, координируемых через протоколы коммуникации и механизмы оркестрации для задач, которые один Agent не тянет эффективно.

Три доминирующие топологии: централизованная (единый orchestrator — аудируемо, но bottleneck), децентрализованная (peer-to-peer mesh — resilient, но трудно дебажить) и иерархическая (supervisors of supervisors — баланс контроля и масштаба).

Эти шесть паттернов покрывают более 95 % реальных мультиагентных систем.

Паттерн 1 — Последовательный pipeline: выход Agent A → вход Agent B, строго линейно. Для жёстких зависимостей (контент-пайплайн, code review). Прост в отладке ; латентность = сумма шагов ; один сбой блокирует всё.

from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class PipelineState(TypedDict):
    query: str
    retrieved_docs: str
    analysis: str
    final_report: str

def retrieval_agent(state: PipelineState):
    docs = search_knowledge_base(state["query"])
    return {"retrieved_docs": docs}

def analysis_agent(state: PipelineState):
    result = llm.invoke(f"Проанализируй: {state['retrieved_docs']}")
    return {"analysis": result.content}

builder = StateGraph(PipelineState)
builder.add_node("retriever", retrieval_agent)
builder.add_node("analyzer", analysis_agent)
builder.add_edge(START, "retriever")
builder.add_edge("retriever", "analyzer")
builder.add_edge("analyzer", END)
pipeline = builder.compile()

Паттерн 2 — Parallel fan-out / fan-in: независимые подзадачи параллельно, synthesizer агрегирует. Латентность = max(T1, T2, …, Tn). LangGraph Send API + reducer Annotated[list, operator.add] сливает ветки без ручной синхронизации.

Паттерн 3 — Иерархический supervisor-worker: supervisor декомпозирует, маршрутизирует, агрегирует. Двухуровневый routing: keyword fast path (<1 ms, без LLM) + LLM fallback для ambiguous intent. Кейсы: coding assistant уровня Replit, enterprise support.

KEYWORD_ROUTING = {
    "код": "code_agent",
    "code": "code_agent",
    "поиск": "search_agent",
    "данные": "data_agent",
}

def supervisor_with_fast_path(state):
    query = state["query"].lower()
    for keyword, agent_name in KEYWORD_ROUTING.items():
        if keyword in query:
            return {"next": agent_name}
    decision = llm.invoke(f"Маршрутизируй на code_agent, search_agent или data_agent: {state['query']}")
    return {"next": decision.content.strip()}

Паттерн 4 — Swarm (peer-to-peer): агенты передают задачи напрямую без центрального координатора. Остановка по round count, consensus или timeout. Подходит для multi-round code review ; высокая недетерминированность — в production использовать осторожно.

Паттерн 5 — Blackboard: общее структурированное рабочее пространство ; агенты читают/пишут при выполнении preconditions. Для долгих async-задач (часы–дни) и гетерогенных сервисов разных команд.

Паттерн 6 — Hybrid: комбинация паттернов — типично intent router + supervisor + parallel fan-out + quality pipeline. Самая частая архитектура enterprise content platform.

LangGraph — для production reliability (финансы, healthcare), долгоживущей персистентности состояния и точного HITL. CrewAI — прототип за 1–2 дня, команда мыслит «должностями агентов». AutoGen — Microsoft/Azure stack, когда центральны multi-round дебаты между агентами.

В 2026 мультиагентная коммуникация стандартизирована двумя комплементарными протоколами под Agentic AI Foundation Linux Foundation: MCP (вертикаль, Agent ↔ tools/DB/API) и A2A (горизонталь, Agent ↔ Agent). MCP — «написал интеграцию один раз, использую везде». A2A (Google, v1.0 начало 2026, 50+ партнёров включая Atlassian и Salesforce) — делегирование задач и capability discovery через Agent Card JSON на /.well-known/agent.json.

import httpx

async def discover_and_delegate(agent_url: str, task: str):
    card = (await httpx.get(f"{agent_url}/.well-known/agent.json")).json()
    skills = [s["id"] for s in card["skills"]]
    if "web_research" not in skills:
        raise ValueError(f"{card['name']} не поддерживает web_research")
    payload = {
        "jsonrpc": "2.0",
        "method": "message/send",
        "id": "task-001",
        "params": {"message": {"role": "user", "parts": [{"type": "text", "text": task}]}}
    }
    return (await httpx.post(card["url"], json=payload)).json()

Реализация MCP tool server — в руководстве MCP Server с нуля. Agent Skills в IDE — в гайде Cursor Agent Skills.

Персистентность и recovery: PostgreSQL через PostgresSaver LangGraph — resume после crash по thread_id сессии.

from langgraph.checkpoint.postgres import PostgresSaver

with PostgresSaver.from_conn_string("postgresql://user:pass@localhost/agentdb") as checkpointer:
    graph = builder.compile(checkpointer=checkpointer)
    config = {"configurable": {"thread_id": "user-session-12345"}}
    result = graph.invoke({"query": "Анализ отчёта Q2"}, config)

Human-in-the-loop: interrupt() останавливает execution перед high-risk action (изменение production DB) и ждёт human approval.

Circuit breaker: после N consecutive failures вызов внешнего Agent переходит в OPEN на recovery timeout — блокирует дорогие retry loops.

Token budget: TokenBudgetManager с глобальным потолком (например 100 000 tokens) и per-agent tracking. Рекомендуемые hard caps: MAX_ITERATIONS=10, MAX_TOOL_CALLS_PER_AGENT=20, MAX_TOTAL_TOKENS=50_000.

Анализ MAST по 1 642 execution traces:

Тревожная цифра: 57 % организаций уже гоняют Agents в production, но только 8 % завершили внедрение LLM observability. Ошибки приходят с HTTP 200, дашборды зелёные.

Целевые метрики: end-to-end success rate >85 %, P95 latency <30 s, per-agent error rate <5 %. Каждый agent call — OpenTelemetry span с общим correlation_id. Дополните LLM-as-a-Judge: completeness, accuracy, relevance, hallucination detection.

Референс 1: Google Agent Bake-Off фиксирует 6× ускорение (60 min → 10 min) после мультиагентной декомпозиции.

Референс 2: AdaptOrch — 12–23 % прироста от топологии независимо от модели.

Референс 3: оптимальное число Agents в production — 3–8 ; дальше coordination overhead часто перевешивает выгоду.

• Context pollution: hallucination Agent A становится «фактом» для B и C. JSON schema validation, confidence score (>0,7) и required fields на каждом handoff.
• Infinite loops и runaway cost: hard caps на iterations, tool calls и tokens ; interrupt_before перед дорогими tools.
• Over-engineering: не дробите простую двухшаговую LLM-цепочку на восемь агентов без измеримых доказательств. Начинайте с sequential pipeline.
• Demo-to-production gap: input guardrails (лимит 10 000 символов, prompt injection detection), PII redaction и content classifier на output.
• Parallel branch sync в LangGraph: defer=True на supervisor node — ждёт завершения всех Send-веток перед re-run.

Есть строгие sequential dependencies? Да → подшаги параллелизуемы? Нет → sequential pipeline ; Да → hybrid fan-out + pipeline. Нет → есть agent с decision authority? Да → масштаб требует sub-teams? Нет → supervisor-worker ; Да → hierarchy of supervisors. Нет → long-running async? Да → blackboard ; Нет → ≤5 agents с чёткой termination? Да → swarm с hard limits ; Нет → рефакторинг в иерархию.

Тренды 2026: federated orchestration между командами, multimodal multi-agent (vision + audio + text), adaptive topology selection (направление AdaptOrch), EU AI Act с обязательными audit trails решений.

1. 01
   Выбрать топологию: пройдите дерево решений из секции 08 ; зафиксируйте agent graph (3–8 узлов) до написания кода.
2. 02
   Провижинить облачный Mac: в консоли NUKCLOUD выберите 16 ГБ+ RAM (32 ГБ для LangGraph + PostgreSQL + parallel workers) ; почасовая тарификация на странице цен.
3. 03
   Установить стек: pip install langgraph langchain-openai mcp httpx opentelemetry-sdk ; опционально pip install crewai или pyautogen по выбранному framework.
4. 04
   Настроить persistence: разверните PostgreSQL, подключите PostgresSaver, задайте thread_id per user session для crash recovery.
5. 05
   Подключить MCP и observability: MCP HTTP server для tools ; OpenTelemetry span на каждый agent node с correlation_id ; алерты при error rate >5 %. Документация — в разделе помощи.
6. 06
   Нагрузочная валидация и фиксация подписки: тестируйте parallel fan-out и handoffs с LLM-as-a-Judge ; после пилота — страница заказа. См. production runbook NUKCLOUD.

Гонять multi-agent orchestrator на локальном ноутбуке или shared VPS — это sleep interrupts, SSE disconnects от нестабильного канала, конфликты процессов между разработчиками и нехватка RAM для parallel workers. Для long-running agent workflows — research fan-out, HITL review pipelines, MCP servers 7×24 — мультирегиональные bare-metal Mac nodes NUKCLOUD дают tenant isolation, unified Apple Silicon memory и стабильный bandwidth, что лучше ложится на production multi-agent требования.