AGNTCon + MCPCon Europe 2026

As AI agents move into production, engineering teams face a growing set of challenges. How do you secure and govern MCP servers without modifying them? Route and fail over across multiple LLM providers? Enforce rate limits, access controls, and governance policies? Observe agent traffic, and scale operations across environments?

Rather than embedding these capabilities into every agent, MCP server, and application, organizations can adopt a single architectural pattern: the agent gateway.

An agent gateway acts as a unified control plane for AI systems. It can function as an MCP gateway, LLM gateway, inference gateway, and traditional API gateway, centralizing security, observability, routing, resilience, and policy enforcement across agents, tools, models, and services.

In this hands-on workshop, you'll learn how to secure and federate MCP servers without code changes, route and fail over LLM traffic across providers, enforce authentication and usage policies, and gain end-to-end visibility into agent interactions. Through practical exercises, you'll see how a single gateway layer simplifies operations while enabling secure, scalable, and governable AI systems.

AI coding agents feel like magic. It is easy to assume there is something exotic inside, some secret sauce that makes agents reliable. Well, there isn't, the core of every AI coding agent is dead simple: send a message to a model, parse tool calls, execute them, feed the results back, repeat. Everything else (context management, permissions, observability, safety guardrails) is engineering layered on top of it that we should be building.

In this deep dive, we build that engine from scratch (in Java!), live on stage. Not to build the best agent, but to understand how the pieces fit together. We point it at a real codebase, and watch what happens. It compiles. Tests pass. And it violates every convention the team agreed on. So we iterate. We add context, constraints, and feedback, and at each step we examine what changed, why it helped, and what it maps to in the tools you already use.

The goal is a mental model. By the end, you will understand the components inside the AI coding tools you use every day, what you can layer on top to get smoother results and safer expectations, and where the honest limits still are, the gap no amount of engineering has closed yet.

LLM agents are reaching production faster than teams can evaluate them. A data-analysis agent that runs the right query but reports the wrong number, or returns the right number via a trajectory full of fabricated tool calls, passes superficial testing and fails in production.

This talk walks through evaluating such an agent end-to-end. Our running example: a data-analysis agent answering questions over a business dataset. We show how to grade three dimensions that agent evaluation requires and single-shot LLM evaluation ignores: final response, trajectory, and state changes.

We cover the full lifecycle:

1. Bootstrapping evaluation from 50 hand-reviewed examples when you have no labels.
2. Aligning an LLM-as-a-judge to human judgment with the same rigor you'd apply to outsourced annotators: dev/test splits, inter-rater agreement, Cohen's kappa.
3. Scaling to continuous online evaluation with CI integration, error analysis, and prompt optimization driven by natural-language feedback.

We also cover what we got wrong in earlier iterations and what we'd do differently today.

Most teams shipping agents into production hit the same wall. The build is fast. The adoption is not. A solution that works in three weeks can take three months before operators trust it enough to actually use.

This talk is about closing that gap. Drawing on production deployments across fifteen-plus enterprise clients in logistics, wholesale, manufacturing, insurance, and finance, I'll walk through a four-stage model for moving agents from advisory to full autonomy without breaking trust along the way.

The talk goes deep on a single use case deployed across multiple clients: sales order processing. I'll cover what changed when we moved too quickly between stages and lost trust we had already earned, how we rebuilt it, and the operator-side patterns we now look for before progressing a stage.

The framework is protocol-agnostic. Whether teams are integrating agents through MCP, APIs, or a mix, the trust progression is the same. The talk should be useful for anyone building or deploying agent systems where humans remain in the loop and where adoption, not capability, is the binding constraint on impact.