Два способа делиться данными
Агентам в команде нужно как-то передавать друг другу результаты. Два подхода — как в распределённых системах и параллельном программировании, где этот выбор известен десятилетиями:
- Shared state (общее состояние). Есть единая структура — «доска объявлений». Агент пишет туда результат, следующий читает оттуда. Никто ничего не «отправляет» напрямую — все работают с общей памятью.
- Message passing (передача сообщений). Общей памяти нет. Агент отправляет сообщение конкретному адресату; тот получает и отвечает. Данные живут в потоке сообщений между участниками.
Это не абстракция: LangGraph (модуль 03) — классический shared state: узлы читают и пишут общий State. AutoGen — классический message passing: агенты обмениваются сообщениями в разговоре. CrewAI — гибрид (задачи передают результат через context). Так что выбор подхода ты уже делал, просто выбирая фреймворк.
Shared state: общая доска
В модели общего состояния данные централизованы. Есть одна структура (в LangGraph — State), которую видят все агенты. Кто-то записал documents — все следующие их прочитают. Правила записи задают reducers (урок про reducers в модуле 03).
- единый источник правды — всё в одном месте
- легко дать любому агенту весь контекст
- удобно сохранять/восстанавливать (checkpoint)
- явная структура данных — понятно, что где
- связанность через общую структуру
- конфликты записи (нужны reducers)
- труднее «размазать» по разным процессам
- агент видит лишнее — весь state, не только своё
Message passing: сообщения
В модели сообщений общего хранилища нет. Данные передаются явно: агент A формирует сообщение и отправляет агенту B. Каждый видит только то, что ему прислали. Это децентрализованно и естественно ложится на «разговор» (AutoGen) и на распределённые системы, где агенты — разные сервисы.
- слабая связанность — агенты автономны
- легко распределять по процессам/сети
- агент получает только нужное (инкапсуляция)
- естественно для «разговорных» систем
- нет единой картины — сложнее отлаживать
- надо явно решать, кому что переслать
- контекст можно «потерять» при передаче
- дублирование данных в сообщениях
Суть выбора — централизация против децентрализации. Shared state даёт полную картину и простое сохранение ценой связанности (все зависят от общей структуры). Message passing даёт автономию и масштаб по процессам ценой видимости (нет одного места, где всё видно). Это тот же вечный размен, что «глобальные переменные vs передача аргументов» в обычном программировании.
Сравнение и как выбрать
| Критерий | Shared state | Message passing |
|---|---|---|
| Где данные | в общей структуре | в потоке сообщений |
| Связанность | выше (общая схема) | ниже (автономия) |
| Видимость / отладка | вся картина в одном месте | разрозненно |
| Сохранение (checkpoint) | просто — сериализуй state | сложнее |
| Распределённость по сети | труднее | естественно |
| Типичный представитель | LangGraph | AutoGen |
Нужен единый контекст, точный контроль и сохранение (сложные графы, checkpointing, time travel) → shared state (LangGraph). Нужны автономные агенты, распределённость, «разговорная» логика (агенты как отдельные сервисы, обмен по сети — привет протоколам вроде A2A из следующего раздела) → message passing (AutoGen). А на практике часто гибрид: общий state внутри одной команды + сообщения между командами/сервисами.
Гибриды и связь с протоколами
Чистых систем мало — реальные комбинируют оба подхода. Например: команда работает на общем state (удобно для координации внутри), но с внешним миром общается сообщениями (агент как сервис). Именно message passing лежит в основе межагентных протоколов — когда агенты живут в разных процессах/на разных машинах, общая память невозможна в принципе, и остаётся обмен сообщениями по сети.
Это прямой мост в следующий раздел про протоколы взаимодействия (A2A, MCP): там агенты — независимые сервисы, и message passing по HTTP — единственный способ им общаться. Shared state — про «внутри одного процесса/графа», message passing — про «между разными агентами-сервисами».
Типичные ошибки
Если несколько агентов пишут в одно поле общего state без правил слияния — конфликты и потеря данных. Поля, куда пишут многие, нужны с reducer (урок модуля 03).
Если переслать агенту только кусочек, он не увидит нужного контекста и переспросит/ошибётся. Явно решай, что должно ехать в сообщении.
В shared state легко навалить всё в одну структуру — тогда каждый агент тащит лишнее в контекст. Держи state осмысленным; приватное не выноси в общее.
Брать shared state или messages только потому, что «привык к фреймворку» — не аргумент. Смотри на потребности: нужен ли единый контекст/сохранение или автономия/распределённость.
Шпаргалка
ВОПРОС: КАК агенты обмениваются данными?
SHARED STATE (общая доска): MESSAGE PASSING (сообщения):
единая структура, все читают/ нет общей памяти, агент шлёт
пишут (LangGraph State) сообщение адресату (AutoGen)
✅ единый источник правды ✅ слабая связанность, автономия
✅ полная картина, легко чек- ✅ распределяется по сети
пойнтить ✅ агент видит только своё
❌ связанность, конфликты (нужны ❌ нет общей картины (отладка)
reducers), агент видит лишнее ❌ можно потерять контекст
РАЗМЕН: централизация (видимость, контроль, сохранение)
vs децентрализация (автономия, масштаб по процессам)
ВЫБОР:
единый контекст + контроль + checkpoint → SHARED STATE (LangGraph)
автономные сервисы + сеть + «разговор» → MESSAGES (AutoGen, A2A)
на практике часто ГИБРИД: state внутри команды, messages между сервисами
СВЯЗЬ: message passing → фундамент межагентных протоколов (A2A/MCP,
агенты в разных процессах — общей памяти НЕТ)
ГРАБЛИ:
• общие поля state → reducers (иначе конфликты)
• messages → не терять нужный контекст
• не раздувать общий state
• выбирай по задаче, не по привычке
Практическое задание
Прочувствуй разницу на одной задаче:
Задание: одна команда — два подхода к обмену
- Возьми команду из 3 агентов (analyst → writer → critic). Реализуй её на shared state (LangGraph): агенты читают/пишут общий State. Отметь, как легко дать критику весь контекст.
- Реализуй ту же команду на message passing (AutoGen): агенты передают результаты сообщениями. Отметь, что каждый видит только присланное.
- Сравни отладку: где проще увидеть «что произошло на каждом шаге»? Где данные разрозненнее?
- Добавь checkpoint/сохранение состояния. В каком подходе это сделать проще и почему?
- Представь, что агенты — разные сервисы на разных машинах. Какой подход применим, а какой — нет? (Подсказка: общей памяти между машинами не бывает.)
- Со звёздочкой: спроектируй гибрид — общий state внутри команды, но обмен с внешним агентом-сервисом через сообщения. Где проходит граница?
Что дальше
На этом раздел «Паттерны координации» закрыт: ты знаешь топологии (Supervisor, Pipeline, Swarm, Debate) и оба способа обмена данными. Message passing естественно ведёт в следующий раздел — протоколы взаимодействия между агентами: когда агенты становятся независимыми сервисами, им нужен стандарт общения по сети. Начнём с A2A Protocol.