CrewAI и LangGraph — две самые популярные Python-библиотеки для мульти-агентных систем в 2026. CrewAI описывает агентов через роли (Researcher, Writer, Editor) и emergent collaboration; LangGraph — через явный направленный граф с состоянием и переходами. У каждого подхода свои сильные стороны: CrewAI быстрее в прототипировании, LangGraph надёжнее в production. В этой статье — разбор архитектуры, control flow, отладки и применимости.

CrewAI: роли и emergent collaboration

CrewAI вышла в 2023 как результат форка AutoGen от команды João Moura. Текущая стабильная версия — 0.121+ с активным развитием. Ключевая идея — агенты организуются через роли с целями, а не через код:

from crewai import Agent, Crew, Task, Process
from crewai_tools import SerperDevTool

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find authoritative sources on LLM inference optimization",
    backstory="You are a veteran ML systems engineer who has shipped production inference stacks at scale",
    tools=[SerperDevTool()],
    verbose=True,
    llm="claude-sonnet-4-5",
)

writer = Agent(
    role="Technical Writer",
    goal="Transform technical findings into 1000-word articles",
    backstory="You write in clear Russian for senior backend developers",
    llm="claude-sonnet-4-5",
)

research = Task(
    description="Find 5 authoritative sources on vLLM vs TGI throughput benchmarks in 2026",
    expected_output="List of 5 sources with URLs, key findings, methodology notes",
    agent=researcher,
)

write = Task(
    description="Using the research, write a 1000-word article in Russian for senior devs",
    expected_output="Russian-language article with H2 sections, code examples, internal links",
    agent=writer,
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research, write],
    process=Process.sequential,
    verbose=True,
)

result = crew.kickoff()

Process.sequential означает «выполняй задачи по порядку: сначала researcher → research, потом writer → write». Через документацию CrewAI доступны также hierarchical (с менеджером, делегирующим задачи) и consensual (Peer-to-peer discussion) процессы.

Главная фишка — агенты могут общаться между собой. После Task A результат автоматически передаётся агенту B как контекст. Можно включить manager_llm для иерархии — менеджер решает, кто что делает.

LangGraph: явный граф и контроль состояния

LangGraph вышла в июле 2024 как часть LangChain-экосистемы (разработка команды LangChain Inc.). Подробный разбор архитектуры — в материале про LangGraph как production-фреймворк. Ключевое отличие — агент описывается как направленный граф с состоянием:

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

class ResearchState(TypedDict):
    topic: str
    sources: list[str]
    draft: str

def research_step(state: ResearchState) -> ResearchState:
    sources = researcher.run(state["topic"])
    return {"sources": sources}

def write_step(state: ResearchState) -> ResearchState:
    draft = writer.run(state["topic"], state["sources"])
    return {"draft": draft}

def should_continue(state: ResearchState) -> str:
    return END if len(state["draft"]) > 800 else "research_refine"

graph = StateGraph(ResearchState)
graph.add_node("research", research_step)
graph.add_node("write", write_step)
graph.add_conditional_edges("write", should_continue)
graph.add_edge(START, "research")
graph.add_edge("research", "write")
app = graph.compile()

Каждый узел — обычная функция, возвращающая patch состояния. Роутер should_continue решает, идти ли в END или вернуться в research для уточнения. Контроль полностью в руках разработчика — нет emergent-логики, нет сюрпризов.

Контроль flow: декларативный vs императивный

Главное философское отличие — кто отвечает за последовательность шагов:

CrewAI описывает intent через роли. Декларативно сказано, что «Researcher должен сделать research, Writer должен написать статью». Но emergent-логика агентов решает, ЧТО именно делать: какие инструменты вызвать, какие источники искать, как структурировать статью. Это удобно для прототипирования, но непредсказуемо в production — две одинаковые задачи могут дать совершенно разный control flow.

LangGraph описывает явный control flow как граф. Разработчик задаёт, в каком порядке вызываются узлы, какие данные передаются между ними, какие условия для branching. Никакой emergent-логики — каждая ветка графа предсказуема.

Аспект	CrewAI	LangGraph
Control flow	Декларативный (intent), emergent	Императивный (явный граф), предсказуемый
Параллелизм	Через async tasks	Через Send или conditional edges с routing
Conditional	Внутри emergent-логики агентов	Через conditional edges с add_conditional_edges
Отладка	Логи verbose=2, replay tool steps	Чекпоинтеры, time-travel через snapshot

Persistence: emergent — нет, явный — да

CrewAI по умолчанию stateless. Каждый crew.kickoff() запускается с нуля. Если процесс прервался — перезапуск. Состояние агентов можно сохранять через storage (memory, JSON), но это поверхностно: snapshot results агентов, не control flow.

LangGraph включает checkpoint-based persistence из коробки через SqliteSaver, PostgresSaver, RedisSaver. Каждый шаг графа сериализуется в thread_id. После падения процесса граф восстанавливается с последнего checkpoint, а не начинает с нуля. Это критично для production:

from langgraph.checkpoint.sqlite import SqliteSaver
import sqlite3

conn = sqlite3.connect("checkpoints.db")
with SqliteSaver.from_conn_string(conn) as checkpointer:
    app = graph.compile(checkpointer=checkpointer)
    
    config = {"configurable": {"thread_id": "user-123"}}
    for chunk in app.stream({"topic": "vLLM vs TGI"}, config):
        print(chunk)
    
    # После прерывания — продолжить с последнего checkpoint:
    result = app.invoke(None, config)  # state восстановлен автоматически

Бонус — interrupt() для human-in-the-loop. Агент останавливается перед критическим действием (платёж, удаление, деплой), человек одобряет через UI, граф продолжает с того же state.

В CrewAI эквивалент — это кастомный код: до/после kickoff() сохранять state в свой store, но native-поддержки нет.

Human-in-the-loop и отладка

CrewAI поддерживает human input через human_input=True в Task — агенты буквально задают вопрос человеку через input(). Для простых случаев работает: «Уточните, пожалуйста, какой отраслевой регион вас интересует?». Для production UI нет.

LangGraph интегрируется с LangGraph Studio (visual graph UI) — графический отладчик, где видно текущее состояние каждого узла, можно вмешаться на любом шаге. В production Studio обычно не используют, но для dev — отлично. Также работает с interrupt_before / interrupt_after на любом узле.

Multi-agent паттерны

Оба фреймворка поддерживают классические паттерны (Supervisor, Swarm, Hierarchical), но по-разному.

В CrewAI supervisor встроен — это просто manager_llm в Crew(process=Process.hierarchical). Manager решает, какого агента дёргать, видит все доступные задачи. Простой паттерн, но менеджер может зациклиться, вызывая одного и того же агента дважды.

В LangGraph паттерн строится вручную:

from langgraph.graph import StateGraph, START, END
from langgraph.types import Command, Send

class WorkflowState(TypedDict):
    user_input: str
    plan: list[str]
    research: str
    draft: str
    critique: str

def supervisor(state: WorkflowState) -> Command:
    """Decide next step or request changes"""
    if not state.get("plan"):
        return Command(goto=[Send("planner", state)])
    if not state.get("research"):
        return Command(goto=[Send("researcher", state)])
    if not state.get("draft"):
        return Command(goto=[Send("writer", state)])
    if not state.get("critique"):
        return Command(goto=[Send("critic", state)])
    if "fix" in state.get("critique", "").lower():
        return Command(goto=[Send("writer", state)])  # Loop back
    return Command(goto=END)

graph.add_node("supervisor", supervisor)
graph.add_node("planner", planner_node)
graph.add_node("researcher", research_node)
graph.add_node("writer", writer_node)
graph.add_node("critic", critic_node)

Здесь supervisor может делегировать на любой узел, и цикл обратной связи между writer и critic явный. Это в разы надёжнее emergent-менеджера CrewAI: если критика содержит «fix», граф переходит обратно к writer, а не выбирает случайного агента.

Когда использовать каждый

CrewAI подходит, если:

• Нужен быстрый прототип за вечер (минимальный multi-agent за 30-50 строк)
• Задача интуитивно описывается через роли (Researcher → Writer → Editor)
• Не критично, что каждый прогон может дать разный результат
• Команда хорошо знает Python, но не хочет описывать control flow как граф

LangGraph подходит, если:

• Нужен production-grade агент с checkpoint/persistence
• Требуется точный control flow (multi-step retries, branching, parallel)
• Агент работает минуты+ и должен переживать рестарт контейнера
• Нужна observability (LangSmith, LangGraph Studio)
• State-машина — естественная модель (юридические workflow, ML-pipelines, business processes)

Использовать оба

Production-агенты в 2026 часто комбинируют: CrewAI как top-level оркестратор (команда агентов выполняет бизнес-задачу), LangGraph как low-level ядро каждого агента (тонкий control над состоянием, инструментами, retries). CrewAI запускает crew из 4-5 агентов, где каждый агент реализован как LangGraph-граф. Роли CrewAI остаются декларативными («Researcher делает research»), а внутренняя логика каждого агента — предсказуемый граф.

Если вы проектируете первый агент в проекте и сомневаетесь между ними — начните с CrewAI для прототипа. Если прототип показывает, что control-flow сложнее, чем казался (типичный паттерн — агенты гоняют друг друга по кругу, emergent-логика ненадёжна) — мигрируйте внутренности на LangGraph, сохранив CrewAI как top-level.

Заключение

CrewAI выигрывает на этапе прототипирования — быстрый результат, понятный код, минимальный boilerplate. LangGraph выигрывает в production — точный контроль, persistence, циклы, observability. Использовать оба вместе — рабочая стратегия для зрелых проектов. Если вас интересуют low-level детали LangGraph (StateGraph, reducers, persistence, MCP) — погруженный гайд в разделе про LangGraph разбирает архитектуру от паттерна до прода.