Четыре открытых компонента — Agent2Agent, Model Context Protocol, Apache Kafka и Apache Flink — обеспечивают инфраструктуру для совместной работы автономных агентов искусственного интеллекта, пишет на портале The New Syack Шон Фалконер, предприниматель-резидент (EIR) в области ИИ в компании Confluent.
До того как в Интернете появился протокол передачи гипертекста (HTTP), а в электронной почте — простой протокол передачи почты (SMTP), мы были вынуждены работать с пользовательскими интеграциями, разрозненными системами и хрупкими рабочими процессами. Только после появления открытых протоколов и общей инфраструктуры Интернет стал по-настоящему масштабным, что позволило создать современную Сеть, глобальную связь и целые экономики.
Сегодня агенты ИИ находятся на той же стадии предварительной стандартизации. Они мощные, способные и быстро размножаются, но не работают вместе. Один агент анализирует данные. Другой составляет код. Третий автоматизирует рабочие процессы управления взаимоотношениями с клиентами (CRM). Но они изолированы друг от друга и не знают о существовании друг друга.
Но ситуация начинает меняться. Этому способствует новый стек для поддержки следующего уровня Интернета, созданный не для людей, просматривающих веб-сайты, а для автономных агентов, взаимодействующих между системами. В его основе лежат четыре открытых компонента:
- Agent2Agent (A2A) от Google: протокол для обнаружения и взаимодействия агентов.
- Model Context Protocol (MCP) от Anthropic: стандарт для использования инструментов и внешнего контекста.
- Apache Kafka: событийно-управляемая коммуникационная структура для надежной отделенной координации.
- Apache Flink: механизм обработки в реальном времени для обогащения, мониторинга и действий с потоками активности агентов.
Давайте рассмотрим, как эти технологии сочетаются друг с другом, почему одних протоколов недостаточно и как этот новый стек обеспечивает инфраструктуру, необходимую для перехода от разобщенных ботов к динамичным, интеллектуальным экосистемам агентов.
Проблема: разрозненные агенты, хрупкая инфраструктура
Если шумиха верна — а она больше похожа на неизбежность, чем на домыслы, — большинство компаний развернут не одного агента ИИ, а десятки. Эти агенты будут писать код, обрабатывать заявки на поддержку, анализировать данные о клиентах, управлять процессом регистрации, следить за инфраструктурой и многое другое.
Но сегодняшние инструменты не готовы к такому будущему.
Мы сталкиваемся не только с проблемой «островов агентов», когда агенты работают изолированно и не могут взаимодействовать друг с другом; мы сталкиваемся с более широкой проблемой фрагментации экосистемы:
- Агенты не разговаривают друг с другом. Каждый агент работает в своей собственной «песочнице». Агент CRM не знает, что только что обнаружил агент хранилища данных. Агент службы поддержки не может ответить на ту же аномалию, которую только что отметил агент мониторинга.
- Использование инструментов является хрупким и индивидуальным. Без стандарта для вызова инструментов или внешних API агенты в итоге получают жестко закодированные интеграции и невоспроизводимую логику.
- Фреймворкам не хватает согласованности. Различные среды выполнения агентов используют разные модели — одни рассматривают агентов как чат-ботов, другие — как направленные ациклические графы (DAG), третьи — как рекурсивные планировщики. Нет переносимого слоя исполнения или общего состояния.
- Мы строим так, как будто агенты живут в блокнотах. Большинство агентов сегодня разрабатываются как одноразовые прототипы — линейные, синхронные и эфемерные. Но реальные системы — это не блокноты. Они должны обрабатывать повторные попытки, отказы, координацию, протоколирование и масштабирование. Для этого необходима инфраструктура.
- Нет магистрали для совместной работы. Нет ни шины событий, ни общей памяти, ни отслеживаемой истории того, что и почему делали агенты. Все заперто в прямых HTTP-вызовах или похоронено в журналах.
Как утверждает проект
Результат? Изолированность. Дублирование. Хрупкость.
Решение заключается не в том, чтобы запихнуть всех агентов в одну монолитную платформу. Нужно создать общий стек, новый фундамент, основанный на открытых протоколах, архитектуре, управляемой событиями, и обработке данных в реальном времени.
Agent2Agent частично решает эту проблему, предоставляя агентам общий протокол для обнаружения и взаимодействия. Но чтобы выйти за рамки игрушечных демо-версий и достичь масштаба и надежности, необходимых производственным системам, нам нужно нечто большее, чем протоколы. Нам нужна инфраструктура.
Как агенты общаются и действуют: A2A и MCP
Как уже говорилось, экосистема агентов сегодня очень похожа на ранний веб: мощные системы, каждая из которых выполняет полезную работу, но разрозненные и несовместимые. Как браузеры когда-то пытались общаться с серверами без стандартного протокола, так и агенты ИИ сегодня не могут легко обнаруживать, общаться или сотрудничать друг с другом.
Протокол A2A от Google — это смелая попытка исправить ситуацию. Это не очередной фреймворк для агентов — это универсальный протокол, предназначенный для подключения любого агента, независимо от того, кто его создал и где он работает.
Подобно тому, как HTTP стандартизировал способы взаимодействия между веб-сайтами, A2A определяет общий язык для агентов. Он позволяет им:
- Объявлять о своих возможностях с помощью AgentCard — JSON-дескриптора, который декларирует, что может делать агент и как с ним взаимодействовать.
- Отправлять и получать задания посредством структурированных взаимодействий (с использованием JSON-RPC), когда один агент запрашивает помощь, а другой отвечает результатами, или «артефактами».
- Потоковая передача обновлений с помощью событий, отправляемых сервером (SSE), что позволяет получать обратную связь в реальном времени при выполнении длительных или совместных задач.
- Обмен богатым контентом. Файлы, структурированные данные и формы, а не только обычный текст — все это является первоклассной частью A2A-сообщений.
- Безопасность по умолчанию благодаря встроенной поддержке HTTPS, аутентификации и разрешений.
Что делает A2A перспективным, так это то, что он не пытается изобрести колесо заново. Он опирается на десятилетия истории интернет-протокола, как это сделали HTTP и SMTP, используя знакомые, проверенные в боях веб-стандарты. Это облегчает внедрение и ускоряет интеграцию.
Но A2A — это только одна половина картины.
MCP от Anthropic решает вторую половину проблемы: как агенты используют инструменты и получают доступ к контексту. MCP стандартизирует то, как агенты обращаются к API, вызывают функции и интегрируются с внешними системами — по сути, как они думают и действуют. A2A, с другой стороны, определяет, как агенты общаются друг с другом.
Если MCP — это предоставление агентам доступа к инструментам, то A2A — это предоставление им доступа друг к другу.
Вместе эти два протокола предлагают план создания экосистемы взаимосвязанных агентов:
- MCP обеспечивает индивидуальный интеллект агентов.
- A2A обеспечивает коллективный интеллект.
И точно так же, как HTTP и SMTP не были успешны в изоляции — они требовали внедрения, инфраструктуры и инструментов для разработчиков, A2A и MCP будут нуждаться в экосистеме для реализации своего потенциала.
Но даже при такой стандартизации, как A2A и MCP, остается фундаментальный вопрос: как эффективно масштабировать эти агентные коммуникации в сложной, динамичной корпоративной среде? Опора исключительно на прямые соединения «точка-точка», определяемые этими протоколами, создает свой собственный набор проблем, особенно связанных с масштабируемостью, устойчивостью и наблюдаемостью. Это приводит нас к необходимости создания надежной базовой коммуникационной инфраструктуры.
Нам нужна основа, управляемая событиями, а не просто протоколы
Представьте себе компанию, в которой каждый сотрудник может общаться только с помощью прямых сообщений, отправляемых от одного к другому. Нужно поделиться новостями? Придется писать каждому человеку отдельно. Хотите скоординировать проект между пятью командами? Вам придется вручную передавать информацию между всеми группами.
А теперь представьте, что вы пытаетесь распространить это на сотни сотрудников. Хаос.
Именно это происходит в агентных экосистемах, построенных на прямых связях. Каждый агент должен знать, с кем разговаривать, как с ним связаться и когда он будет доступен. По мере роста числа агентов количество необходимых связей растет в геометрической прогрессии. Система становится хрупкой, трудноуправляемой и практически не масштабируемой.
A2A и MCP предоставляют агентам язык и структуру для общения и действий, но одного языка недостаточно. Чтобы координировать работу десятков или сотен агентов в масштабах предприятия, вам также необходима инфраструктура для передачи сообщений и реакции агентов на них.
Именно здесь на помощь приходят Apache Kafka и Apache Flink.
Kafka и Flink: краткий обзор
Apache Kafka — это платформа для распределенной потоковой передачи событий, изначально разработанная в LinkedIn, а теперь являющаяся частью Apache Software Foundation. Она действует как долговечная и высокопроизводительная шина сообщений, позволяя системам публиковать и подписываться на потоки событий в режиме реального времени. Kafka используется повсеместно, от финансовых систем до систем обнаружения мошенничества и телеметрических конвейеров, поскольку она отделяет производителей от потребителей и обеспечивает долговечность, воспроизводимость и масштабируемость данных.
Flink, также являющийся проектом Apache, представляет собой движок для обработки потоков в реальном времени. Он был разработан с нуля для обработки событий с учетом состояния, с высокой пропускной способностью и низкой задержкой. Если Kafka занимается перемещением данных, то Flink — преобразованием, обогащением, мониторингом и оркестровкой этих данных по мере их прохождения через систему.
Вместе они образуют мощный дуэт: Kafka — это кровеносная система, Flink — рефлекторная система.
Kafka и Flink: инфраструктура для агентных экосистем
В то время как A2A становится HTTP в мире агентов, Kafka и Flink формируют событийно-ориентированную основу для поддержки масштабируемых агентных коммуникаций и вычислений. Они решают проблемы, которые не могут решить прямые коммуникации «точка-точка»:
- Отделение. С помощью Kafka агентам не нужно знать, кто будет потреблять их выходные данные. Они публикуют события (например, «TaskCompleted», «InsightGenerated») в теме; любой заинтересованный агент или система может подписаться на них.
- Наблюдаемость и воспроизводимость. Kafka ведет долговременный, упорядоченный по времени журнал каждого события, что делает поведение агентов полностью отслеживаемым, проверяемым и воспроизводимым.
- Принятие решений в реальном времени. Flink позволяет агентам реагировать на потоки событий в реальном времени, фильтруя, обогащая, объединяя или инициируя действия на основе динамических условий.
- Устойчивость и масштабирование. Задания Flink могут масштабироваться независимо, восстанавливаться после сбоев и поддерживать состояние в длительных рабочих процессах. Это важно для агентов, выполняющих сложные многоэтапные задачи.
- Координация на основе потоков. Вместо того чтобы ждать синхронного ответа, агенты могут координировать свои действия через потоки событий, публикуя обновления, подписываясь на рабочие процессы и совместно продвигая состояние.
Короче говоря:
- A2A определяет, как агенты разговаривают.
- MCP определяет, как они работают с внешними инструментами.
- Kafka определяет, как передаются их сообщения.
- Flink определяет, как эти потоки обрабатываются, преобразуются и превращаются в решения.
Как A2A, MCP, Kafka и Flink работают вместе
Такие протоколы, как A2A и MCP, необходимы для стандартизации поведения и взаимодействия агентов. Но без событийно-ориентированной подложки, такой как Kafka, и потоковой среды исполнения, такой как Flink, эти агенты застревают в изолированном взаимодействии, не в состоянии гибко координировать свои действия, плавно масштабироваться или рассуждать с течением времени.
Чтобы полностью реализовать концепцию интероперабельных ИИ-агентов корпоративного класса, нам нужны четыре уровня:
- Протоколы: A2A, MCP — для определения «что».
- Фреймворки: LangGraph, CrewAI, ADK — для определения «как».
- Инфраструктура обмена сообщениями: Apache Kafka — для поддержки потока.
- Вычисления в реальном времени: Apache Flink — для поддержки мышления.
Все вместе это новый интернет-стек для агентов ИИ — основа для создания систем, которые не только интеллектуальны, но и совместны, наблюдаемы и готовы к производству.
Путь вперед: создание коллективного интеллекта
Мы переживаем переломный момент в эволюции ПО.
Подобно тому, как первоначальный стек Интернета — протоколы HTTP и SMTP, а также инфраструктура TCP/IP — открыл новую эру глобальной связи, появляется новый стек для агентов ИИ. Но вместо людей, перемещающихся по страницам или отправляющих электронные письма, этот стек создан для автономных систем, работающих вместе, чтобы рассуждать, принимать решения и действовать.
A2A и MCP обеспечивают протоколы для взаимодействия агентов и использования инструментов. Kafka и Flink обеспечивают инфраструктуру для координации в реальном времени, наблюдаемости и устойчивости. Вместе они позволяют перейти от демонстрационных образцов агентов к масштабируемым, интеллектуальным экосистемам производственного уровня.
Речь идет не только о решении инженерных задач. Речь идет о создании нового типа ПО, в котором агенты сотрудничают между собой, предоставляя информацию и действия в режиме реального времени, что позволяет интеллекту стать распределенной системой.
Но это видение не реализуется само по себе. Мы должны создать его: открыто, сообща и с учетом уроков последней интернет-революции.
Поэтому в следующий раз, когда вы будете создавать агента, не думайте только о том, что он может делать. Подумайте, как он вписывается в общую систему. Может ли он общаться? Может ли он координировать свои действия? Может ли он развиваться?
Потому что будущее не просто за агентами, оно за агентными экосистемами.
