Урок 9.7. Agent frameworks with state: LangGraph, AutoGen, CrewAI, Mastra

Цель лекции

Разобрать open-source agent frameworks, которые управляют состоянием агента: LangGraph, AutoGen, CrewAI и Mastra. Показать, какую часть memory layer они закрывают, а какую нужно проектировать отдельно.

Ожидаемый результат

Читатель понимает разницу между agent state, workflow checkpoint, conversation memory и полноценной долговременной памятью. Он умеет выбрать agent framework не как замену memory system, а как runtime, вокруг которого строится memory architecture.

Зачем это нужно

В предыдущих лекциях мы разобрали dedicated memory frameworks: Mem0, Zep и Letta. Но в реальных проектах память агента часто появляется не отдельным сервисом, а внутри agent framework.

Такие фреймворки умеют:

хранить состояние workflow;
поддерживать многошаговое выполнение;
запускать tools;
координировать несколько агентов;
сохранять checkpoints;
возобновлять выполнение после паузы;
иногда подключать memory stores и RAG.

Из-за этого возникает соблазн сказать:

Мы используем LangGraph/CrewAI/AutoGen/Mastra, значит память уже решена.

Это не всегда так. Agent framework отвечает за execution model. Memory layer отвечает за lifecycle знаний: что записывать, как обновлять, где искать, что вставлять в prompt, как забывать и как соблюдать права доступа.

Основная идея

Agent framework with state - это каркас поведения агента. Он помогает описать, как агент движется по шагам, какие tools вызывает, где хранит промежуточное состояние и как продолжает выполнение.

Memory system шире. Она должна отвечать на вопросы:

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

Поэтому agent framework часто становится runtime layer, а не всей памятью.

flowchart TD U[User request] --> AF[Agent framework] AF --> S[Short-term state] AF --> C[Checkpoint store] AF --> T[Tool execution] AF --> MR[Memory read] AF --> MW[Memory write] MR --> ML[Memory layer] MW --> ML ML --> P[Policies] ML --> R[Retrieval] ML --> DB[(Stores and indexes)] ML --> A[Audit]

Ключевые термины

Термин	Короткое определение
`Agent framework`	Библиотека или runtime для orchestration агента: state, tools, steps, workflows, multi-agent coordination.
`State`	Текущее состояние выполнения: messages, промежуточные данные, результаты tools, выбранный путь workflow.
`Checkpoint`	Снимок состояния, позволяющий продолжить, отладить или replay выполнить workflow.
`Thread`	Одна сессия или ветка взаимодействия, внутри которой сохраняется conversation state.
`Store`	Долговременное хранилище данных, доступное между threads или sessions.
`Durable agent`	Агент, выполнение которого может переживать рестарт процесса, паузу, human approval или долгую задачу.

Сравнительная карта

Framework	Центр тяжести	Что дает для памяти	Где нужен отдельный design
LangGraph	Graph/state machine	Checkpoints, thread state, stores, replay, human-in-the-loop	Extraction, policies, user memory schema, deletion
AutoGen	AgentChat и multi-agent teams	Memory protocol, context update, custom memory stores	Governance, lifecycle, product-specific memory rules
CrewAI	Crews, Flows, role-based agents	Unified memory, knowledge, flow state, collaborative execution	Scope isolation, long-term facts, audit, user controls
Mastra	TypeScript agents, workflows, memory	Message history, working memory, semantic recall, storage abstractions	Enterprise policies, retention, conflict handling

Эта таблица не говорит, что один framework лучше другого. Она показывает, какой слой они закрывают.

LangGraph: state graph, checkpoints и stores

LangGraph полезен, когда агентское поведение лучше описывать как граф состояний:

узлы выполняют шаги;
ребра задают переходы;
состояние передается между узлами;
checkpointer сохраняет snapshots;
workflow можно interrupt, resume и replay.

Для памяти особенно важны два слоя:

Short-term memory как thread-scoped state.
Long-term memory через store с namespaces.

Short-term memory хранит то, что нужно в текущей ветке взаимодействия: messages, выбранные документы, tool outputs, пользовательские уточнения в рамках текущей задачи.

Long-term store может хранить user facts, preferences, project notes или другие записи между threads.

flowchart LR T1[Thread A] --> CP[Checkpointer] T2[Thread B] --> CP T1 --> ST[Shared store] T2 --> ST ST --> U1[Namespace: user memories] ST --> P1[Namespace: project memories]

Сильная сторона LangGraph - контроль над execution state. Это хорошо для:

human-in-the-loop workflows;
задач с pause/resume;
воспроизводимой отладки;
branching and replay;
устойчивого выполнения long-running tasks.

Но checkpoint не равен memory record. Checkpoint сохраняет состояние выполнения. Memory record должен иметь type, scope, source, confidence, time, retention и policy.

AutoGen: Memory protocol и multi-agent контекст

AutoGen ориентирован на агентные команды и agent conversations. В AgentChat memory реализуется через protocol, где memory object может:

добавлять записи;
искать релевантную информацию;
обновлять context агента перед шагом;
очищать store;
закрывать ресурсы.

Это удобная abstraction: можно начать с простой list memory, затем подключить ChromaDB, Redis или собственный backend.

AutoGen особенно полезен, когда:

несколько агентов разговаривают и распределяют роли;
нужно подключать разные memory implementations;
RAG и memory должны добавляться в context agent step;
важна наблюдаемость событий в agent team.

Ограничение похоже на другие frameworks: protocol говорит, как memory object вызывается, но не решает product governance автоматически.

Например, если support agent использует AutoGen memory, приложение все равно должно определить:

можно ли сохранять customer-specific fact;
в каком tenant scope лежит запись;
как работает deletion;
какие sources считаются trusted;
кто видит shared team memory.

CrewAI: crews, flows, roles and memory

CrewAI строит систему вокруг ролей, задач, crews и flows. Это удобно, когда агентская система напоминает рабочую команду:

researcher собирает данные;
analyst сравнивает источники;
writer готовит текст;
reviewer проверяет результат.

Для памяти CrewAI важен как orchestration слой:

agents имеют роли и цели;
tasks передают результаты;
flows задают более контролируемый workflow;
memory/knowledge могут использоваться как общий контекст выполнения.

В multi-agent системах это быстро приводит к shared memory problem.

Researcher нашел источник.
Analyst сделал вывод.
Writer использовал вывод.
Reviewer обнаружил, что источник слабый.

Что должна помнить система?

сам источник;
claim;
оценку надежности;
связь claim -> source;
correction от reviewer;
правило не использовать этот claim как подтвержденный факт.

CrewAI помогает организовать роли и выполнение. Но модель памяти для claims, provenance и corrections все равно нужно проектировать.

Mastra: TypeScript runtime, workflows и memory primitives

Mastra интересен тем, что соединяет TypeScript agent runtime, tools, workflows, MCP, tracing и memory primitives.

В memory layer обычно выделяются:

message history;
working memory;
semantic recall;
storage provider;
thread/resource identifiers;
context assembly перед model call.

Для продукта это полезно, если стек уже TypeScript-centric и команда хочет держать agent runtime рядом с application backend.

Mastra-style memory хорошо ложится на сценарии:

web application agents;
voice or chat agents с thread/resource моделью;
workflows с persistent execution;
agents with tools and MCP;
быстрый local-to-production путь.

Но, как и в других случаях, framework не отменяет вопросы:

какие memory records являются source of truth;
как отделять session-only instruction от long-term preference;
как проводить PII filtering;
как тестировать semantic recall;
как сохранять audit trail для user-visible memory.

Agent state vs memory layer

Главное различие:

Вопрос	Agent state	Memory layer
Для чего нужно	Выполнить текущий workflow	Сохранять и использовать знания между задачами
Срок жизни	Thread, run, workflow	Session, user, project, org, long-term
Тип данных	Messages, variables, tool outputs	Facts, events, skills, summaries, relationships
Основной риск	Потерять выполнение или перепутать state	Запомнить неверное, устаревшее или запрещенное
Контроль	Checkpoints, reducers, graph state	Policies, scopes, provenance, deletion, audit

Agent state может стать источником episodic memory, но не должен автоматически превращаться в semantic memory.

Пример:

Tool output:
"Команда pytest упала, потому что нет pytest в .venv."

Это событие текущего run. Его можно сохранить как episode.

Но semantic memory вида:

"В проекте никогда не используется pytest."

будет неправильным обобщением. Нужна extraction policy и confidence.

Где agent frameworks особенно полезны

Agent frameworks with state особенно хороши, когда есть:

multi-step workflow;
retries;
human approval;
parallel branches;
multi-agent coordination;
tool-heavy tasks;
long-running jobs;
необходимость replay/debug;
сохранение task progress.

Они хуже подходят как единственный ответ на:

user profile memory;
compliance-grade deletion;
permission-aware enterprise retrieval;
temporal fact invalidation;
domain-specific knowledge graph;
объяснимый audit of memory usage.

Open-source критерии выбора

При выборе open-source agent framework смотрите не только на README.

Критерий	Что проверить
License and governance	Можно ли использовать в вашем продукте, кто контролирует roadmap.
Persistence model	Есть ли checkpointer/store, какие backend поддерживаются.
Memory API	Можно ли заменить memory backend и добавить policies.
Observability	Видны ли tool calls, state transitions, retrieved context.
Deployment	Легко ли self-host, тестировать локально, запускать в CI.
Extensibility	Можно ли добавить custom retriever, store, middleware, guardrails.
Ecosystem	Есть ли интеграции с RAG, vector DB, MCP, tracing.

Для курса важно не заучить список инструментов, а увидеть pattern: open-source framework дает control surface, но ответственность за memory semantics остается у архитектора.

Мини-кейс: coding agent на LangGraph

Задача: агент чинит баги в репозитории и может продолжать работу после interruption.

Стек:

LangGraph state graph
SQLite/Postgres checkpointer
Project files as source of truth
Structured episodic log
Optional vector/code search
Procedural memory in AGENTS.md

Что хранит LangGraph:

текущий план;
список измененных файлов;
результаты команд;
checkpoint перед risky step;
состояние human approval.

Что хранит memory layer:

recurring project conventions;
прошлые ошибки и их решения;
stable user preferences;
known commands;
decisions with provenance.

Если смешать эти слои, агент начнет считать временный command output постоянным правилом проекта.

Мини-кейс: multi-agent research team на AutoGen или CrewAI

Задача: команда агентов готовит аналитический обзор.

Agent framework управляет:

ролями;
очередностью реплик;
task delegation;
termination conditions;
handoff between agents.

Memory layer должна хранить:

sources;
claims;
confidence;
contradictions;
reviewer corrections;
citation graph;
decisions about inclusion/exclusion.

Здесь нельзя ограничиться conversation history. Research memory должна быть structured и source-aware.

Типичные ошибки

Ошибка 1: считать checkpoint долговременной памятью.

Checkpoint нужен для resume/debug. Он не заменяет semantic memory with lifecycle.

Ошибка 2: сохранять все state variables как memory.

Большая часть state является временной и должна умереть вместе с run.

Ошибка 3: позволять каждому агенту писать в shared memory без правил.

Multi-agent memory требует ownership, schemas and conflict resolution.

Ошибка 4: не тестировать resume behavior.

Если framework выбран ради durability, нужно проверять interruption, restart, replay and duplicate tool calls.

Ошибка 5: забывать о permissions.

Agent framework может правильно выполнить workflow, но memory retrieval все равно может раскрыть чужой context.

Источники для дальнейшего чтения

LangGraph persistence: https://docs.langchain.com/oss/python/langgraph/persistence
LangGraph memory overview: https://docs.langchain.com/oss/python/concepts/memory
AutoGen Memory and RAG: https://microsoft.github.io/autogen/dev/user-guide/agentchat-user-guide/memory.html
CrewAI documentation: https://docs.crewai.com/
Mastra agent memory guide: https://mastra.ai/blog/agent-memory-guide
Mastra memory layers: https://mastra.ai/blog/agent-memory-layers

Краткое резюме

Agent frameworks with state нужны для orchestration: graph execution, tools, multi-agent workflows, checkpoints, pause/resume and durable runs.

Они являются важной частью memory stack, но не заменяют memory layer. Долговременная память требует extraction, scopes, policies, update, deletion, retrieval quality, observability and user control.

Вопросы для самопроверки

Чем checkpoint отличается от memory record?
Почему agent state не стоит автоматически превращать в semantic memory?
Какие memory responsibilities остаются у приложения при использовании LangGraph или AutoGen?
Когда multi-agent framework требует shared memory governance?
Какие критерии важны при выборе open-source agent framework?

Что дальше

В следующей лекции мы отдельно разберем RAG frameworks: LangChain, LlamaIndex и Haystack. Они особенно важны для world memory, document retrieval, source attribution and grounded answers.