I attended the “Building Autonomous Systems” meetup and afterparty during KubeCon EU 2026 week in Amsterdam — an evening event near Amstel Station that packed the venue with AI engineers and platform engineers ready to talk about what happens after the demo.
The event was co-organized with talks from LangChain, Qodo, and SurrealDB, with support from AWS. The focus: reliability, guardrails, and the runtime and data foundations you need to ship agentic systems in production.
The Core Questions
The evening explored four themes that define production-ready agentic AI:
- What “production-ready” means for agents: safety, observability, and failure modes
- How platforms should support agent workflows (not just model calls)
- Patterns for separating experimentation from execution (and keeping both fast)
- Building durable agent memory with knowledge graphs — and making retrieval predictable
The Talks
Sandboxed Deep Agents — Daniel Kneipp (LangChain)
Daniel presented LangChain’s approach to running agents in sandboxed environments. When agents can execute code, browse the web, and call APIs, containment becomes critical. The talk covered isolation strategies, execution boundaries, and how to give agents power without giving them the keys to production.
Hidden Failure Modes for AI Agents — Nupur Sharma (Qodo)
Nupur from Qodo dug into the failure modes that do not show up in demos but break agents in production. Beyond the obvious hallucination issues, she covered:
- Agents that appear to work but silently degrade over time
- Context window overflow causing forgotten instructions
- Tool call chains that produce correct intermediate results but wrong final answers
- The gap between evaluation metrics and actual user satisfaction
Building Agent Memory with Knowledge Graphs — SurrealDB
The SurrealDB keynote presented a compelling architecture for durable agent memory using knowledge graphs. The key insight: agents need memory that is structured, queryable, and grows over time — not just vector embeddings stuffed into a database.
The production agent stack they described:
- Knowledge graphs — entities + vectors + weighted edges
- Collection templates — every reasoning step is a traversable node
- Safeguards — measure drift, verify constraints, deterministic by construction
The memorable line from the talk: “The model is the least important part of the stack. The memory is what drives consistency.” Agents need memory, not just models.
LangChain Authorized AI Apps — Sohan (LangChain)
Sohan presented SpiceDB integration for authorized AI applications — a highly parallel, open source graph database optimized for authorization queries. Built as a gRPC and HTTP API service written in Go, SpiceDB answers three fundamental questions:
- Can a subject take an action on a resource?
- List all subjects that can take an action on a resource
- List all resources a subject can take an action on
For teams building multi-tenant AI platforms (a topic close to my heart after my KubeCon talk on multi-tenant GPUs), combining LangChain agents with SpiceDB authorization creates a powerful pattern for secure, scoped AI access.
Panel: Building and Operating AI Systems in Real-World Environments
The evening included a panel discussion bringing together perspectives from all speakers on the practical challenges of deploying AI systems beyond prototypes.
The Qodo Community
Qodo also presented their community programs:
- Free Tier — up to 30 PRs per month completely free
- Free for open-source maintainers — as part of their Google partnership
- Bug Chase Game — hunt bugs, earn points, win prizes
- Super Qodoer — ambassador program for power users
Dana Firi, Open Source and Community Manager at Qodo, drove community engagement throughout the evening.
My Takeaways
The most valuable insight from the evening was the convergence of thinking around agent memory and authorization as first-class concerns. Every speaker, regardless of their company, pointed to the same conclusion: the model layer is increasingly commoditized. The differentiation is in:
- Memory — how agents accumulate and retrieve knowledge
- Authorization — who can do what, enforced at the platform level
- Observability — understanding what agents actually did (not just what they said they did)
- Isolation — sandboxing agent execution to prevent cascading failures
This maps directly to infrastructure decisions. If you are building an AI platform, you need to think about knowledge graph storage, agent orchestration, code quality guardrails, and authorization services as separate, composable layers.
Related Posts
- Qodo at KubeCon EU 2026: AI Code Reviews
- Meet David Parry: AI Code Reviews at KubeCon
- KubeCon Europe 2026 Side Events Guide
- AI on Kubernetes: Agentic AI Architecture Decisions
- OpenClaw Hackathon at AI House Amsterdam
About the Author
I am Luca Berton, AI and Cloud Advisor. I help enterprises build production-ready AI agent platforms with proper authorization, observability, and memory architectures. Book a consultation.
