Паттерны агентов

Короткая версия

В 2026 полезно думать о паттернах так:

• Workflow: код заранее определяет путь выполнения.
• Agent: модель сама выбирает следующий шаг, tools и иногда handoff.

Самые полезные practical patterns сейчас:

• Routing
• Prompt chaining
• Parallelization
• Orchestrator-worker
• Evaluator-optimizer
• Manager with specialists
• Handoffs
• Tool-using autonomous agent

Нужно построить support-систему: сначала понять тип обращения, потом отправить в нужный поток, а в конце проверить ответ на policy.

1. Базовое различие: workflows vs agents

Это сейчас главный architectural split.

Workflows

Workflow — это система, где путь выполнения в основном задаётся кодом:

• известны этапы;
• есть control points;
• проще тестировать;
• проще ограничивать cost и latency.

Примеры:

• классифицировать запрос и выбрать нужный pipeline;
• сделать research -> outline -> draft -> review;
• параллельно прогнать несколько независимых проверок;
• прогнать answer через policy evaluator.

Agents

Agent — это система, где модель в loop сама решает:

• что делать дальше;
• какой tool вызвать;
• нужно ли делегировать подзадачу;
• когда завершать run.

Anthropic формулирует это очень практично: агенты полезны для open-ended задач, где число шагов и точный путь нельзя надёжно захардкодить.

2. Routing: сначала понять тип задачи

Routing — один из самых полезных паттернов. Система сначала классифицирует задачу, а затем направляет её в конкретный поток.

Типичные сценарии:

• support: billing / refund / tech issue;
• coding: bugfix / refactor / explanation;
• content: draft / critique / summarize;
• enterprise agent: CRM / knowledge base / escalation.

Почему этот паттерн силён:

• дешевле, чем один универсальный агент;
• проще eval'ить;
• легче держать prompts короче и точнее.

3. Prompt chaining: последовательные этапы

Prompt chaining означает, что выход одного шага становится входом следующего.

Это хороший паттерн, когда:

• этапы понятны и проверяемы;
• нужно разбить задачу на маленькие шаги;
• между шагами есть естественные артефакты.

Примеры:

• research -> outline -> draft -> critique;
• extract -> normalize -> classify;
• retrieve -> answer -> verify.

Это современный practical replacement для многих старых “plan-and-execute” сценариев, где не нужен по-настоящему автономный агент.

4. Parallelization: независимые проверки и ускорение

Parallelization полезна в двух основных режимах:

Разделение независимых подзадач

Например:

• один lane проверяет policy;
• другой ищет factual support;
• третий оценивает tone или format.

Множественные оценки одной задачи

Например:

• несколько grader'ов;
• несколько rubric checks;
• несколько candidate generations с последующим выбором.

Это не “агентная магия”, а просто хороший orchestration pattern, который часто даёт лучший speed/quality trade-off, чем один длинный автономный run.

5. Orchestrator-worker: неизвестное число подзадач

Orchestrator-worker нужен, когда задача распадается на подзадачи, но их точное число заранее неочевидно.

Классический flow:

1. orchestrator планирует decomposition;
2. создаёт workers;
3. workers решают свои куски;
4. orchestrator собирает финальный результат.

Когда паттерн полезен:

• writing/report generation;
• research across sections;
• code changes across many files;
• long document processing.

Это уже сложнее routing и chaining, но всё ещё обычно более контролируемо, чем один автономный mega-agent.

6. Evaluator-optimizer: quality loop

Evaluator-optimizer — это production-friendly версия “reflection”.

Паттерн:

• один шаг генерирует результат;
• другой шаг оценивает его по критериям;
• если критерии не выполнены, система делает ещё одну итерацию.

Это полезно, когда:

• success criteria понятны;
• нужна доводка до стандарта;
• важнее quality, чем минимальная latency.

Важно: evaluator должен опираться не на vague “сделай лучше”, а на конкретные rubric / pass-fail conditions.

7. Manager vs handoff

Это один из самых важных agent patterns сегодня, особенно после OpenAI Agents SDK.

Manager with specialists

Главный агент остаётся owner conversation и вызывает specialist agents как tools.

Подходит, когда:

• один agent должен собрать и синтезировать ответы;
• нужен единый policy layer;
• specialist решает bounded subtask.

Handoff

Triage agent передаёт разговор specialist-агенту, и тот становится владельцем следующей части взаимодействия.

Подходит, когда:

• routing itself is part of workflow;
• specialist должен отвечать напрямую;
• нужны более узкие инструкции и context.

OpenAI docs прямо формулируют это различие:

• agents as tools для bounded subtask;
• handoffs для передачи ownership диалога.

8. Tool-using autonomous agent

Только здесь мы приходим к тому, что раньше часто называли просто ReAct agent.

Автономный tool-using agent нужен, когда:

• путь решения заранее не ясен;
• возможны разные sequences of tools;
• задача достаточно открытая;
• вы готовы платить за loop и ошибки.

Этот паттерн силён для:

• coding agents;
• research agents;
• browser/computer use;
• open-ended ops tasks.

Но у него есть реальные costs:

• больше latency;
• выше token/tool cost;
• compounding errors;
• труднее reproducibility.

Поэтому practical guidance в 2026 обычно такая: autonomous agent loop — не default, а deliberate choice.

9. Как выбирать паттерн

Практический выбор можно свести к нескольким вопросам:

10. Что чаще всего работает в production

На практике самые здоровые системы часто выглядят так:

• routing + specialist workflow;
• prompt chaining + evaluator;
• manager agent + tools;
• triage + handoff;
• orchestrator-worker только там, где decomposition реально dynamic.

И только в отдельных участках:

• fully autonomous tool-using agent;
• computer use loop;
• open-ended research/coding agent.

То есть зрелая agent architecture обычно гибридная: часть deterministic, часть agentic.

Routing через structured output

from pydantic import BaseModel
from typing import Literal


class Route(BaseModel):
    lane: Literal["billing", "support", "refund"]


def route_ticket(classifier, text: str) -> str:
    result = classifier(text)
    return result.lane

Это почти всегда здоровее, чем один универсальный агент с 20 tool'ами и 5 специализациями в одном prompt.

Prompt chaining как control-friendly default

def run_chain(task: str):
    research = do_research(task)
    outline = make_outline(research)
    draft = write_draft(outline)
    review = critique(draft)
    return improve(draft, review)

Да, это “просто pipeline”, но именно такие пайплайны часто и выигрывают у supposedly smarter autonomous agent loops.

Manager vs handoff в стиле OpenAI Agents SDK

from agents import Agent


billing_agent = Agent(name="Billing specialist")
refund_agent = Agent(name="Refund specialist")

triage_agent = Agent(
    name="Triage",
    instructions="Маршрутизируй пользователя к нужному специалисту.",
    handoffs=[billing_agent, refund_agent],
)

Если specialist должен лишь помочь с bounded subtask, его часто лучше давать как Agent.as_tool(). Если он должен принять ownership следующей части разговора, нужен handoff.

Evaluator-optimizer loop

def refine_until_pass(generate, evaluate, max_rounds=3):
    draft = generate()
    for _ in range(max_rounds):
        verdict = evaluate(draft)
        if verdict["pass"]:
            return draft
        draft = improve(draft, verdict["feedback"])
    return draft

Production-нюанс:

• лимитируйте число итераций;
• логируйте feedback;
• связывайте verdict с eval traces.

Autonomous agent loop только там, где он окупается

def autonomous_loop(agent, task, max_steps=10):
    state = task
    for _ in range(max_steps):
        step = agent.next_step(state)
        if step["type"] == "done":
            return step["output"]
        state = execute(step)
    return {"status": "stopped", "reason": "max_steps_exceeded"}

Нормальный production baseline:

• sandbox;
• step/time limits;
• tool guardrails;
• trace logging;
• evals на successful completion.

У нас customer support system с triage, policy checks, knowledge lookup и escalation. С какого паттерна начать?

Проверьте себя