Мультиагентные системы: конкурентная архитектура Mozaik

Мультиагентные системы: последовательный и конкурентный подходы

Построение мультиагентной системы на бумаге выглядит просто: дайте одному агенту задачу, другой выполнит следующий шаг, добавьте ревьюера, подключите инструменты — и вот вам агентный воркфлоу. Но всё усложняется, когда агентам нужно работать одновременно.

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

Mozaik предлагает другой архитектурный подход. Это open-source TypeScript-фреймворк для построения реактивных агентов в событийно-ориентированной среде, где агенты могут работать конкурентно, реагировать на события и координироваться без центрального воркфлоу, определяющего каждое взаимодействие.

И теперь есть практическая возможность попробовать эту архитектуру: JigJoy совместно с daily.dev и Hyperskill организует Mozaik Hackathon 2026 — бесплатный онлайн-хакатон, посвящённый построению конкурентных AI-агентов.

Сравнение последовательных и конкурентных мультиагентных систем

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

Представьте исследовательское приложение с пятью специализированными агентами:

• Исследователь собирает информацию.
• Аналитик изучает находки.
• Критик ищет слабые места.
• Писатель превращает результаты в ответ.
• Ревьюер проверяет итоговый вывод.

Воркфлоу может выглядеть так:

Исследователь
    ↓
Аналитик
    ↓
Критик
    ↓
Писатель
    ↓
Ревьюер

У каждого агента есть чёткая ответственность, и каждый этап передаёт результат следующему. Для задач, где каждый шаг зависит от предыдущего, такой подход оправдан.

Проблема возникает, когда агентам не нужно ждать друг друга. Предположим, исследователь нашёл три полезных источника. Аналитик мог бы начать изучать первый источник, пока исследователь продолжает сбор. Критик мог бы проверить раннюю находку, пока остальное исследование ещё идёт. Наблюдатель мог бы непрерывно мониторить работу и реагировать на проблемы.

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

Это различие — центральное для Mozaik.

Таблица сравнения:

• Последовательный воркфлоу: агенты следуют упорядоченному пути выполнения; один этап часто ждёт другой; логика оркестрации определяет воркфлоу; добавление агента может потребовать изменений в воркфлоу; длительная работа задерживает нижестоящие этапы; агенты тесно связаны с конкретным воркфлоу.
• Конкурентная модель Mozaik: агенты реагируют на события по мере поступления; несколько агентов могут работать одновременно; участники сами определяют свои реакции; новые участники могут присоединиться к общей среде; неблокирующий вывод позволяет другой активности продолжаться; агенты могут работать более независимо.

Цель — не сделать каждый AI-воркфлоу конкурентным. Некоторые задачи действительно имеют зависимости, требующие порядка. Mozaik полезен для случаев, когда нескольким агентам нужно наблюдать за одной и той же активностью, независимо реагировать и продолжать работу, пока другие агенты ещё обрабатывают данные.

Это меняет проектирование системы. Вместо цепочки вида:

Агент A → Агент B → Агент C

вы можете думать о системе как об общей среде, в которой несколько участников реагируют на события:

Событие ──────────────┼── Агент-исследователь
                    │
                    ├── Агент-планировщик
                    │
                    ├── Агент-кодер
                    │
                    ├── Агент-ревьюер
                    │
                    └── Наблюдатель

У агентов по-прежнему разные обязанности, но их взаимосвязь не обязательно кодировать как жёсткий конвейер.

Это также влияет на независимость и переиспользование агентов. Когда поведение агента основано на событиях, которые он получает, и обработчиках, которые он реализует, такого агента легче перенести в другое приложение или объединить с другим набором участников.

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

Это важная часть подхода Mozaik: конкурентность и интероперабельность связаны с самой архитектурой. Фреймворк даёт агентам общую среду для совместной работы, позволяя их индивидуальному поведению оставаться раздельным.

Событийно-ориентированная архитектура Mozaik для конкурентных AI-агентов

Mozaik строит свою конкурентную мультиагентную архитектуру вокруг AgenticEnvironment.

Среда является общей для людей, агентов, наблюдателей и инструментов. Каждый участник может генерировать события, а другие участники могут слушать события, значимые для их роли, и решать, как на них реагировать.

События могут включать простые текстовые сообщения, типизированные ContextItem, представляющие взаимодействия с моделью, и потоковые SemanticEvent<T> чанки, генерируемые во время инференса.

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

AgenticEnvironment: общий событийно-ориентированный слой

AgenticEnvironment действует как коммуникационный слой между участниками.

Человек может отправить сообщение в среду. Агент получает его через onMessage(). Затем агент запускает инференс, который может породить рассуждения, сообщения модели или вызовы функций. Другие участники могут наблюдать эти события и решать, нужно ли им отвечать.

Поток выглядит так:

Сообщение
   ↓
Агент реагирует
   ↓
runInference()
   ↓
События модели
   ├── Рассуждения
   ├── Вызов функции
   └── Сообщение модели
          ↓
    Другие участники реагируют

Нет требования, чтобы каждый участник завершил свою работу, прежде чем среда продолжит обработку других событий. Это важно, потому что инференс модели не мгновенен. Медленный вызов модели не должен превращать всю мультиагентную систему в очередь ожидания.

Неблокирующий инференс держит агентов в движении

Возможность runInference() в Mozaik спроектирована как неблокирующая.

Реактивный агент может получить сообщение, добавить его в свой ModelContext и запустить инференс:

async onMessage(message: string): Promise<void> {
    this.context.addContextItem(UserMessageItem.create(message));
    runInference({
        model: "gpt-5.5",
        context: this.context,
        caller: this,
        environment: this.environment
    });
}

Важная деталь — что происходит после вызова runInference(): обработчик возвращается, пока модель продолжает работать. Агенту не нужно ждать результата инференса, прежде чем среда обработает другую активность. Тот же участник может ответить на другое событие, а другие участники могут продолжать обработку своих событий.

Когда инференс порождает новые ContextItem, они отправляются обратно через среду. Агент может реагировать через обработчики onReasoning, onFunctionCall и onModelMessage, а другие участники могут наблюдать соответствующие внешние события.

Таким образом, базовый паттерн становится:

Событие
  ↓
Реакция
  ↓
Инференс или вызов инструмента
  ↓
Новое событие
  ↓
Другая реакция

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

Участники делают агентов слабо связанными

Mozaik также разделяет участников и общий поток приложения.

Базовый класс BaseParticipant обеспечивает основу для участников, а обработчики onMessage, onFunctionCall, onReasoning и onModelMessage позволяют каждому участнику реализовать только необходимое поведение.

Это означает, что участнику не нужно знать всё приложение. Планировщик может сосредоточиться на планировании, исследователь — на исследовании, критик — на оценке, наблюдатель — на мониторинге событий. Все они могут участвовать в одной AgenticEnvironment без центрального контроллера, содержащего все взаимодействия.

Это также делает архитектуру полезной для переиспользуемых AI-агентов. Если поведение агента определяется вокруг событий, которые он понимает, и действий, которые он может выполнять, того же участника можно потенциально ввести в другую среду с другим набором агентов.

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

Для разработчиков, создающих системы оркестрации AI-агентов, это значимое изменение в структуре архитектуры: среда предоставляет общий коммуникационный слой, а каждый участник владеет своим поведением.

Начало работы с Mozaik: TypeScript-рантайм для конкурентных агентов

Mozaik написан на TypeScript и доступен как пакет @mozaik-ai/core.

Для нового проекта вы можете установить его через npm:

npm install @mozaik-ai/core

Затем создайте экземпляр AgenticEnvironment и определите своих агентов. Вот минимальный пример реактивного агента:

import { AgenticEnvironment, BaseParticipant, runInference, UserMessageItem } from '@mozaik-ai/core';

class MyAgent extends BaseParticipant {
    constructor(environment: AgenticEnvironment) {
        super(environment);
        // Подписываемся на сообщения
        this.onMessage = this.handleMessage.bind(this);
    }

    async handleMessage(message: string) {
        // Добавляем сообщение в контекст модели
        this.context.addContextItem(UserMessageItem.create(message));
        // Запускаем неблокирующий инференс
        runInference({
            model: "gpt-5.5",
            context: this.context,
            caller: this,
            environment: this.environment
        });
    }

    // Обработчик результата инференса
    async onModelMessage(content: string) {
        console.log(`Агент получил ответ: ${content}`);
        // Отправляем результат обратно в среду
        this.environment.emitMessage(content);
    }
}

Этот код демонстрирует ключевые концепции: агент подписывается на сообщения, запускает инференс асинхронно и обрабатывает результат, не блокируя другие события.

Mozaik Hackathon 2026: создайте конкурентную мультиагентную систему

Теперь у вас есть возможность применить эти знания на практике. Mozaik Hackathon 2026 — это бесплатный онлайн-хакатон, организованный JigJoy совместно с daily.dev и Hyperskill.

Кто может участвовать?

Хакатон открыт для всех разработчиков, независимо от уровня. Если вы экспериментировали с AI-агентами, это шанс выйти за рамки простой оркестрации API и изучить, как проектируются конкурентные мультиагентные системы.

Таймлайн хакатона: 4–13 сентября 2026

• 4 сентября: онлайн-открытие с лайвстримом
• 5–6 сентября: основной период разработки
• 13 сентября: объявление победителей

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

Что можно построить с Mozaik?

Возможности ограничены только вашей фантазией. Вот несколько идей:

• Система автоматического ревью кода с несколькими агентами-ревьюерами
• Исследовательский ассистент, который параллельно собирает и анализирует данные
• Чат-бот с агентами-наблюдателями для модерации и улучшения ответов
• Инструмент для генерации контента, где один агент пишет, другой критикует, третий редактирует

Главное — использовать конкурентные возможности Mozaik, чтобы агенты работали одновременно и реагировали на события.

Почему разработчикам стоит присоединиться

Вы получите практический опыт с современной архитектурой мультиагентных систем. В отличие от типичных туториалов, хакатон заставит вас решать реальные проблемы и интегрировать агентов в работающее приложение.

Кроме того, есть денежный призовой фонд: $1000 на троих победителей ($500 за первое место, $300 за второе, $200 за третье). Это не только признание, но и материальная мотивация.

Практический вывод: что делать прямо сейчас

Не ждите сентября, чтобы начать. Вот три шага, которые вы можете предпринять сегодня:

1. Установите Mozaik и запустите пример из документации, чтобы увидеть, как работает AgenticEnvironment.
2. Спроектируйте простую мультиагентную систему для задачи, которая у вас есть. Подумайте, какие агенты могут работать параллельно и как они будут обмениваться событиями.
3. Зарегистрируйтесь на хакатон и начните формировать команду или план проекта. Даже если вы не уверены в победе, участие даст ценный опыт.

Конкурентная архитектура мультиагентных систем — это не просто тренд, а необходимость для масштабируемых AI-приложений. Mozaik предлагает элегантный способ её реализации. Попробуйте сами и присоединяйтесь к хакатону, чтобы отточить навыки и, возможно, выиграть приз.