Enterprise-Ready AI Agents: Architecting the Agent Mesh with Open Source
One agent is a demo. A fleet of them is an infrastructure problem, and the one most organisations are about to walk into without a plan. This workshop is about the architecture that makes agents safe to operate at scale, built entirely on open-source components you can run on-prem or on any cloud. No vendor lock-in.
We'll spend the day on the patterns and trade-offs that decide whether agents become a strategic capability or a compliance liability: the Agent Mesh: a gateway, a registry, and a runtime that do for agent fleets what Istio and Kubernetes did for microservices. Security, observability, and agent identity are not bolted on at the end; they sit at the center of the architecture.
The format is concept-first with short, guided exercises to make the ideas concrete. Engineers will get their hands dirty; architects and decision-makers can follow the through-line without writing a line of code.
This is a working session for people who already suspect that "just ship the agent" won't survive contact with production. We treat agents as a distributed-systems problem first and a model problem second, and we build up the architecture in the same order you'd actually have to defend it: what the thing is, where it lives, how it's secured, and how you prove it behaved. Every pattern shown is backed by an open-source component you can run yourself; the goal is for you to leave with an architecture you could whiteboard for your own team on Monday.
By the end of the day you will be able to…
- Explain where complexity lives in a modern agent system, and what scales poorly
- Architect an Agent Mesh: gateway, registry, runtime, and what each one solves
- Design agent IAM with per-agent identity, mTLS, and policy at the traffic layer
- Apply guardrails and observability strategies that surface regressions early
- Evaluate open-source components against the lock-in risk of managed alternatives
- Make a defensible build-vs-adopt case to your own organisation
The day is structured in four blocks, each pairing a concept session with a short, optional exercise:
- What a Production Agent Actually Is: an LLM in a loop calling tools, and the harness around it. We pin down the minimum viable architecture, then expose the gaps a single-agent prototype hides: context handling, tool governance, failure modes. The shortlist of problems the rest of the day exists to solve.
- The Agent Mesh: Gateway, Registry, Runtime: the architectural centrepiece. The parallel to the service mesh, the three pillars, and why agent fleets need them. Walkthrough of the open-source reference stack:
agentgateway(Linux Foundation) andkagent(CNCF Sandbox). What lives where, and which problems each pillar owns. - Security & Identity for Agent Fleets: agent IAM as a first-class concern. Per-agent identity instead of shared API keys, mTLS between components, scoped credentials, central quotas, prompt-injection defence, tool-call policy. Guardrails as gateway middleware rather than per-feature code.
- Observability, Evaluation & Reliability: OTel traces across prompts, tool calls, and agent hops. Evaluation gates in CI to catch regressions before they ship. Cost control at the gateway. How to prove what an agent did, with which model, on whose behalf; the question regulators and incident reviews both ask.
Multi-agent patterns (planning, sub-agents, orchestrator/worker) and the Google ADK framework appear throughout the day as the concrete examples for the exercises, not as a block of their own. The same goes for context engineering, the discipline that replaced prompt engineering, integrated into Block 1 and revisited where it matters, rather than treated as a standalone topic.
Key Topics
- The agent harness and the minimum architecture for production
- The Agent Mesh: gateway, registry, runtime, portable across clouds
- Agent IAM: per-agent identity, mTLS, scoped credentials, no shared API keys
- Guardrails: input/output validation, tool-call policy, prompt-injection defence
- Observability: OTel traces across prompts, tool calls, and agent hops
- Reliability: evaluation in CI, regression gates, central cost and quota control
- Context engineering, applied throughout, not relegated to a single block
- Build-vs-adopt: open-source mesh components against managed-platform lock-in
Who Should Attend
- Architects and platform leads evaluating how to host agents safely
- Security, SRE, and compliance teams responsible for AI workloads
- Engineers building LLM-powered systems beyond the prototype
- Technical decision-makers weighing build, adopt, and lock-in trade-offs
Prerequisites
- A working understanding of LLMs and tool calling (helpful, not required)
- No prior agent-framework experience needed
Stack you'll see: Google ADK, MCP, agentgateway, kagent, Guardrails AI.
All open source. Runs on-prem, on any cloud you happen to have a cluster on.
Flurin is a Senior AI Engineer at Open Systems, where he builds and operates agentic systems in production. His work focuses on the unglamorous half of AI engineering: observability, evaluation, and the infrastructure that turns a promising prototype into something a security team will sign off on. He works extensively with Google ADK, MCP, Agent Skills, and OpenTelemetry.