OSS + ELC EU 2026

AI systems need more than intelligence; they need context. Without it, even the most advanced models can misinterpret information, lose track of details, or arrive at conclusions that don’t hold up. Context engineering is emerging as a discipline that shapes how AI perceives, recalls, and reasons about information.

This talk will explore how context provides the foundation for reasoning, problem solving, and explainability in AI. We will look at techniques such as connected memory, contextual retrieval, and graph-based knowledge representation that give large language models a more reliable way to connect information and draw logical conclusions.

Attendees will come away with a practical understanding of how to design effective context pipelines that align AI with real-world knowledge and user intent, and why context engineering is becoming a central part of building trustworthy and impactful AI systems.

AI agents are fast becoming how modern software gets built. But taking one from prototype to safe, production-grade operation is still genuinely challenging, and how they behave at scale remains largely uncharted. Agents are stochastic, so testing becomes continuous evaluation. They run code nobody wrote, so a shared kernel stops being a boundary you can trust. They decide their own network calls at runtime, so egress is no longer predictable. And they still need what any service needs: source control, CI/CD, observability, memory, and tool access.

This session walks the full lifecycle of running agents on Kubernetes, open source the whole way. The "outer loop" (build, deploy, trace, evaluate) runs on tools like GitLab, Argo, Langfuse, Milvus, and MCP gateways. The "inner loop" (isolated execution) runs on the kubernetes-sigs Agent Sandbox CRD, gVisor, and FQDN-aware egress via Cilium. We'll show what maps cleanly from the platform you run, what changes for agents, and the production gotchas no quickstart warns you about, drawn from building these in the open with teams running from a handful of developer sandboxes to the hundreds of thousands that frontier-scale RL spins up.

As AI systems move from experimentation to production, engineering teams face a growing number of infrastructure decisions. How do you secure MCP servers without modifying them? How do you seamlessly transition and fail over across multiple LLM providers? How do you enforce token rate limits and usage policies for LLMs? How do you govern agent-to-agent and agent-to-MCP communication, control context growth, enforce security policies, observe traffic, and scale operations across environments?

Rather than solving each challenge independently, organizations can adopt a single architectural pattern: the agent gateway.

Through live demos, Lin introduces the agent gateway pattern and demonstrates how it simplifies AI infrastructure by eliminating the need for teams to repeatedly solve the same cross-cutting concerns. Using agentgateway, an open-source implementation of the pattern, she will show how to secure and federate MCP servers without modifying them, route, fail over, and rate limit LLM traffic across providers, enable advanced capabilities such as code mode and progressive disclosure, and operationalize AI workloads on Kubernetes.

AI agents fail in production because they're overwhelmed with data but starved for context. LLM models aren’t the problem. The bottleneck is the data stack: fragmented silos, inconsistent definitions, and logic hidden in tribal knowledge. Agents need structured, reliable, and interpretable context—not just data access.

In this session, we'll show how Apache Iceberg becomes the backbone of AI-ready pipelines. You’ll learn how to elevate your Iceberg implementation from a storage format to a live context layer that powers structured retrieval-augmented generation (RAG), schema-aware agents, and autonomous reasoning grounded in truth.

What we’ll cover:
1. Iceberg Foundations for AI - from ACID to Time Travel
2. From Rows to Relationships - The role of the semantic layer
3. Structured RAG in Practice - Fully open source

The session includes a live demo of a fully open-source Structured RAG stack built on Apache Iceberg, featuring semantic query translation, hybrid retrieval, and governed agent reasoning. Expect architecture diagrams, real code, and practical guidance.

AI agents are evolving from simple chatbots to coordinated systems that plan, collaborate, and execute real-world tasks. But moving from a working prototype to a production-grade multi-agent system is where most teams struggle.

In this session, two practitioners share battle-tested patterns from deploying agent swarms in industrial environments. We cover:
The architectural shift from single-agent to multi-agent: when and why you need a swarm
Comparing open source frameworks (LangChain, AutoGen, Strands Agents SDK) — strengths, trade-offs, and selection criteria
Practical orchestration patterns: task delegation, shared memory, tool coordination via MCP (Model Context Protocol)
Live demo: building a multi-agent system that collaborates to solve a real task
Safety-first design: guardrails, execution boundaries, and observability for production
Attendees will leave with a reusable architectural blueprint applicable to any open source agent framework.

On April 24, 2026, an AI coding agent deleted a company's entire production database in nine seconds. Every customer record, every reservation, and every backup vanished. The system prompt explicitly told the agent never to execute destructive commands. It did it anyway.

It was a chain of architectural failures: an agent improvising instead of stopping, overprivileged credentials, no human approval for high-risk actions, and backups inside the same blast radius.

This session recreates the incident and rebuilds the security architecture live. You'll see how OPA enforces policy before tools execute, Falco detects suspicious runtime behavior, and OpenTelemetry captures structured reasoning traces for compliance-grade audit logs.

We'll implement six defensive layers: pre-execution policy enforcement, runtime behavioral monitoring, structured audit logging, least-privilege execution roles, infrastructure deletion protection, and recovery systems isolated outside the agent trust boundary.

Prompts are guidance. Infrastructure is enforcement. You'll leave with a vendor-neutral security architecture for deploying AI agents safely across any framework or LLM provider.