1
00:00:00,120 --> 00:00:03,680
Here is the question that 
exposes the biggest gap between 

2
00:00:03,680 --> 00:00:07,000
what the AI industry is selling 
and what it can actually 

3
00:00:07,000 --> 00:00:09,760
deliver. 
You have an AI agent that 

4
00:00:09,760 --> 00:00:11,840
handles your customer support 
tickets. 

5
00:00:12,080 --> 00:00:15,440
You have another one that 
manages your inventory, and you 

6
00:00:15,440 --> 00:00:18,680
have a third one that does 
financial forecasting. 

7
00:00:19,040 --> 00:00:21,320
All three are supposedly 
intelligent. 

8
00:00:21,680 --> 00:00:24,600
All three can reason, plan, and 
take actions. 

9
00:00:24,920 --> 00:00:28,440
But can they talk to each other?
Can the support agent tell the 

10
00:00:28,440 --> 00:00:31,680
inventory agent that a product 
is getting a surge of 

11
00:00:31,680 --> 00:00:35,640
complaints, so maybe do not 
reorder 10,000 more units? 

12
00:00:36,360 --> 00:00:39,680
Can the forecasting agent ask 
the support agent how many 

13
00:00:39,680 --> 00:00:41,760
refund requests came in last 
quarter? 

14
00:00:42,600 --> 00:00:46,280
The answer for the vast majority
of production deployments in 

15
00:00:46,280 --> 00:00:51,400
2026 is no, they cannot. 
And the reason is not that the 

16
00:00:51,400 --> 00:00:55,240
models are not smart enough, it 
is that we never built the phone

17
00:00:55,240 --> 00:00:58,920
lines. 
IMO, and this is the practical 

18
00:00:59,000 --> 00:01:02,680
AI Digest. 
Today we are talking about the 

19
00:01:02,680 --> 00:01:07,280
agent interoperability problem, 
why your AI agents cannot talk 

20
00:01:07,280 --> 00:01:10,560
to each other, and the three 
protocols that are trying to fix

21
00:01:10,560 --> 00:01:13,440
it before the whole thing 
collapses under its own weight. 

22
00:01:14,240 --> 00:01:17,680
Let me frame the scale of this 
problem with a number from 

23
00:01:17,680 --> 00:01:25,440
Composio 2026 AI Agent Report. 
90% of enterprises now have AI 

24
00:01:25,440 --> 00:01:30,280
agents deployed in production, 
but only 23% have successfully 

25
00:01:30,280 --> 00:01:32,520
scaled them beyond a single use 
case. 

26
00:01:33,160 --> 00:01:37,640
That gap, 67 percentage points 
of companies stuck at one agent 

27
00:01:37,640 --> 00:01:41,720
doing one thing, is almost 
entirely an interoperability 

28
00:01:41,720 --> 00:01:44,200
problem. 
The agent works. 

29
00:01:44,760 --> 00:01:50,080
The agent works great, but it is
an island, and islands do not 

30
00:01:50,080 --> 00:01:52,560
compound. 
This is not a new problem in 

31
00:01:52,560 --> 00:01:55,320
computing. 
We solved it for applications 

32
00:01:55,320 --> 00:01:59,000
decades ago with APIs. 
We solved it for microservices 

33
00:01:59,000 --> 00:02:03,080
with REST and GRPC. 
We solved it for web browsers 

34
00:02:03,080 --> 00:02:06,320
with HTTP. 
Every time a new computing 

35
00:02:06,320 --> 00:02:09,759
paradigm emerges, the first 
generation is a bunch of 

36
00:02:09,759 --> 00:02:13,440
isolated systems that cannot 
communicate, and then someone 

37
00:02:13,440 --> 00:02:17,480
builds the connective tissue and
the entire ecosystem explodes in

38
00:02:17,480 --> 00:02:20,880
capability. 
We are in that preconnective 

39
00:02:20,880 --> 00:02:23,320
tissue moment for AI agents 
right now. 

40
00:02:24,080 --> 00:02:27,000
The challenge with agents is 
that they are fundamentally 

41
00:02:27,000 --> 00:02:30,440
different from traditional 
software in ways that make the 

42
00:02:30,440 --> 00:02:32,760
old integration patterns 
insufficient. 

43
00:02:33,280 --> 00:02:37,480
An API call is deterministic. 
You send a request, you get a 

44
00:02:37,480 --> 00:02:40,960
response, you know the schema. 
And agent interaction is not 

45
00:02:40,960 --> 00:02:43,120
like that. 
The agent might need to 

46
00:02:43,120 --> 00:02:47,240
negotiate, it might need to ask 
clarifying questions, it might 

47
00:02:47,240 --> 00:02:50,520
need to stream partial results 
over minutes or hours as it 

48
00:02:50,520 --> 00:02:54,400
works through a complex task. 
It might fail part way through 

49
00:02:54,600 --> 00:02:58,480
and need to hand off gracefully.
The interaction pattern is 

50
00:02:58,480 --> 00:03:01,760
closer to how 2 humans 
collaborate on a project than 

51
00:03:01,760 --> 00:03:05,360
how 2 services exchange data, 
and we do not have good 

52
00:03:05,360 --> 00:03:10,400
protocols for that. 
What we do have as of mid 2026 

53
00:03:10,800 --> 00:03:13,800
are three protocols that each 
tackle a different piece of this

54
00:03:13,800 --> 00:03:18,200
puzzle and understanding how 
they fit together is the key to 

55
00:03:18,200 --> 00:03:21,440
understanding where agent 
infrastructure is heading. 

56
00:03:22,000 --> 00:03:27,480
The 1st is MCP, the model 
context protocol created by 

57
00:03:27,480 --> 00:03:30,400
Anthropic and now governed by 
the Linux Foundation. 

58
00:03:31,160 --> 00:03:33,640
MCP is the one you have probably
heard of. 

59
00:03:34,120 --> 00:03:39,680
It has 97,000,000 monthly SDK 
downloads as of early 2026. 

60
00:03:40,240 --> 00:03:43,680
It is integrated into every 
major AI provider tool chain. 

61
00:03:44,280 --> 00:03:47,840
It is, for all practical 
purposes, the standard for how 

62
00:03:47,840 --> 00:03:50,600
an agent connects to tools and 
data sources. 

63
00:03:51,280 --> 00:03:54,600
Think of MCP as the power strip 
for AI agents. 

64
00:03:54,960 --> 00:03:57,440
Your agent needs to read a file 
from Google Drive. 

65
00:03:58,600 --> 00:04:04,320
There is an MCP server for that.
It needs to query a database MCP

66
00:04:04,320 --> 00:04:08,040
server, send a Slack message MCP
server. 

67
00:04:08,520 --> 00:04:11,960
The protocol defines a clean 
client server interface, where 

68
00:04:11,960 --> 00:04:15,120
the agent is the client and the 
tool is the server. 

69
00:04:15,520 --> 00:04:18,680
The agent discovers what 
capabilities the server offers, 

70
00:04:18,680 --> 00:04:22,040
sends structured requests, and 
gets structured responses back. 

71
00:04:22,600 --> 00:04:25,800
It is simple, it is elegant, and
it works. 

72
00:04:26,600 --> 00:04:29,880
But here's the critical thing 
about MCP that most coverage 

73
00:04:29,880 --> 00:04:33,520
gets wrong. 
MCP is vertical integration. 

74
00:04:34,000 --> 00:04:36,520
It connects an agent downward to
its tools. 

75
00:04:37,000 --> 00:04:40,640
It does not connect an agent 
sideways to other agents. 

76
00:04:41,160 --> 00:04:44,560
Your customer support agent can 
use MCP to read from your 

77
00:04:44,560 --> 00:04:48,680
ticketing system, but it cannot 
use MCP to ask your inventory 

78
00:04:48,680 --> 00:04:53,160
agent a question. 
MCP gives agents hands, it does 

79
00:04:53,160 --> 00:04:55,200
not give them the ability to 
coordinate. 

80
00:04:55,920 --> 00:04:58,160
This is where the second 
protocol comes in. 

81
00:04:59,000 --> 00:05:03,240
A to a Agent to Agent was 
created by Google and donated to

82
00:05:03,240 --> 00:05:05,960
the Linux Foundation in June 
2025. 

83
00:05:06,480 --> 00:05:10,160
It launched with over 50 
partners, including AWS, 

84
00:05:10,160 --> 00:05:14,800
Microsoft, Salesforce, and SAP. 
A 2A is specifically designed 

85
00:05:14,800 --> 00:05:19,320
for horizontal coordination, 
agent to agent, peer-to-peer. 

86
00:05:20,080 --> 00:05:24,880
The design of a 2A reflects a 
deep understanding of how agent 

87
00:05:24,880 --> 00:05:27,160
interactions actually work in 
practice. 

88
00:05:27,840 --> 00:05:32,120
It introduces a concept called 
an agent card, which is 

89
00:05:32,120 --> 00:05:36,760
essentially a machine readable 
resume that an agent publishes 

90
00:05:36,760 --> 00:05:40,520
to describe what it can do, what
inputs it needs, and what 

91
00:05:40,520 --> 00:05:43,840
outputs it produces. 
When one agent wants to 

92
00:05:43,840 --> 00:05:47,560
collaborate with another, it 
first reads the agent card to 

93
00:05:47,560 --> 00:05:49,920
understand the other agent 
capabilities. 

94
00:05:50,640 --> 00:05:53,320
This is analogous to how you 
might check a colleague on 

95
00:05:53,320 --> 00:05:55,960
LinkedIn before reaching out 
with the request. 

96
00:05:56,760 --> 00:06:00,040
You want to know if they are the
right person before you start a 

97
00:06:00,040 --> 00:06:04,280
conversation. 
Then A to a provides a task life

98
00:06:04,280 --> 00:06:07,800
cycle protocol. 
One agent can create a task for 

99
00:06:07,800 --> 00:06:11,320
another agent, check on its 
progress, receive partial 

100
00:06:11,320 --> 00:06:13,280
updates, and get the final 
result. 

101
00:06:14,080 --> 00:06:17,960
The interaction is asynchronous 
by default, which is the right 

102
00:06:17,960 --> 00:06:20,920
call because real agent work 
takes time. 

103
00:06:22,240 --> 00:06:25,760
You do not want your customer 
support agent frozen waiting 

104
00:06:25,760 --> 00:06:29,080
synchronously for the inventory 
agent to finish a full stock 

105
00:06:29,080 --> 00:06:31,760
analysis. 
You want it to fire off the 

106
00:06:31,760 --> 00:06:35,760
request, keep handling tickets, 
and get notified when the result

107
00:06:35,760 --> 00:06:39,080
is ready. 
A to A also handles something 

108
00:06:39,080 --> 00:06:42,640
that most protocol designers get
wrong on the first try, which is

109
00:06:42,640 --> 00:06:46,400
failure and hand off. 
If an agent cannot complete a 

110
00:06:46,400 --> 00:06:49,360
task. 
A to A defines explicit error 

111
00:06:49,360 --> 00:06:53,720
States and hand off mechanisms. 
The failing agent can say, I 

112
00:06:53,720 --> 00:06:57,240
cannot do this, here's the 
partial work I completed, and 

113
00:06:57,240 --> 00:06:59,800
here's a suggestion for who 
might be able to finish it. 

114
00:07:00,520 --> 00:07:03,960
This is crucial in production 
environments where reliability 

115
00:07:03,960 --> 00:07:06,120
matters more than peak 
performance. 

116
00:07:06,680 --> 00:07:11,240
A system that fails gracefully 
is infinitely more valuable than

117
00:07:11,240 --> 00:07:16,200
one that fails silently. 
The third protocol is ACP, the 

118
00:07:16,200 --> 00:07:20,240
aging communication protocol 
originally created by IBM. 

119
00:07:20,880 --> 00:07:23,920
ACP took a different 
philosophical approach than A to

120
00:07:24,040 --> 00:07:27,360
a, where A to a builds a full 
life cycle framework with 

121
00:07:27,360 --> 00:07:30,240
discovery, task management, and 
streaming. 

122
00:07:30,760 --> 00:07:34,560
ACP was deliberately minimalist.
It used standard REST 

123
00:07:34,560 --> 00:07:38,160
conventions, standard 
Http://methods, standard Jason 

124
00:07:38,160 --> 00:07:40,960
payloads. 
The argument was that 

125
00:07:41,000 --> 00:07:45,120
enterprises already have massive
investment in REST 

126
00:07:45,120 --> 00:07:49,440
infrastructure. 
Load balancers, API gateways, 

127
00:07:49,880 --> 00:07:54,000
monitoring tools, and making 
agents communicate over plane. 

128
00:07:54,000 --> 00:07:56,760
REST would be the fastest path 
to adoption. 

129
00:07:57,680 --> 00:08:00,720
This is a legitimate engineering
argument. 

130
00:08:01,440 --> 00:08:03,960
Every enterprise has people who 
know REST. 

131
00:08:04,480 --> 00:08:07,880
Not every enterprise has people 
who understand custom binary 

132
00:08:07,880 --> 00:08:12,080
protocols or GRPC streaming. 
If you can make agent 

133
00:08:12,080 --> 00:08:15,800
communication look like a 
regular API call, you remove a 

134
00:08:15,800 --> 00:08:19,400
huge barrier to adoption. 
But here is the interesting 

135
00:08:19,400 --> 00:08:23,760
part. 
In September 2025, IBM announced

136
00:08:23,760 --> 00:08:27,880
that ACP would officially merge 
with a 2A under the Linux 

137
00:08:27,880 --> 00:08:32,400
Foundation. 
Kate Blair, IBM director of 

138
00:08:32,400 --> 00:08:36,360
Incubation, who had been 
overseeing ACP, joined the a 2A 

139
00:08:36,360 --> 00:08:39,039
technical steering committee. 
The reasoning was 

140
00:08:39,039 --> 00:08:42,240
straightforward. 
Maintaining 2 agent, 2 agent 

141
00:08:42,240 --> 00:08:45,320
standards creates unnecessary 
fragmentation. 

142
00:08:45,640 --> 00:08:49,120
The industry needs one 
horizontal protocol, not two, 

143
00:08:49,560 --> 00:08:53,520
and A to a had more momentum. 
This merger is significant 

144
00:08:53,520 --> 00:08:57,240
because it signals that the 
industry is converging faster 

145
00:08:57,240 --> 00:09:00,560
than most people expected. 
We are not heading toward a 

146
00:09:00,560 --> 00:09:03,680
fragmented landscape of 
competing agent protocols. 

147
00:09:04,120 --> 00:09:08,680
We are heading toward a two 
layer stack MCP for vertical 

148
00:09:08,680 --> 00:09:12,600
agent to tool, A to A for 
horizontal agent to agent. 

149
00:09:12,800 --> 00:09:16,320
That is it. 2 protocols that 
complement each other, not 

150
00:09:16,320 --> 00:09:19,440
compete. 
There is also 4th protocol worth

151
00:09:19,440 --> 00:09:22,960
mentioning even though it is 
earlier in its life cycle. 

152
00:09:23,840 --> 00:09:28,640
A&P, the Agent Network Protocol,
is a community driven effort 

153
00:09:28,640 --> 00:09:31,800
focused on open discovery of 
agents across the public 

154
00:09:31,800 --> 00:09:34,960
Internet. 
Think of it as DNS for agents, 

155
00:09:35,600 --> 00:09:39,160
where A to A assumes you already
know which agent you want to 

156
00:09:39,160 --> 00:09:42,040
talk to. 
A&P tries to solve the discovery

157
00:09:42,040 --> 00:09:45,760
problem. 
How does your procurement agent 

158
00:09:45,760 --> 00:09:47,880
find a compliance agent in the 
1st place? 

159
00:09:48,680 --> 00:09:52,760
A&P proposes A decentralized 
registry where agents publish 

160
00:09:52,760 --> 00:09:55,640
their capabilities and other 
agents can search for them. 

161
00:09:56,240 --> 00:09:59,840
It is ambitious, it is early, 
and it faces all the trust 

162
00:09:59,840 --> 00:10:04,160
problems of any open registry, 
but it is solving a real gap 

163
00:10:04,160 --> 00:10:07,000
that neither MCP nor a 2A 
currently address. 

164
00:10:07,600 --> 00:10:11,920
The analogy that clarifies how 
all of these fit together is the

165
00:10:11,920 --> 00:10:13,800
one from the Xylo's research 
team. 

166
00:10:14,760 --> 00:10:18,520
MCP is the power strip, you plug
your tools into it. 

167
00:10:19,200 --> 00:10:22,480
A 2A is the phone line, you call
your colleagues through it. 

168
00:10:23,000 --> 00:10:28,040
ACP before the merger was the 
desk where work gets done and 

169
00:10:28,040 --> 00:10:31,240
A&P is the directory you look up
who to call. 

170
00:10:32,080 --> 00:10:34,680
No single protocol does 
everything and that is by 

171
00:10:34,680 --> 00:10:37,160
design. 
The industry tried the 

172
00:10:37,160 --> 00:10:40,000
monolithic approach with 
enterprise service buses in the 

173
00:10:40,000 --> 00:10:44,480
2000s and it did not work. 
A layered stack where each 

174
00:10:44,480 --> 00:10:48,040
protocol handles one concern 
well is more robust than a 

175
00:10:48,040 --> 00:10:50,440
single protocol that handles 
everything poorly. 

176
00:10:50,880 --> 00:10:55,480
Google Agent Development Kit 
already implements both MCP and 

177
00:10:55,480 --> 00:10:58,800
a 2A Salesforce. 
Agentforce implements both. 

178
00:10:59,080 --> 00:11:01,680
ServiceNow now Assist implements
both. 

179
00:11:02,480 --> 00:11:05,520
The reference architecture is 
solidifying in real time. 

180
00:11:06,240 --> 00:11:09,920
Let me put some dollar figures 
on why this matters because the 

181
00:11:09,920 --> 00:11:13,360
cost of not solving 
interoperability is staggering. 

182
00:11:14,000 --> 00:11:18,800
Composio found that the average 
enterprise spent $500,000 on a 

183
00:11:18,800 --> 00:11:21,800
failed multi agent pilot in 
2025. 

184
00:11:23,200 --> 00:11:27,520
Not on the models, not on the 
inference compute on custom 

185
00:11:27,520 --> 00:11:31,560
integration work. 5 senior 
engineers spending three months 

186
00:11:31,560 --> 00:11:34,520
building bespoke connectors 
between agents that were never 

187
00:11:34,520 --> 00:11:38,240
designed to talk to each other. 
That is half $1,000,000 on 

188
00:11:38,240 --> 00:11:41,720
plumbing, and when the pilot 
gets shelved, that plumbing gets

189
00:11:41,720 --> 00:11:46,160
thrown away. 
Multiply that across the 63% of 

190
00:11:46,160 --> 00:11:50,920
executives who report platform 
sprawl as a growing concern, and

191
00:11:50,920 --> 00:11:53,000
you start to see the scale of 
the waste. 

192
00:11:53,640 --> 00:11:57,360
The economic argument for 
standardized protocols is not 

193
00:11:57,360 --> 00:11:59,400
that they make cool demos 
possible. 

194
00:11:59,960 --> 00:12:04,040
It is that they eliminate a 
category of engineering work 

195
00:12:04,400 --> 00:12:08,000
that currently consumes months 
of senior engineering time per 

196
00:12:08,000 --> 00:12:12,200
integration. 
If your agents speak MCP and a 

197
00:12:12,200 --> 00:12:16,680
2A natively, the custom 
connector work drops to near 0. 

198
00:12:17,200 --> 00:12:20,600
The integration becomes 
configuration, not development. 

199
00:12:21,200 --> 00:12:25,680
So if the protocols exist and 
major players are adopting them,

200
00:12:26,280 --> 00:12:28,680
why is interoperability still a 
problem? 

201
00:12:29,640 --> 00:12:32,760
Because protocols are necessary 
but not sufficient. 

202
00:12:33,560 --> 00:12:36,840
Having HTTP did not 
automatically make every website

203
00:12:36,840 --> 00:12:39,560
work together. 
Having REST did not 

204
00:12:39,560 --> 00:12:42,480
automatically make every API 
compatible. 

205
00:12:43,040 --> 00:12:47,560
The protocol is the syntax, the 
semantics, what the data 

206
00:12:47,560 --> 00:12:52,200
actually means, how capabilities
map to business processes, how 

207
00:12:52,200 --> 00:12:55,120
errors propagate across 
organizational boundaries. 

208
00:12:55,400 --> 00:12:58,560
Those are the hard problems that
protocols cannot solve by 

209
00:12:58,560 --> 00:13:01,520
themselves. 
Let me give you a concrete 

210
00:13:01,520 --> 00:13:04,880
example. 
Say you have a procurement agent

211
00:13:04,880 --> 00:13:08,240
built on Salesforce and a 
compliance agent built on 

212
00:13:08,240 --> 00:13:10,720
ServiceNow. 
Both support A to a. 

213
00:13:11,840 --> 00:13:15,160
In theory, the procurement agent
should be able to ask the 

214
00:13:15,160 --> 00:13:18,720
compliance agent to review a 
vendor before signing a purchase

215
00:13:18,720 --> 00:13:21,480
order. 
But what does review a vendor 

216
00:13:21,480 --> 00:13:24,920
actually mean? 
The procurement agent thinks it 

217
00:13:24,920 --> 00:13:27,840
means checking if the vendor is 
on an approved list. 

218
00:13:28,560 --> 00:13:31,400
The compliance agent thinks it 
means running a full risk 

219
00:13:31,400 --> 00:13:34,880
assessment including financial 
stability, cybersecurity 

220
00:13:34,880 --> 00:13:40,160
posture, and regulatory history.
The A to A task gets created. 

221
00:13:40,640 --> 00:13:44,200
The compliance agent does its 
thing and comes back with a 30 

222
00:13:44,200 --> 00:13:47,280
page risk report when the 
procurement agent just wanted a 

223
00:13:47,280 --> 00:13:51,240
yes or no. 
This is the semantic gap, and it

224
00:13:51,240 --> 00:13:54,680
is the same gap that has plagued
enterprise software integration 

225
00:13:54,680 --> 00:14:00,000
for decades. 
EDI, Soapy, REST, RAFQL. 

226
00:14:00,440 --> 00:14:04,000
Every generation of integration 
technology solves the transport 

227
00:14:04,000 --> 00:14:07,520
problem and then discovers that 
the real problem was always 

228
00:14:07,520 --> 00:14:12,320
about shared meaning. 
The agent world has an 

229
00:14:12,320 --> 00:14:15,680
additional complication that 
traditional software integration

230
00:14:15,680 --> 00:14:19,320
did not face. 
Agents are non deterministic. 

231
00:14:19,600 --> 00:14:23,280
The same agent given the same 
input twice might produce 

232
00:14:23,280 --> 00:14:25,680
different outputs. 
It might take different 

233
00:14:25,680 --> 00:14:27,680
approaches. 
It might ask different 

234
00:14:27,680 --> 00:14:31,680
clarifying questions. 
This makes testing, debugging 

235
00:14:31,680 --> 00:14:35,360
and monitoring agent to agent 
interactions significantly 

236
00:14:35,360 --> 00:14:38,520
harder than testing traditional 
API integrations. 

237
00:14:39,520 --> 00:14:42,920
You cannot just replay a 
successful interaction and 

238
00:14:42,920 --> 00:14:46,480
expect the same result. 
You need to test for behavioral 

239
00:14:46,480 --> 00:14:50,640
envelopes, ranges of acceptable 
outcomes rather than exact 

240
00:14:50,640 --> 00:14:54,640
expected outputs. 
There is also the trust problem,

241
00:14:54,920 --> 00:14:57,440
which the protocols are only 
beginning to address. 

242
00:14:57,920 --> 00:15:02,200
When 2 APIs communicate within 
the same organization, trust is 

243
00:15:02,200 --> 00:15:05,440
implicit. 
You control both endpoints. 

244
00:15:05,640 --> 00:15:09,640
When 2 agents communicate across
organizational boundaries, trust

245
00:15:09,640 --> 00:15:13,680
is earned, not given. 
How do you verify that the agent

246
00:15:13,680 --> 00:15:17,120
claiming to be your supplier 
inventory system is actually 

247
00:15:17,120 --> 00:15:19,040
authorized to share stock 
levels? 

248
00:15:19,800 --> 00:15:22,760
How do you prevent one agent 
from manipulating another 

249
00:15:22,960 --> 00:15:24,800
through carefully crafted 
prompts? 

250
00:15:24,920 --> 00:15:29,760
Essentially, an agent to agent 
prompt injection A to A has 

251
00:15:29,760 --> 00:15:33,960
authentication and authorization
mechanisms, but the attack 

252
00:15:33,960 --> 00:15:37,760
surface of agent to agent 
communication is fundamentally 

253
00:15:37,760 --> 00:15:41,680
larger than traditional API 
communication because the agents

254
00:15:41,680 --> 00:15:45,200
can interpret and act on natural
language, not just structured 

255
00:15:45,200 --> 00:15:48,320
data. 
The NIST AI Agent Standards 

256
00:15:48,320 --> 00:15:53,400
Initiative, launched in 2026, is
trying to establish governance 

257
00:15:53,400 --> 00:15:56,080
frameworks for exactly these 
scenarios. 

258
00:15:56,880 --> 00:16:01,240
Their focus areas include agent 
identity verification, 

259
00:16:01,720 --> 00:16:05,840
capability attestation, audit 
trails for multi agent 

260
00:16:05,840 --> 00:16:09,560
decisions, and liability 
frameworks for when a chain of 

261
00:16:09,560 --> 00:16:11,600
agents produces A harmful 
outcome. 

262
00:16:12,480 --> 00:16:16,960
These are governance problems, 
not protocol problems, but they 

263
00:16:16,960 --> 00:16:20,320
will determine whether multi 
agent systems ever achieve 

264
00:16:20,320 --> 00:16:24,280
mainstream enterprise adoption. 
Let me bring this back to the 

265
00:16:24,280 --> 00:16:27,880
practitioner level. 
If you are building or deploying

266
00:16:28,000 --> 00:16:32,360
AI agents today, here's what the
interoperability landscape means

267
00:16:32,360 --> 00:16:37,280
for your architecture decisions.
First, adopt MCP now. 

268
00:16:37,920 --> 00:16:39,920
It is the clear foundation 
layer. 

269
00:16:40,400 --> 00:16:44,640
It has critical mass universal 
tool support and a stable 

270
00:16:44,640 --> 00:16:48,760
specification. 
If your agents are not using MCP

271
00:16:48,760 --> 00:16:52,320
for tool integration, you're 
building custom connectors that 

272
00:16:52,320 --> 00:16:56,640
you'll have to throw away. 
Second, design for A to a. 

273
00:16:56,640 --> 00:17:00,600
Even if you are not implementing
it yet, Structure your agents 

274
00:17:00,600 --> 00:17:04,359
with clear capability 
descriptions, well defined input

275
00:17:04,359 --> 00:17:07,480
and output schemas, and explicit
error handling. 

276
00:17:07,960 --> 00:17:12,079
When you do add A to a, these 
architectural patterns translate

277
00:17:12,079 --> 00:17:15,520
directly into agent cards and 
task definitions. 

278
00:17:16,119 --> 00:17:19,480
If your agent is a monolith that
takes unstructured text and 

279
00:17:19,480 --> 00:17:22,680
returns unstructured text, it 
will be very difficult to make 

280
00:17:22,680 --> 00:17:26,839
it interoperable later. 
Third, treat the semantic gap as

281
00:17:26,839 --> 00:17:29,400
a product problem, not a 
technical one. 

282
00:17:30,040 --> 00:17:33,680
The hardest part of making two 
agents work together is agreeing

283
00:17:33,680 --> 00:17:37,440
on what the words mean. 
Define your domain vocabulary. 

284
00:17:37,440 --> 00:17:42,760
Explicitly document what review 
a vendor means in your context. 

285
00:17:43,360 --> 00:17:47,000
Build shared ontologies for 
common business concepts. 

286
00:17:47,520 --> 00:17:50,920
This is the work that no 
protocol can do for you, and it 

287
00:17:50,920 --> 00:17:54,120
is the work that will determine 
whether your multi agent system 

288
00:17:54,120 --> 00:17:58,160
actually delivers value or just 
passes messages back and forth. 

289
00:17:58,760 --> 00:18:04,120
4th plan for the trust boundary.
Every agent to agent interaction

290
00:18:04,120 --> 00:18:08,000
crosses a trust boundary, even 
if both agents are within your 

291
00:18:08,000 --> 00:18:11,840
organization. 
Build in verification, build in 

292
00:18:11,840 --> 00:18:15,840
audit trails, Build in the 
ability to explain why a chain 

293
00:18:15,840 --> 00:18:18,040
of agents made a particular 
decision. 

294
00:18:18,520 --> 00:18:21,960
Because when something goes 
wrong in a multi agent system, 

295
00:18:22,280 --> 00:18:25,800
and it will, the first question 
will be which agent made the 

296
00:18:25,800 --> 00:18:29,400
wrong call and the second 
question will be why did the 

297
00:18:29,400 --> 00:18:33,720
other agents trust it. 
And 5th watch your 

298
00:18:33,720 --> 00:18:37,280
observability. 
In a traditional microservices 

299
00:18:37,280 --> 00:18:40,040
architecture you have 
distributed tracing. 

300
00:18:40,600 --> 00:18:43,920
You can follow a request from 
the API Gateway through 10 

301
00:18:43,920 --> 00:18:47,480
services and back. 
Multi agent systems need the 

302
00:18:47,480 --> 00:18:49,800
equivalent, but for reasoning 
chains. 

303
00:18:50,200 --> 00:18:55,200
When agent A asks agent B, which
asks agent C, which makes the 

304
00:18:55,200 --> 00:18:58,640
decision that agent A acts on, 
you need to be able to 

305
00:18:58,640 --> 00:19:01,760
reconstruct that entire 
reasoning chain after the fact. 

306
00:19:02,320 --> 00:19:05,720
Not just the messages that were 
passed, but the reasoning each 

307
00:19:05,720 --> 00:19:07,840
agent applied to produce its 
output. 

308
00:19:08,520 --> 00:19:12,280
This is harder than distributed 
tracing because the reasoning is

309
00:19:12,280 --> 00:19:17,560
non deterministic. 2 identical 
replays will produce different 

310
00:19:17,560 --> 00:19:19,760
traces. 
The tooling for this barely 

311
00:19:19,760 --> 00:19:22,960
exists today, but it will be 
table stakes within a year. 

312
00:19:23,680 --> 00:19:27,960
There is one more dimension of 
the interoperability problem 

313
00:19:28,160 --> 00:19:32,040
that deserves attention, and 
that is the organizational 

314
00:19:32,040 --> 00:19:35,600
dimension. 
Protocols solve the technical 

315
00:19:35,600 --> 00:19:38,240
problem of how agents 
communicate. 

316
00:19:38,880 --> 00:19:42,160
They do not solve the 
organizational problem of who 

317
00:19:42,160 --> 00:19:46,400
owns the agent, who is liable 
for its outputs, and who pays 

318
00:19:46,400 --> 00:19:49,800
when it breaks. 
In an enterprise with a customer

319
00:19:49,800 --> 00:19:53,440
service agent owned by the 
support team and a billing agent

320
00:19:53,440 --> 00:19:57,040
owned by the finance team, who 
is responsible when the two 

321
00:19:57,040 --> 00:20:00,880
agents collaborate to issue a 
refund that violates company 

322
00:20:00,880 --> 00:20:04,560
policy? 
The support team says the 

323
00:20:04,560 --> 00:20:07,960
billing agent approved it. 
The finance team says the 

324
00:20:07,960 --> 00:20:12,200
support agent initiated it. 
Both are right, neither feels 

325
00:20:12,200 --> 00:20:15,520
accountable. 
This is the multi agent 

326
00:20:15,520 --> 00:20:18,720
governance problem and it 
mirrors the challenges that 

327
00:20:18,720 --> 00:20:22,240
organizations faced when they 
first adopted microservices. 

328
00:20:23,040 --> 00:20:26,920
Ownership boundaries, Slas 
between internal teams. 

329
00:20:27,480 --> 00:20:30,080
Incident response for cross team
failures. 

330
00:20:31,600 --> 00:20:35,040
The companies that solve 
microservices governance did it 

331
00:20:35,040 --> 00:20:39,720
by establishing clear service 
ownership, explicit Slas, and 

332
00:20:39,720 --> 00:20:44,880
shared on call rotations. 
Multi agent systems will need 

333
00:20:44,880 --> 00:20:48,760
the same organizational 
infrastructure adapted for the 

334
00:20:48,760 --> 00:20:52,800
fact that agents make judgment 
calls, not just deterministic 

335
00:20:52,800 --> 00:20:56,760
computations. 
The agent interoperability 

336
00:20:56,760 --> 00:21:00,160
problem is real, it is urgent, 
and it is solvable. 

337
00:21:01,480 --> 00:21:05,240
The protocols are here. 
The governance frameworks are 

338
00:21:05,240 --> 00:21:08,160
coming. 
The missing piece is the 

339
00:21:08,160 --> 00:21:11,880
unglamorous integration work 
that turns a protocol 

340
00:21:11,880 --> 00:21:14,360
specification into a working 
system. 

341
00:21:15,080 --> 00:21:18,360
This is not the kind of work 
that makes headlines or gets 

342
00:21:18,360 --> 00:21:22,600
published at conferences, but it
is the work that will determine 

343
00:21:22,600 --> 00:21:26,840
whether the 90% of enterprises 
that have deployed agents can 

344
00:21:26,840 --> 00:21:29,760
join the 23% that have actually 
scaled them. 

345
00:21:30,400 --> 00:21:35,560
The AI industry spent 2024 and 
2025 proving that individual 

346
00:21:35,560 --> 00:21:37,600
agents can be remarkably 
capable. 

347
00:21:38,200 --> 00:21:42,400
The challenge for 2026 and 
beyond is proving that they can 

348
00:21:42,400 --> 00:21:46,280
be remarkably capable together. 
I am MO Bouillon. 

349
00:21:47,000 --> 00:21:50,520
This has been the Practical AI 
Digest. 

350
00:21:50,800 --> 00:21:52,360
See you in two weeks.
