Мульти-агентная архитектура на практике: паттерны, фреймворки и продакшен (гайд 2026)

Почему один Agent перестаёт масштабироваться в production

Monolithic agent — один system prompt, один tool list, один thread — демо собирается за день. Под реальной нагрузкой он становится bottleneck. Внутренний бенчмарк Google Agent Bake-Off (MLflow production guide 2026) показал: decomposed multi-agent архитектура сократила время обработки с 60 до 10 минут — 6x speedup. Отдельно исследование AdaptOrch (2026) формально доказало: orchestration topology объясняет на 12–23% больше variance в task success, чем смена underlying model.

Перед выбором framework зафиксируйте structural limits, которые вынуждают split на MAS.

1. 01

   Context window saturation: Research, code, logs и tool outputs копятся в одном thread. Retrieval quality падает; agent забывает constraints, заданные десять turns назад.

2. 02

   Jack-of-all-trades prompting: Одна persona не может одновременно excel в SQL tuning, legal review и UI copy. Instruction interference поднимает hallucination rate.

3. 03

   No true concurrency: Sequential tool calls блокируют друг друга. Независимые subtasks (scrape трёх sites, run трёх test suites) сжигают wall-clock time.

4. 04

   Single point of failure: Один bad tool result или runaway loop убивает всю session. Нет isolation domain для retries и rollbacks.

5. 05

   Opaque cost attribution: Finance не может ответить, какой step сжёг tokens. Без per-agent budgets один verbose researcher agent drains monthly cap.

Шесть orchestration design patterns

Patterns composable. Customer-support stack может использовать supervisor, fan-out к parallel researchers, pipeline synthesis в writer. Выбирайте minimum pattern set под dependency structure — покрывает 95%+ production scenarios.

1. Sequential Pipeline

Stages в fixed order: ingest → analyze → draft → review. State через shared graph node. Ideal когда каждый step зависит от prior output (ETL, report generation). LangGraph — linear StateGraph с typed state reducers.

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

2. Parallel Fan-out / Fan-in

Orchestrator spawns N independent branches, collector aggregates. Total latency = max(T1..Tn), не sum. LangGraph Send API dispatches dynamic worker nodes; reducer merges outputs. Multi-source research, ensemble voting, shard-level code review.

from langgraph.types import Send

def fan_out(state):
    return [Send("research_worker", {"query": q}) for q in state["queries"]]

def fan_in(state):
    return {"report": synthesize(state["worker_results"])}

3. Hierarchical Supervisor-Worker

Supervisor classifies intent, routes к specialists (coder, DBA, reviewer). Добавьте keyword fast path: regex или embedding match на high-confidence intents skips LLM routing call — <1ms на FAQ-style queries.

4. Swarm (AutoGen-style)

Agents hand off conversation control peer-to-peer без central coordinator. AutoGen excels: multi-round negotiation (code review, proposal evaluation). Caveat: high non-determinism — в production чаще ship как hierarchical.

5. Blackboard

Agents read/write shared artifact store (blackboard), не direct messaging. Planner posts goals; specialists append sections. Long-running async tasks (hours–days), heterogeneous services разных teams.

6. Hybrid

Real systems combine patterns: hierarchical supervisor → parallel fan-out для research → sequential pipeline для packaging. Явно mark sync vs async segments до написания кода.

MCP + A2A: dual protocol layer

Tool integration и agent collaboration — разные problems. 2026 stacks treat их как two-layer protocol cake: vertical tool access снизу, horizontal agent delegation сверху. Оба под governance Linux Foundation Agentic AI Foundation.

Каждый agent publishes Agent Card — JSON с capabilities, input schemas, endpoint URLs. Peers вызывают discover_and_delegate для routing subtasks без hard-coded agent lists. A2A v1.0 (early 2026): 50+ partners — Atlassian, Salesforce, SAP.

{
  "name": "sql-analyst-agent",
  "description": "Read-only Postgres analysis and explain plans",
  "url": "https://agents.internal/a2a/sql-analyst",
  "capabilities": ["query", "explain", "schema-introspect"],
  "input_schema": {
    "type": "object",
    "properties": { "question": { "type": "string" } }
  }
}

async def discover_and_delegate(task: str, registry: AgentRegistry):
    card = await registry.find_best_match(task)
    if not card:
        raise NoAgentError(task)
    payload = {"task": task, "caller": "supervisor-01"}
    return await a2a_client.send(card.url, payload)

MCP handles tools/list inside каждого agent; A2A handles, какой agent owns task. Vertical layer — в нашем MCP protocol guide.

Observability: MAST traces, OpenTelemetry, LLM-as-Judge

Нельзя fix то, что нельзя attribute. MAST study проанализировала 1 642 multi-agent execution traces: failure modes cluster predictably — большинство design issues, не model IQ gaps. 57% организаций уже run agents в production, но только 8% finished observability implementation — dashboards green (HTTP 200), output wrong.

MAST failure breakdown

• 41.77% — system design flaws (wrong topology, missing handoff contracts, missing termination)
• 36.94% — inter-agent misalignment (context lost at handoffs, hallucination становится ground truth)
• 21.30% — verification gaps (premature termination, incomplete validation)

Instrumentation stack

Wrap каждый agent invocation в OpenTelemetry spans: agent_id, parent_span, tool_name, token_in/out, latency_ms. Export в existing APM. Minimum dashboard — CORE_METRICS:

Добавьте LLM-as-Judge на sample traces: evaluator agent scores goal alignment и factual consistency. Offline для regression tests, не inline на каждый request (cost).

def traced_agent_call(agent_name: str, task: dict, correlation_id: str = None):
    if not correlation_id:
        correlation_id = str(uuid.uuid4())
    with tracer.start_as_current_span(f"agent.{agent_name}") as span:
        span.set_attribute("agent.name", agent_name)
        span.set_attribute("correlation.id", correlation_id)
        result = agent_registry[agent_name].run(task)
        span.set_attribute("tokens_used", result.get("tokens", 0))
        return result

Decision framework: topology selection tree

AdaptOrch доказал: topology choice важнее model swap. Используйте decision tree до commit на framework — снижает risk over-engineering и wrong pattern lock-in.

1. ?

   Strict sequential dependencies между steps? Да → subtasks concurrent? Нет → Sequential Pipeline. Да → Hybrid: Pipeline + Fan-out.

2. ?

   Один agent имеет decision authority? Да → scale требует sub-teams? Нет → Supervisor-Worker. Да → Hierarchical (Supervisors of Supervisors).

3. ?

   Task long-running async (hours–days)? Да → Blackboard Architecture. Нет → continue.

4. ?

   Agent count ≤ 5 и termination well-defined? Да → Swarm с hard round/time limits. Нет → refactor в Hierarchical.

5. ?

   Need crash-safe resume? Да → LangGraph + PostgresSaver. Нет → CrewAI rapid path.

6. ?

   Cross-team agent discovery? Да → Agent Cards + A2A. Tools only → MCP per agent.

Три вопроса перед переходом на multi-agent