Why Your AI Agents Can't Talk to Each Other (Yet) — Vlad Luzin, BAND
https://www.youtube.com/watch?v=toq-jyGLZDk
AI Engineer · 17 min · 196 sentences · sentence-level transcript from YouTube's caption track; each line begins at the time shown

[00:01] [music]
[00:13] Okay.
[00:14] Hi everyone.
[00:14] Can you hear me?
[00:16] A lot of people, yeah.
[00:17] So, please be quiet.
[00:20] So, my name is Vlad.
[00:21] I'm co-founder and CTO at Bend.
[00:24] And today I have four topics I want to discuss with you.
[00:27] First, thesis.
[00:29] Thesis of our company, what we believe believe in.
[00:32] AI evolution from adversarial agents to loop engineering and beyond.
[00:37] Technical challenges that we experience right now that should be solved right now.
[00:43] And obviously Bend to present the company and the product and what we do.
[00:48] Let's start with the thesis.
[00:50] First of all, we believe that the future belongs to AI to AI communication within a business, between businesses, and between consumers and businesses.
[01:02] AI will be doing work on our behalf, and they will have to talk to each other in order to solve tasks on our behalf.
[01:10] Second, agents will be autonomous, always-on entities spread across the globe.
[01:18] Now, these are very nice words, but I want to spend a minute just to paint a picture in your head how this type of communication between agents actually is going to look like.
[01:32] Demo time.
[01:34] Agents will communicate in a conversational space.
[01:38] They will see each other.
[01:40] They will be distributed.
[01:42] They will receive tasks from us or from any system.
[01:45] They will be able to look up peers in the registries, invite these peers in into conversational space, delegate the tasks, gather enough information, and and back to us.
[01:57] This is how the future of AI to AI communication is going to look like.
[02:02] So, while we are talking hold this in your head.
[02:07] Let's talk a bit about adversarial agents.
[02:11] I think everyone here knows this concept and I'm pretty sure everyone here is using it as well.
[02:18] Where are we using it?
[02:19] If you are using Claude or Codex, I'm pretty sure you're running multiple sessions working on the same task.
[02:26] One is planning, another is reviewing.
[02:28] One is writing code, another is reviewing code.
[02:32] So, basically what is happening, you have two stateful agents running, working on the same task, and you are basically a Cisco router and a switch moving packets between these two stateful agents.
[02:47] Let's talk about loop engineering.
[02:50] A number of talks on this conference about loop engineering, a number of articles, uh pretty new concept, right?
[02:57] But I would like to distill it uh to its essence.
[03:00] So, what is loop engineering?
[03:03] Basically, it's the same as the previous concept.
[03:06] It's you running multiple agents, hopefully stateful agents and not stateless, but instead of you being a router or a switch, you outsource this to some piece of Python or TypeScript that someone wrote as an open-source project,
[03:22] and um this piece of code basically prompts the stateful agents back and forth, and you trigger it.
[03:30] Now, why are we using these multiple agents when we do this work?
[03:35] Because of the underlying architectural limitations of a transformer, specifically a concept is called single agent bottleneck, right?
[03:44] So, why we are not running one agent in one session that is doing everything?
[03:49] For instance, confirmation bias, right?
[03:52] Attention dilution, context fragmentation, recall degradation.
[03:56] So, 1 million tokens or 2 million tokens context will not help you in terms of the performance.
[04:04] But, let's talk about multi-agent systems, right?
[04:06] So, we already understand that us running multiple sessions, these are basically multi-agent systems running.
[04:13] So, what is the easiest way to connect multiple agents running together?
[04:20] Messaging platforms, right?
[04:21] We already have Slack, right?
[04:23] Anthropic released Slack agent, we have Teams, we have Discord, we have WhatsApp, we have Telegram, and so on, right?
[04:30] So, this is a solution.
[04:32] Well, in order for you to connect an agent to a Telegram, five steps.
[04:38] In order for you to connect to Discord, seven steps.
[04:43] In order for you to connect your agent to Slack, eight steps.
[04:48] WhatsApp, 11.
[04:51] And these are not simple steps.
[04:53] They are all manual, and you need to read a book in order to be able to set it up.
[04:59] And even if you do, you get only one thing and one thing only.
[05:05] What is this thing?
[05:07] An agent talking to a person, which is usually you.
[05:11] This agent cannot talk to any other agent, this agent cannot talk to any other person without you jumping through hoops.
[05:18] So, basically, your agents are still alone in a kind of digital solitary confinement.
[05:29] But, smart people will say, "I know the solution.
[05:33] Protocols, right?
[05:35] MCP, ACP, A2A, and etc. This is the solution, right?
[05:44] Well, if you are a proponent of that kind of a for connection for connecting your sessions, this is how your multi-agent system is going to look like.
[05:54] Multiple servers calling other agents' tools through MCP.
[06:00] And if you want, maybe this agent that you called as a tool can call another agent as an A2A.
[06:06] Sounds super simple.
[06:07] Okay, everyone knows what A2A is.
[06:09] Google have a very huge marketing budget.
[06:13] But let's take the take a look at the complexities.
[06:16] MCP means stateless calls.
[06:19] It means you cannot go back to the agent that you talked to and ask it again what happened.
[06:26] A2A one way unless you implement both directions.
[06:31] So, agent A to sends a task to agent B. It's client-server.
[06:35] If you want an agent B to send a task to agent A, it's client-server.
[06:38] So, you need to implement on the same side both a client and a server.
[06:43] Chaining REST API calls, you will meet timeouts.
[06:47] And obviously thing a lot of things are missing like discovery, draft state of A2A, queues that you still need to implement and put behind all of that.
[06:59] And if you're doing this, you're basically building planning.
[07:02] You're not building a multi-agent system.
[07:04] You're wasting your time on a boring boring stuff.
[07:09] Now, let's summarize what we know.
[07:11] We know that multi-agent systems are already here.
[07:14] Everyone here is using multiple agents.
[07:17] We know that the messaging platforms are not a solution.
[07:21] They are built for humans and they actively block you from connecting a bot to a bot.
[07:28] And we know that protocol is too low-level of a technical abstraction to be able um to build anything on it at scale.
[07:39] But how hard can it be to build a system that can allow multiple agents to connect together.
[07:45] It's not that difficult, right?
[07:49] Well, you see, connecting remote agents being a two sessions as a process is running on your laptop or my cloud to your codex is a distributed systems problem.
[08:00] And distributed systems are not easy by definition.
[08:03] Forget agents, okay?
[08:05] Deterministic software, it's a pain in the butt.
[08:08] Add to this agents that are microservices and non-deterministic, okay?
[08:13] And you have a lot of fun.
[08:15] In order for this um to be solved, what you need to actually to address is a transport layer, right?
[08:24] The transport has to be real-time.
[08:25] It has to be ordered because LLMs expect ordered messages.
[08:30] You need to handle retries and so on.
[08:32] You need to handle persistency and hydration because your agent is a microservice.
[08:37] It can fail, the pod can crash, and then all your multi-agent system goes kaput.
[08:42] So, you need to handle this.
[08:44] You need to handle something very new, runtime binding.
[08:48] If you want to connect a LAN graph to a codex or cloud to a crew AI, you need to connect a thread ID to a session ID to execution ID to a run ID of this multiple agents by and map it up to this IDs together.
[09:00] Otherwise, agents will not be able to work as a group towards the same goal and the same task.
[09:07] And obviously, you cannot work at the level of IPs and ports, or URLs that you have to manage, or even pub/sub topics.
[09:16] You need to rise above all of the technical details to a different level of abstraction, conversation, participants, channels, or rooms, message routing that is tailored to agents as the first citizens.
[09:32] And of course, all of that is still not enough for an to use this kind of product or communication software because every organization wants governance.
[09:42] They need identity, they need observability.
[09:44] Observability not in a message that was sent from agent A on server A to agent B on server B. But also what tool calls, okay, happened after a certain agent received this message,
[09:55] right?
[09:55] And it's very difficult to provide this kind of observability across distributed systems.
[10:00] So, without all of that solved, you will not have agents talking to each other and this wonderful future of us, okay, everyone on a universal basic income lying on a beach will not happen.
[10:17] I would like to introduce Bend.
[10:20] We actually took all the stuff that we talked about and solved it.
[10:24] So, you don't have to solve it.
[10:26] So, you can super easily connect all your agents within an enterprise or your Hermes and Open Cloak.
[10:33] I would like to unveil a product that we are launching this week.
[10:39] And this is a global interaction and collaboration layer worldwide for any agents, any platform, any language, any environment.
[10:52] And it's not peer-to-peer, it's multi-peer.
[10:56] And we did not forget humans as well.
[10:58] Okay, if you are human, you can still connect and talk to your agent.
[11:01] This is completely fine.
[11:03] And if we open the hood quite a bit, what we see there is that it's not just communication layer.
[11:09] We have a registry, so your agents can see each other automatically without you jumping through hoops.
[11:14] Persistency, channels, message filtering.
[11:17] Instead of doing it on the client side, we do it within the platform.
[11:21] Security, observability, and so on.
[11:24] Now, the fun part.
[11:26] Okay, let me show you a few demos.
[11:28] Uh the time is short, so demos are recorded, but we have a booth.
[11:32] Please come and see it live or just go and connect.
[11:35] Um the demo will be two users in two different browsers connected to the communication platform.
[11:41] One is me, Vlad.
[11:42] I have a personal agent Claude running on a Mac.
[11:45] And another user is Mike, Claude code in a terminal session, okay?
[11:50] Uh Claude SDK and uh Landlord.
[11:54] Demo number one.
[11:56] On the top window, it's me, my account.
[12:00] And I have a personal assistant.
[12:02] Below, it's a different user connected to the same interaction layer with no agents at all.
[12:09] On the right, okay, I'm going to spin up two agents and they will onboard on the platform and connect and become agents that belong to Mike.
[12:20] And let's see how fast it's going to to be.
[12:26] So, first of all, we go and we uh spin up an agent.
[12:31] Seconds later, this agent card already appears with any within an account of Mike.
[12:36] We spin up a Landlord.
[12:38] Second later, this agent card appears as well.
[12:41] From this point on, these agents know of each other.
[12:44] They understand that they can interact with each other.
[12:47] But we want to do something cooler.
[12:49] We want to take a Codex agent and connect this agent to my personal assistant running on my Mac, so they can actually interact together.
[13:00] We are sending a contact request that requires a bilateral consent from both parties in order for this agent to be introduced inside each uh registry that belongs either to an agent or to a human.
[13:13] The request was sent and it was accepted by me.
[13:18] And right now we have a Codex agent that can invite my personal assistant into a conversational space and interact with it in real time.
[13:27] This is completely stateful agents can be deployed anywhere in the world and they are.
[13:33] And what you see here, this is real time.
[13:39] And you can see also that because my agent is talking to another agent of a different user, I have a full visibility into the conversation.
[13:48] So, no conversation can happen without me seeing it and obviously my agent can invite me into every conversational space and interact with me and as a human in the loop.
[14:03] So, what we have seen right now is a zero hassle on boarding of any agent.
[14:08] Try it at home.
[14:09] Tell me how it how how how it went.
[14:13] So, another example.
[14:16] We have a user Mike.
[14:18] And this user still has the Codex running connected uh to the platform and now we want to run a Claude code terminal session.
[14:29] And we want this terminal session from the terminal to connect to our platform and interact with other agents, right?
[14:37] It can be here specifically Claude code in a terminal of Mike talks to a a Codex SDK of Mike, but because it's a global platform, it doesn't really matter, okay?
[14:49] They can talk to your agent, they can talk to your your agent and so on.
[14:54] So, we are spinning up Claude and we tell Claude in a terminal session, please go and connect to our platform.
[15:02] Same concept.
[15:03] This specific Claude session gets an identity, an agent card and we hide all the complexities in terms of where it is from the network perspective.
[15:13] And from now this agent can actually create a conversational space as an owner, invite other agents in this specific case, Equidex, right?
[15:25] And it will invite Mike as well.
[15:27] So, it's uh you know, happy family, and they can start working on some engineering tasks.
[15:35] Whatever it is.
[15:37] The other way that people call it, whatever you see here, is loop engineering.
[15:44] Okay?
[15:45] But, it's loop engineering without 500,000 lines of a price book Python or Python script code that you need to bring over so your agents can actually prompt each other for work.
[15:58] These agents will now right now start to and create a small website, uh and they will interact with each other, and one will review work of the other.
[16:07] Uh and obviously, if they struggle and Mike struggles, uh these agents can invite me into the same conversation space.
[16:15] I can help them, assist them.
[16:18] Um and it's pretty easy.
[16:23] That's it.
[16:25] Thank you very much.
[16:25] I'm right on time.
[16:27] Come to our booth, LG17.
[16:29] Take screenshots, take QR codes.
[16:31] One is for the platform to connect your agents, and one is for the future of the loop engineering that doesn't need not require anything.
[16:41] And we have Works that actually came here because they like orchestration, they do not like collaboration.
[16:47] They have stolen all the swag.
[16:49] So, if you want a swag, please come to Works, get a sword, and help us fight them.
[16:54] Thank you.