Hugo Guerrero
Building the Infrastructure for the Agentic Era | AI, MCP, Kubernetes & Cloud Native | Speaker on AI, APIs & AX/DX
Boston, Massachusetts, United States
Actions
Hugo Guerrero helps build the infrastructure for the agentic era. As a technology leader, he focuses on AI and agentic infrastructure, modern API strategy, and scalable cloud-native systems. A frequent speaker and advocate for developer ecosystems, Hugo brings complex architectural ideas to life, helping organizations turn emerging technologies into real-world outcomes. He works at the intersection of connectivity and intelligence, shaping the architecture, strategy, and governance needed to make AI and agentic systems secure, scalable, and ready for production.
Links
Badges
Area of Expertise
Topics
Your Agent Knows What, It Doesn't Know Why: Durable Reasoning Traces for Production AI
When an AI agent fails in production, the hardest question is: where did the reasoning go wrong? Most agentic systems store state — what the agent knows right now — but not the ordered history of how it got there. That gap is the difference between a system you can debug and one you're just hoping works.
This session introduces the durable commit log as the foundational architecture for trustworthy agent systems. Every tool call is a transaction. Every context update is a commit. Every decision is a delta. When you treat the event stream as the source of truth — with vector databases and KV stores as downstream projections — you gain three capabilities that are otherwise expensive to engineer: replay (rewind and re-run agent history), forking (branch from any point to explore alternative reasoning paths), and unified observability (a single trace across the full data path, not three siloed logs).
We'll cover practical implementation patterns, why this logic belongs at the connectivity layer rather than inside the agent framework, and what governed event infrastructure means for compliance in regulated environments.
Solving Context Bloat: Semantic Tool Routing in Multi-Server MCP Environments
As MCP adoption scales beyond a single server, context bloat becomes a critical bottleneck. When agents operate across multiple MCP servers — each exposing dozens of tools — injecting every available tool into the model context inflates the context window, increases latency, raises costs, and degrades reasoning quality. Most current implementations have no answer for this.
This session introduces the MCP Gateway pattern: a semantic routing layer that sits between the agent and its MCP servers. Rather than flooding the model with every registered tool, the gateway dynamically selects and injects only the tools relevant to the current request — using intent classification, embedding-based search, and prompt analysis.
We'll cover why context bloat is a natural byproduct of multi-server deployments, how semantic routing maintains full MCP protocol correctness, and how just-in-time tool discovery keeps the agent loop efficient. Attendees leave with a practical, vendor-neutral blueprint for scaling agentic systems to hundreds of tools without sacrificing performance or reasoning quality.
Responsible AI at Scale: Governance, Ethics, and Compliance in Practice
AI adoption brings tremendous opportunity but also significant responsibility. In this session, we explore practical strategies for responsible AI governance in enterprise environments. Attendees will learn how to audit models, manage bias, enforce compliance, and embed ethical checks throughout the AI lifecycle. We will cover patterns for governing autonomous systems across multiple teams, balancing automation with human oversight, and aligning AI outputs with business and regulatory policies. Real-world examples will illustrate how organizations can innovate with AI while minimizing risk. By the end, participants will understand actionable frameworks for ensuring their AI deployments are ethical, auditable, and compliant, empowering teams to build AI that is both powerful and trustworthy.
Patterns for Bridging Legacy API Catalogs to MCP Resources
One of the biggest challenges to adopting the Model Context Protocol (MCP) is the cold start problem. Most organizations already operate large, well-defined API ecosystems built on REST and GraphQL, yet very few have native MCP servers. Rewriting or duplicating these services is unrealistic and slows down experimentation with agent-based systems.
This session presents patterns and tooling for bridging existing API catalogs into MCP without rewriting backend services. We introduce the “Synthesis Pattern,” an approach for translating OpenAPI and GraphQL into MCP tools and resources. Rather than treating MCP as a replacement layer, this approach treats it as an adaptive interface on top of existing infrastructure.
The talk dives into practical implementation details, including how to map HTTP semantics and schema contracts into MCP tool lifecycles, how to build a context-aware proxy that enriches API calls with semantic metadata for agents, and how to expose large API catalogs safely.
By focusing on open source implementations and extensible reference architectures, this session shows how developers can make MCP immediately useful.
From Prompt Hacking to Architectural Determinism: Engineering Reliable GenAI Systems
As generative AI moves from experimentation to production, prompt engineering has become a bottleneck. Adding constraints and detail to prompts provides short-term consistency but doesn't scale — prompts drift, edge cases multiply, and reliability suffers. The industry needs to move beyond treating prompts as configuration files.
This session argues for architectural determinism: transitioning AI agents from probabilistic improvisers into disciplined routers that execute deterministic, validated artifacts. We present a systematic framework for capturing and hardening successful agent behavior through four mechanisms: human-in-the-loop governance that evolves oversight into a reliability catalyst; capturing reasoning paths and mapping dependencies into structured blueprints; codifying validated workflows into executable rules that eliminate hallucinations; and building an agent skill store — a centralized library of proven solutions that let agents solve recurring problems with procedural precision rather than speculative generation.
By shifting focus from linguistic hacks to system architecture, teams can build GenAI systems that are scalable, auditable, and genuinely trustworthy.
Event-Driven AI: Why Your Agents Should Be Asynchronous
The shift from chatbots to autonomous agents is reshaping how applications handle long-running tasks — and exposing a fundamental mismatch. Triggering an agent via a synchronous API call leads to timeouts, dropped connections, and poor user experience. Unlike simple request-response interactions, agents think, plan, and execute across multiple steps — and that requires an architecture built for asynchronous operation.
This session introduces the Event-Driven Agent pattern: treating AI as an asynchronous participant in your system rather than a synchronous endpoint. We'll show how event-driven design enables complex, multi-step workflows that are resilient, observable, and scalable, covering patterns from simple observer implementations to full orchestration of agents alongside microservices.
Topics include designing agents that listen to system events and emit results back into the stream, managing long-running agent state across asynchronous steps, and tracing a single user request as it moves between multiple agents and traditional services.
Delivering Self-Service AI with Built-In Guardrails and Governance
As AI adoption accelerates, platform engineering teams face new challenges in governing how developers build and consume AI capabilities. This session explores how to design intelligent developer experiences that embed AI responsibly, combining productivity with strong governance. We'll cover how to enable self-service deployment of AI-infused applications while enforcing controls through CNCF projects like OPA/Gatekeeper for policy enforcement, Kyverno for workload validation, and OpenTelemetry for auditing AI interactions. Learn how to expose AI inference as a managed service within your internal developer platform using tools like KServe or Kubeflow, with built-in gateways and guardrails for access control, usage quotas, and monitoring. We'll share patterns to track model usage, ensure data compliance, and prevent shadow AI by aligning platform workflows with enterprise governance standards—empowering developers without compromising trust, transparency, or security
Building the Control Plane for Multi-Agent AI Systems on Kubernetes
AI agents introduce a new generation of distributed systems challenges for platform teams. Moving beyond prototypes requires managing complex interactions across models, MCP servers, and event streams while maintaining security, governance, and cost control.
Co-presented by Red Hat and Kong, this session explores cloud-native patterns for operating autonomous agentic workloads at scale. We examine how open-source projects—including Kubernetes, Knative, Envoy, KServe, and Model Context Protocol (MCP) implementations—establish a robust control plane for AI.
Attendees will learn how AI gateways, MCP gateways, and intelligent LLM routing layers enable policy enforcement, smart model selection, and traffic management. We’ll share a reference architecture demonstrating how to deploy resilient agent swarms across multiple LLM providers using open standards.
Building Reliable AI Agent Memory with Event Streams on Kubernetes
Vector databases excel at retrieval, but they can't provide complete history, explain causality, or show how knowledge evolved—critical gaps that lead to agent hallucinations and unreliable reasoning.
We'll introduce the Durable Memory Stack, an event-driven architecture where Kafka's commit log becomes the source of truth for agent memory and Knative Eventing orchestrates workloads. The key innovation is Change Context Capture—a pattern that extends CDC to preserve not just updates, but the reasoning behind them.
Using Kafka, Knative, Debezium, and OpenTelemetry, we'll demonstrate:
Replaying agent decisions to debug failures in production
Continuous RAG synchronization through events
Giving agents access to how and why information changed
Learn how cloud-native event-driven patterns unlock more reliable and intelligible AI agents on Kubernetes.
Bringing Order to GenAI : Gateways, Guardrails, and Governance
Deploying GenAI models is easy—governance, cost control, and scale are the hard parts. If you're a platform engineer, API architect, or developer enabling AI in Kubernetes, you’ve likely hit issues like authentication, rate limits, PII redaction, traffic routing, and usage tracking. These are API problems, and the solution is an AI Gateway.
In this session, we’ll explore how AI Gateways act as policy and control layers for LLMs and inference workloads. Using CNCF tools like KServe, Envoy, Kuma, Dapr, OPA, Prometheus, and Backstage, we’ll show how to manage model access, enforce rules, expose internal AI APIs safely, and enable developer self-service.
You'll walk away with patterns and practices that help you scale AI responsibly, without reinventing the wheel
AI Governance: Lessons from API Management and the Role of AI Gateways
As organizations adopt AI to enhance digital experiences, robust governance is critical. Unchecked AI usage can lead to security risks, compliance issues, and unpredictable costs—challenges similar to API management. This session explores how proven API patterns can govern AI effectively, ensuring observability, security, and policy enforcement at scale.
We introduce the AI Gateway—a control plane for AI interactions that enables rate limiting, authentication, policy enforcement, and cost control. By leveraging insights from API gateways and service meshes, we show how to enforce responsible AI usage while maximizing innovation.
Learn how to implement AI governance with cloud-native tooling and future-proof your AI strategy in a Kubernetes-powered world.
AI at the Gateway: Scaling, Securing, and Orchestrating Agentic AI
Integrating LLMs into production is easy for a demo, but scaling them for thousands of concurrent users reveals a harsh reality: they are high-latency, expensive, and fundamentally non-deterministic. Traditional API Gateways weren't built for 60-second request times or "hallucinating" status codes.
In this session, we move beyond basic API calls to explore the AI Gateway Pattern. We will dive into how to build a resilient orchestration layer that treats AI models as unreliable downstream dependencies rather than standard microservices. You will see how to implement "semantic caching" to save costs, handle token-based rate limiting, and use circuit breakers to failover between disparate models (e.g., from GPT-4 to a local Llama instance).
We will walk through the transition from synchronous "Request/Response" to Event-Driven AI orchestration, ensuring your architecture remains responsive even when the model is slow. This is a session about the "plumbing" of AI—security, observability, and stability—designed for engineers who need to move AI from a playground to a production-grade system.
Hugo Guerrero
Building the Infrastructure for the Agentic Era | AI, MCP, Kubernetes & Cloud Native | Speaker on AI, APIs & AX/DX
Boston, Massachusetts, United States
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top