Event Schedule
A full day of cloud content across our session rooms. Filter by track to find sessions that match your interests.
Registration
Keynote
Morning Tea
A Very Brief History of AI: How AWS Fueled the Evolution of Language Models
To understand the future of AI, you have to understand its past. Join us for a whirlwind tour of AI, tracing the journey from early breakthroughs to the massive frontier models of today. While the headlines focus on the models themselves, the real story of AI is a story of algorithms, data, compute, and scale. In this session, we will look under the hood of this revolution to explore how Amazon and AWS quietly built the scaffolding for modern LLMs, touching on everything from the early days of human data loops with Amazon's Mechanical Turk, to the industrialisation of machine learning via SageMaker, and finally to Bedrock and custom silicon powering the future.
Operating the Agent: SRE Best Practices for Autonomous AI in Production
Everyone at this conference is building agents. Almost nobody is operating them. There are no readiness probes, no error budgets, and no runbooks. When your agent starts looping at 3 AM and burning through tokens, there is absolutely nothing between it and a massive surprise bill except your sleep schedule. I put Amazon Bedrock agents in production for incident triage. During month one, they caused three distinct incidents they were supposed to be fixing. This did not happen because the model itself was bad. It happened because I had zero visibility into what it was actually doing and no safety valve to stop it when things went wrong. So I built the control plane instead. This session walks through the framework we implemented to regain control. We started with four essential Service Level Indicators: decision latency at p99 via Strands tracing, tool success rate to track the percentage of valid results, guardrail trigger rates from Bedrock Guardrails, and cost per invocation tracked as a clear distribution. We then backed this up with a simple circuit breaker. A CloudWatch alarm monitors the tool success rate, routes through EventBridge, and triggers a Lambda function to immediately disable the agent endpoint. It took a single afternoon to build and has already saved us twice. Finally, we established a clear runbook: when an agent alert fires, check the tool success rate first. If it drops below 80%, the upstream tool is broken. You do not restart the agent or blame the model. You fix the tool. Over six months of running this operational framework, we achieved zero agent-caused incidents. Better yet, 73% of P3 and P4 incidents are now auto-triaged without human involvement, bringing the cost down to just $0.41 per triage. Tools like AgentCore Online Evaluation can tell you that an agent is degrading, but this control plane tells you exactly when and why it is happening, and stops the damage before anyone wakes up.
One Engineer, One Agent: Re-architecting a Big Data IoT Platform with Kiro
A single DevOps engineer, an AI agent, and a big data / IoT platform that needed re-architecting from the ground up. This talk is a first-hand account of doing that work with Kiro on AWS - EKS, S3, ElastiCache and friends - and an honest look at what it cost. You'll see where AI genuinely collapsed weeks into days, and where it confidently failed. Expect concrete before/after diagrams, the review practices that caught the bad output, and the moments where slowing down mattered more than shipping.
From Plumbing to Production: Real-World Lessons with Bedrock AgentCore
Building a prototype agent feels like simple script logic, until you realise you’re actually orchestrating an autonomous, non-deterministic distributed system. In this 10-minute lightning talk, we look beyond the "happy path" of the new Amazon Bedrock AgentCore workshop. We’ll dissect how AgentCore handles the critical baseline plumbing (MCP gateways, ephemeral runtimes, identity brokers, and memory abstractions) and where traditional distributed systems engineering must take over: handling tool timeouts, idempotency, loop circuit breakers, and state consistency. You’ll walk away with a clear architectural lens on what AWS manages for you versus the real-world operational patterns you still need to build to survive in production.
C3: The AI Agent That Survived Audit Season (So You Don’t)
Compliance work isn’t a once-a-year event—it’s something teams live with continuously. It often means chasing evidence across accounts, interpreting policies, and trying to keep up with constant change. In this session, we introduce C3, an AI agent built on AWS that helps automate this ongoing effort. It reads compliance policies, evaluates cloud environments across multiple accounts, and generates audit-ready reports in minutes. We’ll walk through how it’s built, including policy interpretation and evaluation pipelines, and discuss where it struggles in practice. You’ll leave with practical patterns for turning compliance into a continuous, automated workflow that developers can work with.
Securing Serverless Enterprises Against Agentic AI Threats
As enterprises rapidly adopt serverless computing and integrate agentic artificial intelligence (AI) into their cloud-native systems, new dimensions of risk emerge. This session explores the complex interplay between AI technologies and serverless architectures, examining how AI both strengthens and undermines security in these environments. Through case studies, vulnerability analysis, and proposed mitigation frameworks, identify specific AI-induced threats to serverless systems, evaluate current defense mechanisms, and propose practical strategies for securing enterprise deployments.
Lunch & Networking
AWS Lambda MicroVMs: What They're Good For, and What They Aren't
In June 2026, AWS launched Lambda MicroVMs, a new compute primitive that gives each user or session its own dedicated Firecracker VM. Firecracker isn't new, it has powered Lambda since 2018. What's new is Instead of a stateless function on an environment you don't control, you get a VM you define with a Dockerfile, keep alive across a session, and suspend and resume at will. This talk walk through how Lambda MicroVMs actually work: you hand AWS a Dockerfile, it builds and snapshots the VM, and you launch from that snapshot. Each VM gets its own HTTPS endpoint. We will walk through what people have actually built with it since launch and which problems it genuinely solves. Then we will turn to the security side and explore how the service could be abused by an attacker, and what you can do to prevent it.
Three AWS Myths That Are Costing You
Bad advice has a long half-life. A forum post from 2017, a Stack Overflow answer that was correct once, a default setting nobody questioned — and suddenly your architecture is built around a problem that no longer exists. In this lightning talk we bust three persistent AWS myths that developers still get wrong in 2026. Each one is widely believed, demonstrably wrong, and fixable in an afternoon. Walk away with three things to check in your stack this week.
Beyond Chatbots: Building VIVA, a Real-Time Avatar Agent on AWS
Most AI agents still live in chat windows or as disembodied voices. At Versent, we wanted to explore what happens when an agent has a face, a voice and the ability to respond in real time. In this session, we’ll introduce VIVA - Versent’s Intelligent Visual Agent: a browser-based avatar agent built on AWS that can hold a natural voice conversation with lip-synced visual responses. We’ll share the architecture and design decisions behind the experience, including how we approached real-time interaction, voice-to-avatar synchronisation, latency, and making the agent feel more natural than robotic. Attendees will walk away with practical lessons from building a multimodal AI experience on AWS - what worked, what was challenging and what we learned about designing the next generation of conversational agents.
Data Observability Without the Pain: 3 Practical Patterns from a Production IoT Platform
Modern IoT platforms are inherently data platforms. Events flow through APIs, queues, AWS Lambda Serverless functions, storage systems, and device networks before becoming meaningful data. When something goes wrong, tracing a single event across these distributed components quickly becomes painful—and the question shifts from _“what happened?”_ to _“where do I even start looking?”_ I’ll walk through three practical observability patterns drawn from building and operating a production, event-driven IoT healthcare platform on AWS that processes tens of thousands of device events daily. Using OpenTelemetry, Amazon Cloudwatch and Honeycomb, we’ll explore techniques for gaining visibility into asynchronous event pipelines, correlating activity across services, and tracing events as they move through distributed systems. Through real troubleshooting examples from production, you’ll see how improved observability makes it dramatically easier to diagnose issues, understand system behaviour, and operate complex event-driven systems with confidence. You’ll leave with three concrete patterns you can apply immediately to your own event-driven data systems.
Sponsor talk from WSO2
Data is being generated everywhere, build a bridge and get over it.
Most of the world's data is unstructured, created at the edge, needed everywhere else. Copying it around doesn't scale, and latency is physics. This session covers how planet-scale file systems solve that: one global namespace, caches you can predict, and metadata that makes storage something you can query.
Document DynamoDB Access Patterns, and Workflows with DNML
Event-driven architectures are now widely used to build scalable, decoupled, and responsive systems. In my work, I’ve seen this success create a quieter problem: hundreds of DynamoDB tables spread across teams and repositories, with critical access patterns documented inconsistently—or known only by the engineers who built them. In this talk, I’ll examine why conventional documentation struggles to keep pace with these systems and introduce DNML as a different way to make DynamoDB designs and their surrounding workflows portable, discoverable, and useful to both engineers and AI agents. I’ll give attendees a repeatable approach for mapping their DynamoDB estate, capturing access patterns, relationships, and workflows, and creating documentation that engineers and AI agents can use to reason about and run systems consistently across environments.
“A Kubestronaut Riding a Dragon”: Scaling Generative AI on EKS
Generative AI is quickly becoming a production workload, but running models like Stable Diffusion XL on EKS introduces challenges around GPUs, scheduling, and performance. In this session, we present a real-world implementation of an AI image generation platform running on Kubernetes. You’ll learn how to containerize, deploy, and scale inference workloads using open-source tools like Diffusers, PyTorch, and Streamlit. We’ll explore GPU vs CPU performance, model loading behavior (~8GB), and cold start impacts, along with how Kubernetes distributes and scales inference workloads. The talk includes a live demo generating images in real time (including “a kubestronaut riding a dragon in space”) and shares practical insights for running generative AI workloads on Kubernetes in any environment.
Afternoon Tea
Shift Left or Get Left Behind: Continuous Security Testing with AWS Continuum
AI-assisted vulnerability discovery is accelerating faster than most teams can keep up. CVE disclosure rates have jumped dramatically, and attackers are finding bugs in codebases that went unnoticed for over a decade. Yet many organisations still treat security validation as a manual, quarterly exercise that happens long after code reaches production. In this session, we explore how to shift security discovery left by embedding continuous penetration-like testing into your CI/CD pipeline. We cover a sample architecture and how it can be centrally managed at the same time adopted by your application teams. We'll also show a live demo on how practically this would work. Whether you are a developer, DevOps engineer, or AppSec practitioner, you will walk away with a practical blueprint for making security validation as routine as running your unit tests.
Mastering Custom Node Pools in EKS Auto Mode
EKS Auto Mode simplifies cluster management, but one size does not fit all. When your applications require specific hardware, strict security controls, or unique networking, the default configuration is often not enough. In this talk, we will break down the gap between managed convenience and the custom requirements of real world production workloads. You will learn the practical differences between NodePools and NodeClasses and discover how to design them for your specific needs. We will show you how to keep the benefits of a managed service while taking full control of your infrastructure. Join this session to gain the confidence to build stable, efficient, and custom Kubernetes environments.
AI Agents Flooded Our PRs. Here's the Harness That Fixed It.
We built an SDLC agent workforce, and the code came faster than we could review it. To solve that, we built a PR agent at the gate: acts on GitHub, comments on PRs, and can block a merge on real failure. The harness demanded real engineering covering idempotency, session continuity, and token economy. The build-vs-buy came down to context richness: design intent, Jira history, cross-repo knowledge that doesn't scale when hand-rolled. The Amazon Bedrock AgentCore ecosystem was the answer. You'll leave with the architectural decisions, including where we went wrong and how we recovered.
The Day We Stopped Paying For Telemetry Noise
Telemetry costs grow exponentially at enterprise scale — and the usual fix, aggressive sampling, risks dropping the errors you actually need to see. At PageUp, we needed a way to cut the noise without losing a single anomalous trace. This session covers how we used Transit Gateway to fan in traffic across regional VPCs, ECS to run a scalable sampling layer, and Redis to coordinate sampling decisions without bottlenecks — together forming a centralised hub-and-spoke architecture for trace-aware sampling at enterprise scale. You'll leave with a practical AWS blueprint for centralising high-volume, multi-region data — plus the strategy that cut our telemetry volume by 75% while keeping 100% of critical errors. Key takeaways: - Hub-and-spoke architecture across VPCs/regions with Transit Gateway - ECS service design & autoscaling for a high-throughput proxy layer - Distributed coordination with Redis — patterns and failure pitfalls - The payoff: 75% volume reduction, 100% critical error retention
One Guardrail, Any Model: Securing an AI-Developed Student Platform with Amazon Bedrock
AI now writes a lot of our code and powers a lot of our features often in the same app, shipped faster than security review can keep up. EduReach is exactly that story: an AI-assisted, rapidly built platform that connects students and teachers, with an LLM answering student questions in real time. It serves minors, handles personal data, and like most AI apps today runs its model outside of AWS. This talk is a practical walkthrough of how we put AWS-native security guardrails around that app without rebuilding it. I'll show how Amazon Bedrock Guardrails can wrap any model including third-party LLMs via the ApplyGuardrail API, and how a layered guardrail policy (content filters, denied topics, prompt-injection and jailbreak defense, PII detection and redaction, and contextual grounding against hallucinations) maps directly to the risks of an app used by students. We'll go beyond the model too: IAM least privilege, Cognito auth, WAF, Secrets Manager, and CloudTrail/CloudWatch for audit the defense-in-depth an AI feature alone doesn't give you. You'll leave with a reference pattern and a checklist you can apply to your own AI app, whether your model lives in Bedrock or not.
Real-Time on AWS: What I Learned the Hard Way with Kinesis & Flink
Real-time data engineering looks simple in a reference diagram and gets hard the moment streaming data is late, out of order, or arriving faster than you can process it. In this session, I share lessons from building a real-time anomaly detection pipeline on AWS using Kinesis for ingest, Managed Service for Apache Flink for stateful processing, and EventBridge for alerting. I'll walk through what actually went wrong: latency budgets, windowing, late-arriving events, and the speed-versus-accuracy tradeoff. You'll leave with a reference architecture and the gotchas to avoid on your own builds.