At a maintainer roundtable during AGNTCon + MCPDev Summit EU in Amsterdam, moderator Nitish Tyagi of Gartner sat down with four people building the infrastructure underneath the agentic AI stack: David Soria Parra, Anthropic; Idit Levine, Solo.io; Kuba Herczyński, Google; and Nick Cooper, OpenAI. The conversation covered why enterprises are still in pilot mode on custom agentic systems, what enterprises can actually learn from open source, why identity and authorization are becoming the central problem, how to keep token costs under control, how observability needs to evolve, and how standards themselves should be built. Here are some of the main points from the discussion.
Enterprises are still experimenting, on a compressed timeline
“It's just a compressed time zone where everybody really is experimenting this year, and latest, if not this year, we already see quite a lot of companies starting to really productionize it,” said Kuba.
The consensus was that adaptability is an advantage of agentic systems over traditional software; they can be shaped to each company's specific needs, which is why no single deployment pattern has settled yet. That flexibility already shows up in production use: some organizations described running fully agentic applications at scale today, with identity as the main remaining friction point. The pace was compared to the early cloud native adoption curve, just compressed from years into months, with constraints like HIPAA compliance or legal and cultural silos still slowing certain industries more than others.
What enterprises can borrow from open source communities
There was skepticism about how directly open source practice transfers to enterprise settings; community experimentation without commercial constraints doesn't map cleanly onto how companies operate, and internal silos (a legal team blocking a project it doesn't fully understand) were named as a bigger practical barrier than any shortage of open code. What does transfer, the group agreed, is the habit of engaging with an existing community's accumulated best practices and tooling instead of building everything from scratch.
MCP itself was repeatedly held up as proof that this can work, a standard shaped by companies that might otherwise never sit in the same room, refined enough that enterprises have been able to adopt it directly rather than reinventing it internally. The panel credited this to a neutral, foundation-backed space where even competitors can compare notes, the kind of setting they argued the industry will need more of as agentic standards keep evolving.
Composability is the connective tissue
The view was that the interesting work now is making MCP, A2A, and whatever comes next interoperate, with shared description formats like the AI card specification cited as an early example of protocols developing common threads. Looking further out, the conversation turned to the idea of an “agentic economy,” where agents transact with and build trust in one another, though what that will look like in practice is still unclear.
Identity and authorization are the next big unlock
“Honestly, what's really keeping me up at night is not the agent that I'm running in my organization, which I'm putting in a sandbox, it's the one that I'm not running,” said Idit, describing an unsupervised agent, like one a teenager might run, operating outside anyone's control and attacking sensitive systems no one is watching.
Identity came up repeatedly as the biggest unresolved piece, rooted in a structural mismatch: decades of access control were built around humans, who get slow, heavily scrutinized authorization in exchange for broad, standing access. Agents need the opposite: fast, narrow, and easily revoked. The standards for that don't fully exist yet. MCP's current authorization model leans on OAuth 2.1, a human-centric standard, and the shared view was that the industry now needs new primitives for agent-native identity, something A2A was noted as already building in directly.
Controlling token costs across the whole system
Token cost was broken down as three variables multiplied together: price per model call, amount of context sent, and number of round trips. The fixes discussed attacked each in turn: limiting which tools get loaded in the first place, disclosing only a couple of tools at once instead of a full list, and collapsing multiple round trips into fewer calls. On-demand tool loading alone was credited with erasing a lot of the waste that defined early implementations, echoing the early days of cloud computing, when nobody thought twice about running a VM 24/7. Simple documentation (README files, Agents.md files, comments in code) was flagged as one of the easiest ways to shrink the context an agent needs, and therefore the cost, by giving it something to read instead of something to rediscover. The bigger shift identified was moving away from token-based pricing comparisons entirely and toward measuring cost per completed task, since not all tokens are worth the same.
Observability needs to capture why an agent acted
The panel largely agreed that agentic observability builds on existing practice, with OpenTelemetry already being extended to cover MCP. Customers were described as treating full logging as a requirement, in contrast to the sampling that's normal in traditional cloud systems. The harder open question raised was capturing why an agent chose a particular tool or path, an attribution problem that gets messier once agents are calling other agents across trust boundaries, and harder still given that LLMs can rephrase data in ways that make tracing its lineage difficult.
Standards should be built on working implementations
“MCP has a sort of lagging approach when you want to adjust the specification, your suggestion needs to go hand in hand with a concrete implementation, with conformance tests,” said Nick, describing a lesson he took directly from working alongside David.
The instinct when building any standard is to guess at the hypothetical future and design for it in advance, but the panel's shared experience was that this instinct is usually wrong. The alternative discussed was requiring evidence before changing a spec: a proposed adjustment has to prove itself in a working implementation first. On the skills side, the biggest gap flagged was evaluation: knowing the difference between a well-designed MCP server and one that was clearly auto-generated and shallow, which is part of why certification programs like the MCP Associate track were raised as a useful way to close that gap. Almost nothing from the deterministic-systems era was written off as obsolete; the panel argued that old lessons in evaluation and Unix-style composability are being reapplied to make agentic systems legible.
Building on a floor that keeps moving
“It's super hard to see what things will be if the floor is moving while you are trying to build a house on top of a moving floor,” said David.
David’s comment points to what makes this shift different from past ones; the models underneath these systems are still changing as fast as the tooling built on top of them. The shared bet across the panel was that composability, identity, and cost discipline need to solidify first, because everything else will have to be built on them, whatever comes next.
Closing thoughts
Asked what excites each of them most, looking three to five years out, David pointed to seeing early signs of AI accelerating scientific and mathematical discovery. Nick highlighted how much more approachable building has become: ideas that once required deep technical skill can now be executed by far more people. Kuba is watching for multi-agent systems that cross trust boundaries, with agents from different companies working together. Idit said she cares less about the theoretical roadmap than about real-world adoption: getting people to actually use these systems, learn from that use, and feed it back into how the tools evolve.
Check out all the talks from this event at the AAIF YouTube channel.
Share
Author
