In this episode of Data Driven, we're diving into the rapidly evolving world of agentic AI—where autonomous AI agents collaborate, communicate, and occasionally collide. Our guest, Vlad Luzin, co-founder and CTO of Band, joins us to explore the technical challenges and real-world implications of building collaboration layers for agents that act like distributed, non-deterministic microservices.

We’ll unpack the myths and realities surrounding orchestration, governance, and security, and discuss how enterprises can operationalize these agent ecosystems safely. Tune in as we share lessons learned, amusing engineering mishaps, and get a glimpse of what the future holds as agents become everyday colleagues in the digital enterprise.

Links

• Vlad's LinkedIn Profile -https://www.linkedin.com/in/luzin/
• Watch this episode on YouTube -https://youtu.be/MZztFagEX_E
• Band Website -https://www.band.ai/
• Band Docs -https://docs.band.ai/

Time Stamps

00:00 Explaining orchestration in tech

03:42 Understanding models and harnesses

09:38 Misconceptions about A2A communication

10:41 Understanding multi-agent systems

16:18 Observability for distributed systems

18:54 Agent communication and collaboration

24:28 Unauthorized agent interactions

25:49 Remote agent collaboration ideas

28:54 How foundational AI models communicate

33:20 Agent communication protocols overview

35:39 Discussing tech standards and AI velocity

40:53 Learning to Work with AI Agents

42:41 Using Band AI tools

Another way to look at this future where agents

in the world work on our behalf and interact with each other.

It's basically a distributed system of microservices where

each microservice is non deterministic. Everyone's talking

about AI agents these days. Far fewer people are

asking what happens when those agents need to work together? How do

they communicate, collaborate and avoid causing absolute

chaos? That's exactly what we're discussing today with Vlad

Luzin, co founder and CTO of band.

Hello and welcome back to Data Driven, the podcast. We explore the

emergent field of artificial intelligence, data science, and

even agentic AI, which we'll talk about today for sure.

And without it all, without data engineering as the underlying

foundation, it's all for nothing. So accordingly, I have my favorite data

engineer in the world with me. How's it going, Andy? It's going well, Frank.

How are you? I'm doing well, I'm doing well, I'm keeping busy and I.

I'm excited to talk about agentic AI. Agentic AI is one of those things that

comes up quite a bit. And we have a

co founder and CTO of a presumably an

agentic AI startup. Because if you look at the. His LinkedIn profile says band of

Agents. It's Vlad Lozin hard. Hopefully I pronounced that right.

And he is a co founder and CTO of band.

So welcome to the show, Vlad. Hi

all. Thank you, thank you for having me. No problem, no problem.

So tell us about band.

Yeah, band. We create an

interaction collaboration layer for agents.

We basically decided to look ahead and see where the whole industry is

going and where the whole world will be in a few years from

now. And everyone is talking about agents doing

work on our behalf. And we are sitting by the beach

enjoying the view and we looked what will be the

problem that we can solve that will be still relevant?

And we figured out that these agents probably will not be doing the work

alone. They will need to collaborate between themselves

mostly and sometimes with us or humans. So

we've decided basically to enable that kind of interaction

collaboration for agents and bring this future closer to today.

Interesting. So is it fair to say that this is a

orchestration layer or a harness for

the agents? How would you describe it? Yeah,

excellent question. So maybe we need to unpack a bit what

orchestration is. Right, because it's like a bombastic word and everyone

puts different meaning into it.

So usually what people mean by orchestration is

either a graph based execution, which is a genetic

application where each node is an agent and then it's

Basically hard coded pass between nodes or

an agent that controls other agents and

says, frank, now you can speak and now

you are allowed to talk. And quite often it also takes the messages and

pushes messages back and forth for you. So

this is orchestration. We look at the future and we believe

that agents actually you can see it already today, right?

Agents are stateful, standalone,

always on. And they're developed in different

languages, using different frameworks, using different models

and so on. And they will be autonomous in how they interact and they

decide when they speak and to whom they speak and so on.

So it's a bit different than orchestration, but it is a harness. And you are

right, because agents means there

are two pieces to an agent. One is a model,

another is a harness. So if you look at ChatGPT, ChatGPT is a

model and a harness, which is a web application so you can interact with

it as a chatbot. If you look at cloud code, Cloud code

is 1.8% model and the

rest is harness. Cloud code was leaked and people

looked into it and published articles and so on. If you look at

OpenCloud and the like, I'm sure you know your

listeners know about that. It's a huge piece of

that is hardness as well. And because model is not enough.

So in our part you can think of

us as a harness for agents to allow them

to collaborate, see who their peers are,

provide them an ability to create chat rooms and interact with

people, et cetera. But harness obviously is not enough because harness

does not give you an ability to send messages

and discover other peers, et cetera. We also have planet

scale communication layer through which our

agents can discuss. So I can connect my codecs to your

cloth running on your laptop, for instance.

Interesting. It almost sounds like

orchestration isn't really a great word, but it almost sounds like you need a

harness plus a smart queuing system like

message queuing. Is that

what this is? Yeah,

another great question. So another way to look

at this future where agents in the

world work on our behalf and interact with each other.

It's basically a distributed system of microservices where

each microservice is non deterministic. It means in

order for someone to build the system, the problems you need to

solve are distributed system problems. And one of these problems

you need to solve obviously is queuing. Because

it's a sync microservices, messages gets delivered, you need to

queue them. You need to persist the messages in a queue

because agent can crash. It's still the software runs in

a pod somewhere you need to route messages in a

deterministic way. You need to enable dynamic

discovery of these services. You need to tackle security,

identity, back pressure, flow control. All of these

niceties that to be completely frank, have nothing to do with

AI or LLMs, but it's part of this,

we can call it a harness that is required in order for agents to be

able to cooperate. That's probably the single best

explanation I've heard of agents microservices that are

non deterministic. That is the single best

definition I've heard so far. Because I mean that's at the end of the day

that's really what they are. They're not these magical little

robots running around your system. Although maybe, but

like, but I mean in terms of like. Because it's very important I think for

particularly we go from reading the Hype machine and

all that. It is conference season, right? So you know, everybody has their own thing.

But at the end of the day, Enterprise, it is meant to be very boring,

right? Even if it's cutting edge, it has to be boring, it has to be

stable. And the people that write the

checks like uneventful. Yeah, they

like uneventful deployments. And a lot of them are very suspicious

of to them what sound like very foreign, very new wave

concepts. Right. But if you have

a way to kind of put it in terms that they can be familiar, which

is microservices that have non deterministic outputs, then that

doesn't make them sound so scary.

Yeah, 100%. And this is what we

feel when we talk to Prospect Design partners as well, that at

the moment you frame the solution in

the concepts that the other side can understand becomes

less scary, but also a bit easier of a

conversation because I'm yet to find an R and D

organization that enjoyed building a true microservices

distributed system. It's like Enterprise

can spend six months just defining the topic structure of a Kafka,

right? So. Well that's true.

And I also think too that

people fear what they don't understand. And I think there's so much

noise now in the AI space which

leads to my next question and then I'll stop hogging the mic and Anakin, ask

a question. But what do you think people misunderstand about AI,

particularly agentic AI right now?

Well, quite a lot.

Well, we can start with the finest one. For

instance, people believe that MCP is for agent to

agent communication, right?

They look at MCP, MCP's Model Context Protocol. It's in order

to move context between Models. Right. That's a reasonable

assumption. So where is it wrong? MCP is

a subset of Open API REST protocol and it

was created in order to connect agents in a unified way to the backend

systems. Okay, yeah, so the name

is a bit misleading. Okay. Because people assume it's too.

Yeah, it's between models. It's not. It's within an

agent LLM basically. And the backend system.

Another misconduct. Yeah, another

misconception is that

communication can be solved by A2A.

Google's A2A protocol, if you probably heard

now, A2A is a transport layer protocol

that for instance, does not yet have even the registry.

And the fact that for instance the three of us have laptops and

we have implemented TCP stack on all the laptops

still doesn't mean that I can send message from my laptop to your

laptop. We still need the DNS and the Cisco router and

connect my laptop to this router so the messages will flow.

Another misconception of the overall agentic

space is that people think that

it's possible to create an agent that can do everything like super

agent. And there is no need to have

multiple agents in an environment. Basically.

So for instance, people say, yeah, we have anthropic, we have claude.

So if we have Claude, why do we need multi agent systems?

And what people miss is that even if there is only one harness in

the world which is called code, and only one model

which is, let's say Opus 4.8,

you still will create multiple sessions.

Because what defines an agent is not the harness which is stateless,

it's an instance of this harness that performs a

certain task which is a session. In a terminal, when you open

CLAUDE or Codex, it is a session, so it is an agent.

And if you open another window with another session, it's another agent.

Even if there's only one harness and one model,

there will still be distributed stateful

agents, be it on your laptop or

within an enterprise, connecting Salesforce, the SAP

to the Langgraph and et cetera. It will not be

one super agent. And let me take it even further, right,

so assume we have Opus 15,

okay, super powerful model, it's still

generic model that was trained on a lot of

data. It has no idea about the organization

and what the organization is doing, what other entities, be it

humans or agents, are in the organization. So you still need to

onboard this model, you need to give it a proper system

prompt, explain what the purpose is of this instance,

of this agent to what it

can connect to what backend system it Connects because you as an

enterprise want to control the backend systems it connects to and so

on, so forth. So even if you have super great model, there will be

specialized agents with proper context, proper

connectivity to backend systems, and the future is

basically still distributed stateful agents,

even with one harness and one model.

Interesting. Yep, it's.

It sounds really cool. Really interesting what you put together there at

Band. I know one concern, especially

when we start talking and you mentioned Open Claw

and platforms like that that have a little more autonomy than

say the previous versions of agents, people are concerned about

guardrails. Can you speak to that with what you do there

at Band? Yeah, the guardless

are there basically to make sure that the agent behaves

and is more or less deterministic and will not

get off rails, so to speak. Just like anything

in life, there is no 100%

foolproof agent. Just like when you hire a human

being, the person still can make mistakes,

do not deliver on the work, perform very badly, and

maybe even do some bad stuff within the organization.

And agents, despite the fact that they are software and we all expect that they

will behave 100% deterministically and much better than

humans and so on, they still can make mistakes.

So there are a number of approaches here. Obviously the common

guardrails solutions for stateful agents

still apply and anyone can use them.

And you can use prompt injection

protection as well. But the safest

approach is actually to create a safe environment

for agents to interact. Where in

this environment you do not give access to any

adversarial actors and you control the ripple effect.

So even if one agent misbehaves, this

cannot ruin the whole system. Right. And you do it in a number of

ways. You need to control what systems this agent

has access to. You need to control with all what

humans or other agents this agent can communicate.

And organization needs primitives to allow that.

Because we are a communication collaboration layer. You can think of us as,

you know, networking layer. And we obviously can have a

firewalls and we can give an organization control on

which entity connects to each entity. We

make sure that every agent has an identity within

this collaborative environment. This identity is owned by

a human being. So we can always do an attribution.

Okay. To whom this agent belonged and why this agent

belongs, did what it did. So we have a kind of governance

around it. I'm sorry, I cut you off. I'm sorry.

Yes. So we have a governance layer on top of this

interaction capability. Because for

organizations, it's never enough to just enable a capability. They also

need a way to control and observe.

So within this governance layer, we also make sure to provide

observability capabilities. So in a usual

distributed environment, in a distributed system, it's enough

to, let's say, have logs and record

events and then you can debug the system.

But when agents are involved, what is interesting is

not what message me as an agent sent to

Andy. It's also very interesting to understand after Andy got

this message in what state Andy believes it is

and what tool calls he perform and what messages he sent.

Right. But these are distributed agents, like distributed processes,

and they call other systems.

So you need to find a way to intercept all these tool

calls and tool results from these remote services,

inject it into one place and provide this kind of observability in a

governance layer to an organization. So organization can put

a customer support person or an IT person

to monitor the whole communication, understand what happens so you can

debug your agents and humans working, so you can do

KPI measurement, prompt tuning, and so on and so

forth. So this kind of multifaceted

approach is what we believe is

needed for that kind of cooperation. Well, I really like that answer. And the

part that I keyed in on when you were describing that is you called

out, there's a human owner of each of these

processes. I loved Frank's follow up. He jumped right on that with

pointing out that's governance. And we all,

either we know governance is good or we're about to learn

that it's good because we're not doing it. And

that's an important point. I would like to. I'm a data

engineer, so Vlad, I apologize for that. I think about

operationalizing and frankly, you brought this up, you

inspired it by saying observability. Okay, so

if, let's say Frank's the owner of, of a

particular agent or some function of an agent, and

he's attending a conference, he's out of the loop.

He's the human who owns it, but he's no longer in the loop.

Does Band provide facility for say,

assigning someone to monitor or own,

assume ownership of that agent while Frank's not available?

Yeah. So what we have is

not just the chain of ownership in terms of like a human that owns an

agent, we also have registry.

So it means that the agents within the registry can see each other

and also inability to connect agents across the

registry. Right. So you can create basically this

hierarchical structure similar to how organizations

and orchards look like. Oh, that's perfect.

Yeah. And agents have an ability to

autonomously invite People or other agents,

when they. And they can see who is online and

who is offline. So it means that if a certain agent needs

to bring Frank into the loop, this agent doesn't go

and look through the whole org chart and so on, because when this

agent was on board that assigned an identity, he was assigned a team

where, you know, he acts and he was connected

to his peers, right? So if this agent has an

ability to reach out, let's say to you, Andy, as well,

this agent, when he wants to bring a certain person into the loop, will say,

okay, Frank is offline, probably will not help me, but Andy is online.

I probably should ping Andy and bring him in the loop and ask.

And if there is no one available, then the work will

stop. Okay? And agents will be able to basically wait for,

you know, human to be available. Vlad, that is very

elegant from an operations standpoint. And I,

I commend y' all for thinking that through. It's obvious that

you did. And I've encountered

customers, potential customers. I do consulting. And

whenever we start talking about this sort of stuff,

it's. In having those conversations,

you'll. You'll are able to tell somebody who's thought about this and

put it through the paces. It goes back to where you started

earlier, when you made the comparison between bringing an

agent online to bringing a new employee online.

And I think there's two thoughts about that. One is

a lot of people react negatively to that type of

characterization, and I can

sympathize because there's a lot of difference between an agent and

a human. And I don't think we should conflate the two.

But in the role in a job function,

that conflating is accurate, and we should

make that comparison and we should treat it that way.

And, you know, often, you know, often we'll see pushback

about. Somebody will read the story about

the production database being deleted, and inevitably

somebody like me, who's a governance nut will say

if I, I wonder if it would have been impossible for,

for an intern working over the summer to delete that production

database. That's my first thought, is if you don't

have governance in place, if you don't have the guardrails. That's why I asked the

question then you're wide open already.

Whether you've deployed an agent or not, you've left

yourself vulnerable, not just to outside

attack. We're not talking about surface vectors here for

script kitties to come in and hack you. We're talking about somebody

internal connecting to the wrong instance Accidentally

and, you know, dropping the production database.

You know, if you're already in that position, why would you make a big deal

about an agent being able to do that? If you haven't protected, number one, if

you haven't protected yourself from somebody making a mistake, an honest

mistake, engineer or intern, then

bringing an agent into that environment is a

recipe for, you know, some potential harm to come to your

organization. Yeah, for sure. And

I agree with you that making a comparison

between agents being onboarded and humans being onboarded is a bit

tricky. But I did find that this kind of

comparison makes it much easier to explain how people

should look at agents and the security aspect and also

understand that agents are not deterministic software. They can and they will

do mistakes, and we can the same

primitives that we use to secure humans to secure

agents. Now, not everything will work, obviously, but it's close enough.

Now, this being said, the whole agentic space is still very, very

early. And most of the

things that we have deployed right now overall in the world is

still siloed agents, steel agents that are mostly

chatbots. And not everyone

actually has a lot of experience in

remote agents working together

because this kind of

capability brings their own issues and security risks.

And I can give you, like, a very funny example of what

happened to me at Nvidia gtc. Yeah, I love

to hear it.

So we have this concept of registries, right? So my

agents can see each other and your agents, Frank, can see each

other. But we also enable one of my agents to talk to your agents,

and it's obvious why it's needed. So if I'm in department A,

I maintain context for my agents. But maybe you, Frank, want to use one of

my agents as well for your task. Because tasks usually

span departments, right? So

I was GTC and I was, you know, presenting our platform

to like six, seven people. And I onboarded them on the

platform and I told them, look, folks, I have a weather

agent. It allows you to ask it about the weather.

Any city in the world, please connect to it. They sent a connection request, and

it requires a lot of consent. It's a security issue. They need to approve, I

need to approve, and then they can talk to my agent.

So it was great. We, you know, finished onboarding, finished the talk,

and then, you know, everyone went home. I woke up

tomorrow, next day, in the morning, and I open the platform and I

see that all these people are talking to other agents of

mine that they have not been, with

bilateral consent, put in contact with. So what

happened? They were inviting My weather

agent and asking it tricky questions, not just questions

about the weather. So the weather agent went to the registry to look

up for entities who can help it answer the questions, and it

found my other agents that were not exposed to these users and

it invited them into the same chat to help

answering these questions. So

unless you actually have distributed agents with

distributed registries and this connectivity between the

registries, you do not even think about that way to

expose private agents, so to speak.

Right. It's almost like

discoverability becomes a. From go some feature to flawless.

Right. Well, very quickly, the point here is that

it got me thinking actually, in a

business use case, you may need this kind

of an ability for an agent within a registry who cannot

answer your question, being able to invite its peers within

its own domain. And there are use cases where you do not

want to do it. So it means that there has to be a security

configuration based on the business domain.

Right. So this shows you that this kind of, you know,

remote agent collaboration is basically we discover it as we go.

So I, I get now why. Because I'll say this, I

started where Frank started. In my mind. I thought, this is going to be

about orchestration. And when Frank brought that up, you said, no,

it's not just about orchestration. And what you just described

is absolutely not about orchestration. It's. It is,

it's beyond that in this sense. You just used the word

collaboration and what you described in an

agent being able to, as Frank pointed out, discover

there's an agent that has this expertise. Maybe it's not

in a public registry, maybe it's not

marked technically available, but there's enough information for

you to see it. And it reminds me a lot, Frank, of the

early, early days of. Net, when reflection became.

There was reflection. The thing that really got me was

way back when, when they had web services, it was the disco

files, if you remember those. Right? Yeah, very much

a reflection type thing too. I mean, the idea sounds

very similar to what you're describing, Vlad. And

I hadn't put that together until you just described an

agent being able to reach out and collaborate with an.

Identify an agent. First off, that I think is in and of itself is

a killer innovation. And then being able

to invite that agent to the conversation, unless

it's not supposed to be invited that conversation, that was another problem. Right?

Like that, that, because I think, like, because that was my.

As he was talking, I was thinking about one of my next kind of questions

that was queued up in my head, like, well, this is a Discovery story. And

then when he brought up that story, like not everything's meant to be discovered, Right?

Exactly, exactly.

And Disco files is really an old concept. I googled it

and there's an MSDN article

from February of 2002. So this is, it's a long dead

technology, but like the whole, the notion of having to

discover what's available is, is an age old problem.

So do you want to hear another funny story? Oh yes, absolutely. Yeah.

I don't want to bore your listeners with, you know, a lot of

excited love what you're

doing and what you're describing and I suspect our listeners do too.

Yeah, I hope so. I hope so. So you see

right now the foundational models, when they're trained, most of them

are trained to assume they talk to a user, to a human,

and they have to follow instructions. And

if you look at the protocols, OpenAI Anthropic, you can

see that whenever you send a message to a model,

it's basically JSON, right? And it has a place to

put a role. And a content and

role is usually user or assistant.

This is how you send messages and you receive messages and so on.

In OpenAI, they do have an ability to assign a name as well.

Actually the stream of messages can have different messages

attributed to different entities.

But anthropic, they do not have that capability. At

one point in time, one of our engineers was trying to

debug a very strange issue. Two agents in

a conversation space with the engineer. And the engineer

was asking one agent to ask a question

to send a question to the other agent. And agent A was

refusing to send a message to Agent B. He

tries to debug it and he says, okay, they see each other. If I ask

who else is in the room, okay, they see each other. They.

It works. If I ask agent A to send a message to

me, it works. If I ask Agent B to send a message to me, it

works. But A doesn't want to send a message to B.

And apparently the issue was the names of the

agents, right? Because every agent has a name, right?

Because it has an identity. So it has to have a name, has to have

a description, all the basic stuff. And Agent

B's name was EIA Assistant. And

agent A was refusing to send the message to Agent B because the

name is EA Assistant. And when foundational models are trained,

they are trained to assume that EI Assistant means me.

I'm the model. I cannot send the message to myself. Okay,

so now that we have multiple agents in the conversation, you're Right. Because the

endpoints assume a chatbot with a chat conversation. Because even the endpoint

now is if you're using the A, maybe there's a new open

AI standard. But it was something like chat completion is the

endpoint. Yeah. Right. And that you know that which as I'm

code, as I'm looking at that I'm like well we're going to regret that naming

pretty soon. Seems like something like that's already happened.

Interesting. I find it fascinating that the agent won't

talk to itself. I think

it probably assumes it's a like a hack. Like it's probably assumes it's being

prompt injected. That would okay that, that fence.

Yeah. So. And it's very difficult to discover. Right. Like and understand

like agents, they see each other and the standard, they hear, they reply to

messages etc. But A doesn't want to send the message to B.

Right. So. So it took us some time to, to figure it out. But yeah,

there's a lot of interesting, you know, stuff that is happening when you try to

connect non deterministic, you know, distributed microservices

together have brains. That is an

interesting problem. Goodness, that must have taken some time to run

down. I can only imagine. Yeah, we actually want

to create a cookbook on our website for all the people who

try and connect different agents together just so they don't stumble

and see the same problems that we did.

And it's, it's still a very new field. So I think a lot of people

haven't really figured out all the problem. We don't know what we don't know yet

when it comes to deploying these things at scale.

Yeah, yeah for sure. And we hope to hide all

the complexities from people so it becomes very easy, very

straightforward so you don't need to think about it. But

along the way we do need to solve a lot of finer problems.

Interesting. You mentioned standard. So there's a 2A,

there's MCP and I think there's at least two more. I think IBM

has one, Google has one. Anthropic had MCP.

Do you think that we're looking at another standards war or do you think

the big companies will or the community in whole will have a way

will not allow that to happen.

Yeah, overall I think there's like about 15 to

16 protocols for Agent to agent communication

and things like the like that. And around it

the most famous protocols are two that most

of the people have heard about it. McP is number one obviously

but it's between agents and systems and

A2A is by Google. But the most

widely used protocol in production is actually acp,

which is mostly protocol that is used for

connection between a front end like IDE

and an agent. This one is being used all over the

place. So in terms of other approaches, Cisco, they have

an agency consortium and they look not only at the protocol, they

also look into the underlying infrastructure and they approach

it more like from the networking perspective. I think

at some point in time, obviously all this stuff

will have standards, but even if it will have

standards, it will be different and depending on your

implementation quality, the product of yours will be better

or much better. And the example, this

example I can give is basically video

streaming packets over udp. Right.

We know how to do it for a long,

long time. This is nothing groundbreaking and it's

2026 and we have, you know, teams, we have

Zoom, we have Google Meet and so on and so forth. And

I'm pretty sure that all those products, they do not have

the same standard of the video quality, audio quality and so on, despite

the fact that they have been built on top of the

one protocol, one infrastructure. So it's not

just a protocol, it's a lot of knowledge

and IP that you need to put in. So the whole system

actually will work. So even

if there is one protocol, there is a lot of work to do. And right

now we are not yet in that place. Right. We are still in the discovery

phase where a bunch of protocols pop up and

have to be supported and reviewed and then they will die and so on.

Yeah, and we've seen this before. You mentioned a great example,

the different video and audio protocols for streaming conversations

just like this meeting that we're recording on teams.

I've seen it in my. The first thought I had was with the

SQL protocol, SQL standards that are out there, the different

Nancy numbered standards, and you nailed

it. The different companies implement the standards

differently and some perform better in this use case, some perform

better in that one. I imagine with the velocity

of agentic AI, how fast it's improving, it's moving faster

than anything I've seen in my career slash

hobby, which goes back 51 years now. I started as

a wee lad back in 1975

and this is moving faster than anything. I would imagine

that probably in, you know, in short order I'll. I

won't put a timestamp on it other than that will probably

find something developed with the help of agents that

will translate between the. You mentioned 15 or so

protocols that are out there. Yeah, yeah, you're

Right. And

let me surprise you a bit. Okay. It's already there. We

do it. Okay. So we support

A2A and ACP, right. So you can have an A2A

agent connecting to us and talking to agent via an acp.

And we also. I'm not surprised.

Yeah. Look, this is one of the first things that you need to solve, right?

If you want to be. To enable interaction, right. You need

to have a universal translator. Right. Otherwise people will

speak different languages and no one will understand each other.

So we act as a normalization layer. Another way

how to look at it is that if you have a Cisco router, it doesn't

really care if you're sending HTTP, TCP or video, audio

whatnot. It's agnostic. And the same is for us.

We want to be friends with every agentic development

framework. We have no preference. We want to enable

them to collaborate together. We want Langgraph

and Crewai to be friends. We want the Codex

and Claude to work together and not fight. So

yeah, no, I think

there's a lot to be said for kind of being the universal translator, bridging

between all these worlds. Because at the end of the day

protocol wars just delay everything. Right. And

as long as you can kind of like get the job done, I think that's

ultimately what matters more than what protocol was used.

And you're right, like the router doesn't really care. Is it udp, is it tcp?

Right. Just it's structured in such a way that it doesn't

really matter. Interesting.

Where do you think we're headed with this?

Where do you think we're headed with

this work in terms of agentic AI and

these non deterministic microservices being put

into the enterprise? What sort of unintended consequences? Because if you think

about the enterprise, it as an ecosystem, we are

introducing a new animal, right? We're introducing

a new species, right. It's not human. It's not. It. It's not

deterministic code. It's like this other thing that can kind of do.

It can kind of come up with its own ideas. And some of those ideas

are going to be great. Some of them are not going to be so great.

Like what, what do you think that is going to change?

Like where do you think that's going to go?

Yeah, I know one thing for sure, 100%

it's going to be exciting. Okay. At least I know

yes, this I know for sure. The rest I can only guess.

I think it's going to be a huge enable for A lot of people

for a lot of enterprises. It will allow

a lot of creativity work to be done. It for sure

will require some re education from

people, not because they will be fired and will be

on universal basic income. And EI will do all the work just because

it's a new entity and you need to learn how to work with it.

Think of it in the following way. Whenever you are young

and you come into a company, the first thing that you do in your first

job is they do a training. They explain to you how to

work as a team, how to collaborate with people, how to schedule

meetings, how to write emails the right way. They

explain to you that people working together as a force multiplier.

They tell you how to talk, how to control your emotions and

so on. So you are, you are basically being taught how to

perform your work within an enterprise and operate with other human

beings, even if there is a direct are conflicts. And it's

despite the fact that you are a human being and you work with other humans

and you've been around other humans for a long, long time. And here

we have another entity. Okay, it's not human,

but it's not a deterministic service. It has pluses, it has minuses,

it sort of communicates with you in a language. It has different

capabilities and you need to be trained how to use it, how to

use it properly, how to depend on it and when you can depend on it,

when not to depend on it. A lot of things that

you know, for instance, I've seen quite a lot that people

turn off their brains and they just outsource their own work

to agents. And this has huge impact not only on the

person itself, but also on the people, the peers

within the organization. So people will have to be trained and

they have to learn how to work alongside agents, how to

control agents, just like you learned how to manage a

team of people with different abilities, different

specializations. People will have to learn how to manage a team of

agents, or how to manage a team of agents and people,

or how to manage people who have agentic teams.

And it's going to be a learning experience for everyone, I believe. I don't think

anyone knows exactly how it's going to play out. No, that's a great

answer because I think anyone that already has got it all figured out is

delusional or lying. Right?

They're lying to themselves or they're lying to everyone else. And I think it's, it's.

You're right, it is an exciting time. It's only Going to get more exciting

and exciting has got good aspects and it certainly has bad aspects

too. So where can folks find out more

about band and how. Well, how about I set this up? What is

band's answer to this would

be a good place to start. And where can folks find out more about band?

So the best place to find more about band is on

Band AI. And then you can go to Docs

Docs Band AI. And please

use your Cloth or Courser or Codex

and point it to the documentation and use it as your best friend.

Because cloud and codecs, they can understand pretty well all

the concepts that we have and then they can help you

set up an agent and connect to

it. If you have personal assistant, Hermes,

openclaw, nanoclaw and such,

Bent is a super great place for your agents

to find friends. Okay. Like open Cloth your friend

so you can schedule meetings with it or if you want to use the

context of your friend who is a fan of, I don't know,

science fiction. Right. And maintains

a library of comics and PDF files or

whatever. Right. And share the information. Yeah. So

onboarding is pretty easy. And make sure to spread the

word because we are collaboration and interaction

framework. Right. You need two for Tango. So bring a friend.

All right. Well, that's cool. Any. Any other

questions, Andy?

Trying to find the mute button. No. I'm already messaging people on

my team saying, go check this out.

Drama. And Mouse wasn't over the screen. I went to Docs Band.

I love that line, Vlad, that it's an excellent place

for your agents to find friends. That's a good

tagline right there. And we're gonna be checking it out.

Yeah, definitely check it out. I have my own instance of openclaw and I'll be

setting up a Hermes, I think is how you say it. It's

Hermes if it's the designer bag and Hermes if it's the.

I think. But definitely be. Definitely checking it out. I'm

in the. I'm starting. I'm in the early phase of an agentic project for

work, so that'll be interesting to kind of check this out. And

thanks. We could talk for another hour, but we want to be respectful of your

time. And thanks for coming on, Vlad. And

we'll let the outro music play. Thank you.