AGNTCon + MCPCon Europe 2026: Two Days of Real Agentic AI at RAI Amsterdam

AGNTCon + MCPCon Europe 2026: Two Days of Real Agentic AI at RAI Amsterdam

Day 1 recap — 2,000+ attendees, keynotes from the co-creator of MCP, and the data that shows agentic AI has already crossed into production.

Today I attended AGNTCon + MCPCon Europe at RAI Amsterdam — the Linux Foundation’s flagship conference on agentic AI and the Model Context Protocol. The tagline says “Where the agentic stack is being built” and after walking the floor, I can confirm: this is exactly the right place to be if you want to see how the agentic stack is taking shape.

The Scene: RAI Amsterdam, September 17-18

The event occupies the main auditorium at RAI Amsterdam, complete with professional video cameras, tiered blue theater seating, and the kind of dramatic purple-and-blue lighting that makes every photo look like it belongs on a conference highlight reel. The crowd of 2,000+ attendees represents the full spectrum of the agentic AI ecosystem: open source maintainers, enterprise platform engineers, researchers, and developer advocates from companies like Microsoft, Elastic, AWS, Anthropic, GitHub, and Hugging Face.

The event is co-hosted by the Agentic AI Foundation, with production support from the Linux Foundation. As a media partner, I was on the ground capturing the key moments — from the opening keynotes to the panel discussions to the hallway conversations where the real insights live.

Arriving at RAI Amsterdam on Day 1, past the registration desks.

The sponsor board: AWS, Google Cloud, Obot and Solo.io in the Diamond tier, then Buzz, FME, Grape Up, Runlayer, Vultr and WSO2 in Platinum.

Keynote 1: Welcome — Angie Jones, VP at Agentic AI Foundation

9:00 AM | Auditorium (Ground Floor)

The morning kicked off with Angie Jones, Vice President of Developer Experience at the Agentic AI Foundation. Angie — a master inventor with 27 patents and a renowned international keynote speaker — set the tone for the two days ahead.

Her message was clear: the era of “AI agents as a future technology” is over. The era of “AI agents as a production technology” has begun. Every decision the conference would return to — from security to observability to interoperability — was framed through the lens of production readiness.

Keynote: Building the Internet of Agents in the Open — Mazin Gilbert, AAIF

9:07 AM | Auditorium (Ground Floor)

Mazin Gilbert, Executive Director of the Agentic AI Foundation, gave the foundation’s state of the union. His framing slide, “The Evolution of AI”, had three phases behind us (rule-based deterministic systems before 1990, statistical machine learning from the 1990s to 2016, transformers and LLMs from 2017 to today) and a fourth “now emerging”: the agentic stack, “systems that plan, use tools, observe, take action and iterate”.

“A Tale of Two Internets” argued that the web scaled on three foundations and the “Internet of Agents” needs the same three, one layer up:

• Open protocols: TCP/IP, HTTP and HTML then; MCP, A2A and agentic commerce protocols now.
• Stateless infrastructure: HTTP and DNS then; stateless agent-tool connections, registries and gateways now.
• Neutral governance: IETF, W3C and ICANN then; the AAIF at the Linux Foundation now, “a neutral home where the agentic stack is governed by no single company”.

From Mazin Gilbert’s keynote: “Agent = Model + Harness + Protocols + Tools” and “Same weights. Different harness. Different agent.”

His definition slide was “Agent = Model + Harness + Protocols + Tools”: “The model reasons. The harness decides what it sees, what it can do, and when it stops.” It listed MCP, A2A and AGENTS.md/SKILL.md as standardized today, and things like memory, context, tool and model portability, and permission and authorization manifests as open, “where the work is”.

The AAIF project list, with A2A and Agent Router highlighted as the new additions.

The AAIF Projects slide listed six hosted projects: Model Context Protocol, goose, AGENTS.md, agentgateway, and, highlighted in red as the newcomers, Agent2Agent (A2A) and Agent Router (“a vendor-neutral gateway for AI and agent traffic, unifying access to 16+ model providers and MCP servers with authentication, rate limiting, and observability”). The member landscape slide counted 270 members across 15 industrial sectors.

“Seven open working groups. Not one of these is a model problem.”

The slide I photographed most carefully was “The Seven AAIF Working Groups”, subtitled “Not one of these is a model problem”:

1. Accuracy & Reliability: per-step accuracy collapses over long task chains; failures are non-deterministic.
2. Agentic Commerce: ACP, UCP, x402 and AP2 must converge, or every merchant becomes a custom integration.
3. Governance, Risk & Regulatory: accountability for autonomous errors is unsettled; rules fragment across jurisdictions.
4. Identity & Trust: who an agent is, who it acts for, and how authority is scoped, verified and revoked.
5. Observability & Traceability: tracing reasoning across hours, tools and sub-agents to regulator-grade audit trails.
6. Security & Privacy: untrusted content hijacks agents; tool poisoning and supply-chain attacks persist.
7. Workflows & Process Integration: orchestration, hand-off and human-in-the-loop patterns across vendor boundaries.

All of them are “member-led, open to participate”, with public meetings, mailing lists and repos. He closed with the 2026 AAIF Member Pulse Survey (the numbers are in The Data below) and a “Five ways to start this week” slide of QR codes for the AAIF, the working groups, submitting a project, events and the AAIF projects.

My take: “not one of these is a model problem” is the right message for platform teams. Every item on that list (identity, audit trails, hand-offs, supply chain) is work that sits around the model, and it’s work most organisations already know how to do for microservices.

Keynote 2: MCP and the Era of Connectivity — David Soria Parra, Co-creator of MCP, Anthropic

9:18 AM | Auditorium (Ground Floor)

Fresh off the welcome, David Soria Parra — Member of Technical Staff at Anthropic and co-creator of the Model Context Protocol — took the stage for what was arguably the most anticipated session of Day 1.

David’s background is a fascinating primer for anyone building on top of MCP: former core developer for PHP, contributor to Git and Mercurial, former engineering leader at Meta/Facebook, entrepreneur-in-residence at Sutter Hill Ventures, and now at Anthropic driving MCP forward. His talk — “MCP and the Era of Connectivity” — was a masterclass in how a protocol designed to solve a narrow problem (connecting AI assistants to external data) evolved into the most adopted standard in the agentic stack.

The core of the talk was MCP’s move to a stateless core, with a new extensions framework, authorization changes, and a clear migration path for existing clients and servers. His slide labelled it a “2026-07-28 · recap”: the stateless revision had shipped in the 28 July 2026 spec, and he called it “the largest revision since launch”.

He started with a METR “long-horizon tasks” chart (50% time horizon on a log scale, measured and estimated points for Anthropic models) to argue that, as model capability compounds, the key becomes connecting it. The adoption numbers followed: 1,000,000,000+ MCP tool calls served on Claude, and an “MCP continues to grow” slide with about 500M tier-1 MCP SDK downloads a month, 180K stars across MCP repositories (1.5× year on year), MCP adapter downloads up 6× in six months, and 950+ MCP servers in the Claude connector directory. The slide’s sources were npm/PyPI, GitHub and @rauchg, August 2026.

The four parts of the 2026-07-28 revision, as David Soria Parra summarised them.

The “A stateless protocol core” slide broke the revision into four parts:

1. Statelessness: no handshake, no sessions. Any request lands on any instance behind a plain load balancer.
2. MRTR (multi round-trip requests): elicitation and sampling without held-open streams.
3. Cacheable results: list responses carry cache hints and a deterministic order.
4. Deprecation policy: a twelve-month minimum window, so you can plan upgrades instead of reacting to them.

His “What’s next” slides named three directions: agentic messaging (server-initiated events through subscriptions and webhooks, and MCP Tasks moving towards the core protocol, via the Agents and Triggers & Events working groups), richer semantics (skills over MCP as an extension, progressive discovery of tools and resources) and authorization and identity (workload identity federation for agents, ID-JAG and RFC 8693 token exchange for delegation, and optional DPoP).

The expo floor before the crowds arrived, with the Solo.io booth in the background.

Keynote: Reactive Agents — Clare Liguori, AWS

9:29 AM | Auditorium (Ground Floor)

Clare Liguori (MCP Core Maintainer & Sr. Principal Engineer, AWS) gave “Reactive Agents: Your Agent Doesn’t Need to Be Always On”. It wasn’t a talk about running MCP servers at AWS scale. It was about agent design: most agents spend their time waiting, either for user input or for tool results, and an always-on agent holds compute and memory the whole time.

The reactive-agent loop: hibernate while waiting, wake on input or on tool results.

Her alternative was the reactive agent: it hibernates and wakes on input, and hibernates and wakes again when tool results arrive.

The Infinity experiment: 80,000 resident agents in 8.4 GB, about 103 KB each, against a Raspberry Pi 5 (8 GB) line.

To show what that buys you, she ran the Infinity experiment. Instead of a traditional model where every agent holds resources (“wasted resources”), agents are time-sliced and “only active slices use compute”. Her chart showed 80,000 resident agents in 8.4 GB of process memory (RSS), about 103 KB per agent, drawn against a “Raspberry Pi 5 (8 GB)” marker.

She then listed what a reactive agent needs from MCP:

1. The agent can suspend and resume when idle, which needs no long-lived streams between client and server. The 2026-07-28 spec’s multi round-trip requests let a tool call ask for input and continue in a second request.
2. Work continues while the agent hibernates, which is the job of the MCP Tasks extension (modelcontextprotocol/ext-tasks): start a long-running tool call, get a task ID, poll for status.
3. An external event can wake the agent, which is what the MCP Triggers & Events working group (modelcontextprotocol/experimental-ext-triggers-events) is working on, with three delivery models on her slide: poll, push over a long-lived stream, and webhook.

Her summary diagram, “Reactive agents with MCP”, connected an agent to an MCP server with three arrows: stateless tool calls, long-running tasks and webhook events.

My take: this is the Kubernetes scale-to-zero argument applied to agents, and it’s the right one. If agents are going to be per-user or per-ticket, you can’t give each one a warm process. Statelessness in the protocol is what makes hibernation cheap.

Keynote: Agents as Actors — Idit Levine and Keith Babo, Solo.io

9:40 AM | Auditorium (Ground Floor)

Solo.io, a Diamond sponsor, had the last morning keynote: “Agents as Actors: Harnessing the Power of Agentic Infrastructure”, presented by Idit Levine (Founder & CEO) and Keith Babo (Chief Product Officer). Their opening wheel laid out an agent lifecycle (discover, eval, trace, secure, connect, deploy) across clouds and runtimes.

The first product on stage was kagent, the open source agent framework for Kubernetes, with agents, tools, skills, plugins and policies as the building blocks. In the demo, an agent asked a human for approval before deleting a file from its own memory workspace: the prompt showed who was asking, what it wanted to do, the target file, why (the file had been replaced after memory compaction) and the impact (“This action cannot be undone”). The “Agent substrate” slide that followed carried Google, Solo.io, Microsoft and NVIDIA logos.

agentgateway placed on the OSI model, with a new “L8 Context” layer on top.

Next was agentgateway (now an AAIF project), drawn on the OSI model with a new “L8 Context” layer on top and four roles: an LLM gateway (“unified interface to any model provider” with central control over access, cost and safety), an MCP/A2A gateway (“purpose-built control point for agentic protocol traffic”), an inference gateway for in-cluster model serving, and a classic layer 7 gateway (routing, failover, timeouts, retries, transformation, rate limits, circuit breaking, CORS).

agentdesktop: the same governance questions, asked of every developer laptop.

The launch was agentdesktop, “Agentic Governance on Every Desktop”, with the Solo.io logo on the slide. It brings four things to the machines where Claude Code, Codex and other harnesses run:

• Every desktop in one inventory: every harness, MCP server, skill and model across the organization, attributed to device and user.
• Centralized configuration: local or fleet-managed configuration for every supported harness, synchronized automatically.
• Least privilege security: user and device enrolment with your existing IdP via OIDC, replacing long-lived API keys with JWTs and configurable access policy.
• Agent telemetry and audit: opt-in session and tool-use events for centralized reporting across harnesses.

Solo.io’s announcement describes it as an Apache 2.0 open source project.

The four questions Solo.io’s keynote kept returning to.

Their closing slide reduced it to four questions: What agents are running? Who is the agent acting as? What can the agent reach? What did the agent do?

My take: the desktop is the blind spot I see most often. Teams govern the agents they deploy on Kubernetes, while dozens of MCP servers and skills run unmanaged on laptops with production credentials. An inventory is the first control you need.

Maintainer Roundtable

Late in the morning I sat in on a small Maintainer Roundtable, moderated by Nitish Tyagi (Senior Principal Analyst, Gartner), with David Soria Parra (Anthropic), Idit Levine (Solo.io), Kuba Herczyński (Google) and Nick Cooper (OpenAI). It isn’t on the public schedule, and I didn’t record it, so I’ll only note who was in the room: maintainers and leads from Anthropic, Google, OpenAI and Solo.io, side by side under one foundation.

Dex Horthy’s “State of the Software Factory” (Day 2)

Dex Horthy’s keynote “State of the Software Factory” was on the second day (18 September, 9:41), not on Day 1. I cover it, with his SlopCodeBench slides, in my AGNTCon + MCPCon Europe 2026 Day 2 recap.

Breakout: Zanzibar-style authorization for agents

12:00 PM | Auditorium (Ground Floor)

Just before Sam Morrow’s talk I caught part of an authorization session in the main auditorium. I couldn’t read a speaker name in my photos. The official schedule lists Sohan Maheshwar (AuthZed) with “Delegated Authorization for AI Agents: How to Build an Agent with Fine-Grained Permissions” in that room and slot, and the slides match the topic.

“Where do Zanzibar-like systems shine?”

The slides I saw walked through a check graph traversal example, check("document:somedocument", "reader", jill), in which the system answers “can Jill read this document?” by walking relationships (direct grants, groups, parent objects) rather than evaluating a flat role list. The next slide asked “Where do Zanzibar-like systems shine?”: low latency, high-throughput authorization checks, hierarchical permission models, and ambient context access control.

My take: this is the piece that turns Mazin Gilbert’s “Identity & Trust” working group into code. An agent acting for Jill should inherit exactly Jill’s relationships to a document, checked at the moment of each tool call, not a broad service-account token.

Breakout: MCP Doesn’t Have a Context Problem — Sam Morrow, GitHub

12:35 PM | Emerald Room (1st Floor)

Of the morning breakouts, this was the one I’d circled. Sam Morrow from GitHub took on the most common complaint about MCP. His session abstract sums it up: critics say MCP dumps every tool into the system prompt and every response straight back to the model, and that CLIs and agent skills are more efficient. In his view they’re right about the symptoms and wrong about the cause. The real gap is that hardly anyone had done serious context engineering on top of MCP.

The “Hot Takes” slide: quotes from Peter Steinberger, Simon Willison and others saying that MCP tool descriptions eat the context window.

He opened with a “Hot Takes” slide that collected those criticisms. Peter Steinberger, Simon Willison and others each made the same point: tool descriptions take up valuable context before the agent has done anything. According to the abstract, the rest of the talk used his own agent harness, mcpi, to show three ways to discover tools progressively over MCP, each paying only for the context tokens it needs. The main one was skills over MCP: a skill describes the tool surface and switches tools on only when the skill is invoked. MCP CLIs and code mode were the other two.

The live demo’s output: a “Merged PRs by author” chart for github/github-mcp-server, built by an agent through the GitHub MCP server.

The demo was the proof. The agent pulled the merged pull request history of github/github-mcp-server and rendered it as an animated “race” chart (pr_race.gif). In my clip of the wrap-up, Sam pointed out that the whole run had used only 47,000 tokens for the amount of data it pulled down. In code mode he encourages the agent to write async scripts, so it can make “a thousand paginated tool calls” in parallel and hand back only the processed result, instead of going turn, tool call, turn, tool call.

My take: this matches what I see with clients. The fix for context bloat is rarely “drop MCP”. It’s making the harness decide which tools are visible and when. If your agents load every tool from every server at session start, start with progressive discovery (skills or tool search), then move bulk data work into code mode.

Keynote: Inside AI Agents — Maarten Grootendorst, Google DeepMind

3:04 PM | Auditorium (Ground Floor)

After the lunch break, Maarten Grootendorst — Member of Technical Staff at Google DeepMind and creator of BERTopic, KeyBERT, and PolyFuzz — took the stage. Maarten’s unique background spans organizational psychology, clinical psychology, and data science, which gives his technical talks a distinctly human perspective.

His keynote, “Inside AI Agents: Offloading Human Tasks”, explored how agentic systems are changing the way we think about workflow automation — not by replacing human judgment, but by offloading the mechanical, repetitive, and rule-bound tasks that consume human attention. He demonstrated how open-source tooling (his own libraries included) is making it possible for teams to build agents that augment rather than replace.

The EU AI Act Thread

Two Day 1 sessions dealt with the EU AI Act, and it came up in several of my hallway conversations too.

10:50 AM | G102 + G103 (1st Floor): Mirela Takacs (Law Office Takacs Mirela) gave “Legal Implications Under EU Law When Deploying AI Agents”. I didn’t get to it, but an attendee with an EU law background told me about it on camera in the afternoon. What stayed with him was the idea of drift. A low-risk agent, such as one that schedules your calendar, can end up doing far more than it was designed to do once it’s deployed. His example was an agent that starts emailing invitations to your whole address book and then links those addresses together. He also stressed the point that the session abstract makes as well: the agent is a system, not a legal person, so the people who build and run it are the ones held accountable. The abstract’s other takeaways: treat compliance as continuous monitoring rather than a one-off check, bring legal and engineering together from the design phase, keep a clear map of what the agent does, accesses and produces, and start from the AI Act before identifying any adjacent legislation the agent’s functions trigger.

3:45 PM | Auditorium (Ground Floor): Steven Mih (Action State Group, Inc.) presented “Six Months of Proof: Independently-Verifiable Records for Agent Actions Under the EU AI Act”. His abstract starts from Article 12 (high-risk AI must support automatic record-keeping) and Article 19 (logs kept for at least six months), and points out that the Act can require logs to exist but can’t make them trustworthy. The fix is anchoring: hash each record and write the hash to an independent, append-only transparency log (the open SCITT/COSE standards), so anyone can verify what the agent did without having to trust the operator. That’s what his Agent Action Capsule project does.

From Steven Mih’s demo: a weekly “human check” in which a person blind re-graded 24 verdicts from an LLM judge.

When I photographed the demo, the screen showed a weekly “human check”. An LLM judge (labelled claude-opus-4-8) had marked each agent action against a specific article, for example Art 5(1)(a) “no manufactured pressure in the rebooking”, Art 26(1) “confirm-before-write on an upgrade” and Art 50(1) “disclosure clarity, branded surface”. A person had then re-graded 24 of those verdicts blind, and every row I could see read “MET / MET / agreed”.

My take: for platform teams, these two talks fit together. The first says compliance is an architecture concern. The second shows what that means in practice: records of agent actions that an auditor can check without trusting you, plus a human sampling the AI judge’s work. It’s the same evidence-layer idea Traefik Labs described to me on the expo floor (more below).

Panel: MCP Challenges & Opportunities

Friday 18 September, 1:15 PM | Emerald Room (1st Floor), per the official schedule; this panel ran on Day 2, not Day 1.

The panel tackled the hard questions about MCP in production:

• Sam Morrow (GitHub) — on MCP adoption at scale
• Angie Jones (Agentic AI Foundation) — on governance and standards
• Shaun Smith (Hugging Face) — on the stateless MCP transport evolution
• Shub Argha (Arcade) — on developer experience and tooling

The discussion covered the gap between “MCP works in my prototype” and “MCP runs in my production environment” — a gap that’s narrowing fast as the spec matures.

The Data: Agentic AI Is Already in Production

Mazin Gilbert closed his keynote with the 2026 AAIF Member Pulse Survey (n=186), on a slide titled “Agentic AI Is Already a Production Market”. The numbers are worth repeating:

The 2026 AAIF Member Pulse Survey slide from Mazin Gilbert’s keynote.

The Open Standards Stack — Top 10 Adopted

The survey also ranked the open standards and protocols gaining traction (using or actively evaluating, select all that apply, n=175; MPP followed at 6%):

1. MCP — 89%
2. Skills — 69%
3. A2A — 57%
4. AGENTS.md — 51%
5. AGNTCY — 37%
6. Agentgateway — 15%
7. ACP (Client) — 12%
8. Goose — 10%
9. ACP (Commerce) — 9%
10. x402 — 8%

Oversight Is a Design Choice

The survey also surfaced how teams are thinking about governance:

• 66% human-on-the-loop
• 63% bounded autonomy
• 23% fully autonomous

Deployment Is Hybrid by Default

• 85% public cloud
• 56% on-prem
• 42% local/desktop
• 19% edge

The Women + Non-Binary Community Gathering

One of the most notable side events was the “Women + Non-Binary Community Gathering” (13:35–14:45 CEST, Emerald Lounge, 1st Floor). This lunch-time networking session, hosted by the Agentic AI Foundation, brought together women and non-binary leaders in the agentic AI community for conversation over food.

The main auditorium during the keynotes, with the new MCPA certification on screen.

Hallway Track: Interviews From the Expo Floor

Between sessions I recorded short interviews for my show. Everything below is the guests’ own account, summarised. Where a company makes a product claim, it’s theirs, not mine.

Frédéric Barthelet, CTO and co-founder of Alpic (he gave the “Three Doors to One Tool” keynote on Day 2). He described Alpic as “the MCP hosting company”, with three lines of business: the hosting platform, Skybridge (an open source framework for building MCP apps that run inside ChatGPT and Claude) and a services team that helps companies build on both. Travel and e-commerce brands moved first, because their customers increasingly start a journey in ChatGPT or Claude rather than in a search engine. His advice was not to bet on a single surface. MCP apps, WebMCP, CLIs and A2A are all ways to make a business usable by agents. He cited Cloudflare reporting that agent traffic had overtaken human traffic. Browser automation works as a fallback, he said, but it’s slow, expensive in tokens and error-prone, so companies should build surfaces meant for agents. On jobs, he doesn’t buy full automation: “only the part that we don’t care about will be automated”. I wrote more about Alpic’s view in AI assistants as a new business channel.

Benjamin Hindman, Founder & CEO of Reboot (reboot.dev). Reboot is an application framework that coding agents such as Claude and Codex write full-stack apps in. Because the app is built from Reboot’s own primitives, the domain objects and how they call each other can be extracted straight from the code. In his words, the spec is “literally extracted from the code”, so it can’t drift the way a hand-written Markdown spec does. Behaviours are written as BDD features in Cucumber/Gherkin style, mapped onto the domain objects and run as tests, including end-to-end runs with Playwright, all shown in a developer dashboard. Two things he said stood out for me. When the team let an agent add feature after feature with no human input, even inside Reboot the resulting design got complicated. And his advice to newcomers was to learn data structures, service boundaries and modular architecture rather than language syntax.

Traefik Labs. A member of the Traefik team walked me through the Sovereign Trust Plane launched that week. Traefik sits in the agent workflow as a gateway that enforces routing and security policies, observes everything through OpenTelemetry, and now writes every allow and deny decision to what they call an evidence layer. It’s built to answer an auditor’s three questions: what did the agent do, who authorised it (a human, or an agent acting for another agent), and can you prove it? He drew a sharp line between the two: observability is sampled and meant for troubleshooting, while evidence is complete and meant for audit. The platform is meant to work with any agent or harness. On identity he listed OAuth 2.1, token exchange (RFC 8693), ID-JAG/cross-app access and AuthZEN, and it ships as a single licensed binary that installs natively on Kubernetes. More in my Sovereign Trust Plane post.

The FME by Safe Software booth: existing FME workflows exposed as MCP tools through FME Flow’s MCP server.

Sanae Mendoza, FME by Safe Software (she also gave the sponsored session “Beyond the Easy 80%: Bringing Legacy, Spatial, and Locked-Down Data to MCP”). FME is a no-code data integration platform that connects to over 500 data formats. The MCP angle is that you can build your own workflows and deploy them as MCP tools. The company is based in Vancouver, Canada.

Avery Louis (Founding Research Engineer) and Theophile Jegou du Laz, Valency. They’re researchers building tools for researchers: an MCP server that lets any LLM search open-access scientific papers. They only ingest open-access research. Finding papers is the easy part, they said. The work is normalising them across fields with different writing and citation norms, and scoring paper quality so the model reasons over real papers instead of whatever a web search returns. One of them, a former time-domain astronomer, said the literature work behind a paper that had taken months would have taken a day or two with the tool. Both insisted that science should stay people-driven, with humans accountable for what gets published.

Dilip Lukose, Co-founder and CPO of Orkes. Orkes offers the enterprise version of Conductor, the workflow orchestration engine that started as an open source project at Netflix (now Conductor OSS). Workflows can call backend APIs, agents and humans. Compared with Airflow, he said, Airflow focuses on data orchestration, while Conductor is general-purpose: customer onboarding and reconciling finance transactions as well as data pipelines.

Dan, Runpod. Runpod is a GPU cloud: you rent GPUs by the hour, or on enterprise contracts, and can run an open model from Hugging Face in a few clicks. According to Dan, the Blackwell range (B200 and B300) was the most requested at the time.

Two attendees gave me their takeaways too. Marco, a lawyer turned legal AI specialist, builds a swarm of specialised agents for legal work and compared a contract to a mid-sized GitHub repo full of cross-references: change one definition and you have to re-read every clause that depends on it. Olivier described WebMCP as a kind of augmented robots.txt for agents: rather than only allowing or blocking crawlers, a site chooses what to expose to them. With the EU AI Act now applying, he expects companies to need an “AI officer”, the way GDPR created the data protection officer.

My take: the common thread across these booths was control and evidence, not raw capability: gateways that record decisions, frameworks that keep specs honest, workflow engines that survive restarts. That’s the platform layer, and it’s where most enterprise agent projects I see are still thin.

What This Means for Builders

Three takeaways from Day 1 that every team shipping agentic AI should internalize:

1. Agentic AI is not a future technology — it’s a production technology. 81% of teams building agents have them in production. The questions have shifted from “if” to “how reliable.”

2. The open standards stack is winning. MCP at 89% adoption is just the start. The stack of protocols and standards — MCP, Skills, A2A, AGENTS.md — represents a community-driven path to interoperability that no single vendor can own.

3. Oversight isn’t overhead — it’s architecture. 66% of teams are adopting human-on-the-loop patterns. The agentic stack that wins won’t be the one that removes humans, but the one that thoughtfully integrates them.

Coming Up: Day 2

Tomorrow’s agenda includes talks on agentic security, observability, and production deployments. I’ll be back on the floor capturing the key moments.

Announcements & Product Launches

Throughout the event, the Linux Foundation and sponsors announced several key developments:

MCP Graduates to Enterprise Infrastructure

The Model Context Protocol (MCP) is getting its biggest update since launch — introducing a stateless core, new extensions, stronger enterprise authorization, and a formal deprecation policy. MCP co-creator David Soria Parra discussed these changes on Day 1, noting that the protocol’s move to a stateless architecture addresses the scaling concerns that have prevented adoption in enterprise environments.

Envoy AI Gateway Becomes Agent Router, Joins AAIF

Envoy AI Gateway is now Agent Router and is joining the Agentic AI Foundation as a hosted project. Developers connect to models and tools through an OpenAI-compatible API and ready-to-use MCP endpoints, while platform teams manage providers, credentials, quotas, routing, and failover behind the scenes.

Agentic AI Foundation Welcomes 57 New Members

The Foundation announced 57 new members, including major financial services players and APAC leaders. New Gold Members include Alibaba, Visa, and Wells Fargo, with 33 Silver and 21 Associate Members across financial services, enterprise technology, research, and global technology organizations.

A2A Joins the Open Agentic Stack

Agent2Agent (A2A), the open standard for inter-agent communication, is joining the Agentic AI Foundation as a hosted project. This fills a critical gap in the agentic stack — while MCP handles agent-to-tool connectivity, A2A standardizes agent-to-agent communication.

MCPA Certification Launched

The Agentic AI Foundation launched the Model Context Protocol Associate (MCPA) certification — a foundational, vendor-neutral credential validating engineering and platform builders’ understanding of MCP concepts, architecture, and implementation considerations.

Other Sponsor Announcements

Additional product launches from sponsoring companies included:

• Traefik Labs: Sovereign Trust Plane for verifiable AI agent governance
• WSO2: Agent Manager for sovereign AI governance across enterprise agent sprawl
• Grape Up: Aiboostr — an open-source AI governance and orchestration platform with EU AI Act compliance and private LLM support
• Omnys: Joined as Gold Sponsor, showcasing the OMNYS AI Platform with native MCP support
• AgentCat: Launched the first Agent Experience (AX) platform combining agent analytics, goal detection, and session replay

Related Content

• AGNTCon + MCPCon Europe 2026: Day 2 Recap
• AGNTCon PreDay: Agentic AI in the Wild — my recap of the pre-event meetup
• ClickHouse Amsterdam Meetup @ Adyen: AI Agents Meets Real-Time Analytics
• Agentic AI in Enterprise Kubernetes
• OWASP Top 10 for LLM Applications