Координация, общая память и компромиссы

Команда агентов работает только при согласованности. Разбираем общую память для координации и честно считаем цену мультиагентности.

Общая память (shared memory / blackboard) — общее хранилище, куда агенты пишут результаты и откуда читают чужие, чтобы координироваться без прямого общения каждый-с-каждым.

Как агенты координируются

Чтобы агенты действовали как команда, им нужно делиться состоянием. Два подхода:

  • Через сообщения — агенты передают результаты напрямую (как в конвейере или через оркестратор).
  • Через общую память (доску) — есть общее хранилище; каждый агент пишет туда свой вклад и читает чужой. Удобно, когда участников много.

Общая память на практике

Смоделируем «доску»: общий словарь, куда агенты складывают результаты, опираясь на уже записанное другими.

# общая память (доска)
blackboard = {}

def researcher():
    blackboard["facts"] = "столица Японии — Токио"

def analyst():
    # читает чужой результат с доски
    facts = blackboard.get("facts", "")
    blackboard["summary"] = "Кратко: " + facts

def writer():
    summary = blackboard.get("summary", "")
    blackboard["report"] = "Отчёт готов. " + summary

# агенты работают по очереди через общую память
researcher()
analyst()
writer()

for key, value in blackboard.items():
    print(f"{key}: {value}")

Вывод:

facts: столица Японии — Токио
summary: Кратко: столица Японии — Токио
report: Отчёт готов. Кратко: столица Японии — Токио

Агенты не вызывали друг друга напрямую — они общались через доску. Аналитик увидел факты исследователя, писатель — резюме аналитика. Так координируют системы с многими участниками.

Компромиссы: за что платим

Мультиагентность мощна, но дорога. Честный список издержек:

ИздержкаСуть
Стоимостьнесколько агентов = в разы больше вызовов LLM
Латентностьагенты ждут друг друга, задержки складываются
Сложностькоординация, общая память, протоколы — больше кода и точек отказа
Накопление ошибокошибка одного агента портит вход следующего

Ошибки накапливаются — между агентами тоже

Та же арифметика надёжности, что в разделе 1, работает и для цепочки агентов: если каждый прав с вероятностью 0.9, то четыре последовательных агента дают уже около 0.9⁴.

per_agent = 0.9
for n in [1, 2, 3, 4]:
    overall = per_agent ** n
    print(f"{n} агент(ов) подряд -> надёжность: {overall:.0%}")

Вывод:

1 агент(ов) подряд -> надёжность: 90%
2 агент(ов) подряд -> надёжность: 81%
3 агент(ов) подряд -> надёжность: 73%
4 агент(ов) подряд -> надёжность: 66%

Отсюда практический вывод: не плодите агентов без нужды. Каждый дополнительный участник добавляет стоимость и шанс ошибки. Начинайте с одного агента; разбивайте на несколько, только когда выгода от специализации перевешивает цену координации.

Итог

  • Агенты координируются через сообщения или общую память (доску), куда пишут и откуда читают.
  • Мультиагентность платит стоимостью, латентностью, сложностью и накоплением ошибок.
  • Надёжность падает с числом агентов в цепочке — добавляйте их только при реальной выгоде.
Проверьте себя
1. Что такое общая память (доска) в мультиагентной системе?
AКонтекстное окно одной модели
BОбщее хранилище, куда агенты пишут результаты и откуда читают чужие для координации
CСписок инструментов
DЛог ошибок
2. Почему надёжность падает с ростом числа агентов в цепочке?
AМодель устаёт
BВероятности успеха каждого агента перемножаются, поэтому ошибка одного портит вход следующего
CАгенты конфликтуют за память
DРастёт размер контекста
3. Какой практический вывод следует из издержек мультиагентности?
AВсегда использовать как можно больше агентов
BНачинать с одного агента и разбивать на несколько только при реальной выгоде от специализации
CНикогда не использовать несколько агентов
DКоординация ничего не стоит
Поддержать проект