Sessions

Agentic development environments need a lot of things - the project, agent harnesses, vector stores, compile tools, and more. And on top of that, it needs to be a trusted and safe environment in case an agent goes off-script. But, how? This talk will dive deep on how to create and customize the sandbox environments for your agent, from the simple to the very complex. You'll also learn how to version control and share the environment through your codebase, ensuring everyone on your team has consistency in both environments and trust. The best part? It's not as hard as you think!

Join me to get up to speed to the right-now in the brave new world of Generative AI for an accessible Zero to... Hero (in training) and look beyond the story the major cloud vendors promote. In four segments we aim to grasp the current state of Generative AI from a hands-on perspective with an independent mindset. Segment 1: Foundations - Concepts and APIs. Together we are tracing the steps on the journey to today's models and how to interact with them. You will learn about the lifecycle of a model from "pre-training" to the models that you finally get to interact with including what's in the model or what's rather an abstracted away PaaS offering on top and what building blocks you work with in the APIs and SDKs Segment 2: Integrating AI Focusing on how to enable your applications, we are looking at the various concepts such as embedding vectors, RAG, tool-calls, skills, plugins, frameworks, to help with that. We will discuss engineering context, how to work with larger documents and content sources to make them accessible by AI models with a mix of technologies. Segment 3: The world of agents Starting with very simple agents, we will effectively leverage AI in an agentic world, meaning, how to have agents do work for you, up to deploying larger teams of agents on complex tasks. This segment description is intentional vague as there is rapid innovation in this space. Segment 4: Local AI, media content, and AI beyond the Western corporate world You may prefer to run AI locally on your own devices. Utilizing tools such as ollama, LM Studio, Azure AI Foundry Local, and other alternatives, we aim to make them accessible to your apps. We explore the wild model zoo that becomes available by going beyond the big cloud vendors including generating images, video, speech, music, more. Some extra attention is awarded to tools from Chinese AI labs and how you can mix-and-match different capabilities for interesting workflows.

At many companies right now, the directive is coming from the top: "We need AI in our product." CTOs hear it from boards. Product leaders hear it from executives. Engineering teams hear it from everyone. In this full-day, hands-on masterclass, you'll learn how to build 10 AI features that deliver real value by automating the work your users aren't good at or don't want to do. We'll build things like semantic search that finds results based on meaning instead of keywords, RAG that answers questions over your own content, and extraction that turns messy input into clean structured data. We'll do summarization that cuts long content down to something manageable, classification and routing that triages work on its own, and sentiment detection that tells you when a specialized model beats a general one. You'll see implementation patterns where a human stays in the loop, anomaly detection that surfaces issues, and recommendations that suggest the next right step. And we'll finish with agentic workflows, where a plain-language request becomes a real sequence of actions your app carries out. Most importantly, we'll explore how the real question isn't "where can we add AI?" but "what problems can AI best solve for my users?" You'll leave with practical examples and hands-on experience of where AI might belong in your product and insight into how to explain those decisions to leadership. No prior AI or ML experience is required. Basic software development experience is recommended.

In this hands-on, full-day workshop, we'll take a bold app concept and ship it together — from blank slate to running application — using today's agentic AI tooling (Claude Code, Codex, and peers). You'll see how to move from idea to product plan, set up a database, build a NestJS backend, and deliver a React frontend, all driven by AI agents rather than manual coding. No slides, no theory overload - just real development with real tools. We'll work with skills, rules, sub-agents, and multi-agent workflows to move fast, stay focused, and skip the tedious parts. You'll leave with a working app and a practical mental model for how agentic development changes the way software actually gets built. By the end of the day, working with AI won't feel like a novelty - it'll feel like your new default. Let's build something cool (and maybe blow your mind a little).

Modern AI agents are useful because they take real actions in the real world and on your machine: read files, run commands, hit the web, build containers, write and publish code. That capability is also where the risk lives. This hands-on workshop walks through the Docker AI primitives (sandboxes, network policy, MCP, hardened images, sbx kits, and multi-agent orchestration with Docker Agent) that make it practical to give an agent real capability without giving it unbounded reach. You'll spin up your first Docker Sandbox, prove its isolation guarantees with hands-on tests, govern its outbound network, attach real tools via MCP, harden the containers it ships, package the whole setup as a reusable kit, and finally compose a small multi-agent team where per-role tool scoping is enforced at the runtime. You'll leave with a working mental model of scoped autonomy and a running sandbox stack on your machine that you can keep experimenting with.

Ever feel uncomfortable about sharing too much personal info with ChatGPT/Gemini/Claude but still want AI’s help? Against giving Big Tech your private life on a golden platter running on wasteful resource-sucking data centers? A bit confused about some of the jargon and words used in news articles about the next most powerful AI models coming out? This workshop is for you! ​Earlier this year there was a breakthrough - we can now run AI that are more than capable of being private and even completely offline assistants on personal computers and laptops! ​This is also a workshop for AI beginners who find setting up agents with OpenClaw too intimidating but still want a capable AI experience like ChatGPT that keeps all private information on their own computers - without writing any code or running any terminal/command line commands! ​What we'll cover: ​Setting up Unsloth Desktop (open source ChatGPT-like interface) and running powerful open source AI models of your choosing on your own computer. ​Learning important concepts about running AI on your own computer - from why open source AI exists to tokens, context, model quantization, MCP tool servers, and more. ​Answering your questions to make sure you're confident discussing AI model concepts and the major news developments that are shaking the world. ​This is a hands-on workshop - bring your computer and get ready to download and install some AI! ​System Requirements: The more RAM your computer has, the better. It’s now possible to run near-frontier-capable-AI on computers with just 16GB of RAM. That said, even if your computer has less than that (like 8GB), you can run less powerful AI that is still impressive and are welcome to attend! ​To be efficient, we encourage participants to download and install Unsloth Desktop (https://unsloth.ai/docs/desktop) as well as let it automatically download a suitable AI model it selects for you (if any) when first running the app in advance before coming to the event. During the event, you’ll learn how to find even better AI models to add to your Unsloth Desktop setup.

Every production agent today is renting its intelligence. You're paying per token, sending your customer's data to someone else's servers, and hoping the provider doesn't rate-limit you during your launch. For most teams, that's fine. But for a growing number of teams in regulated industries, with high-volume products, latency-sensitive workloads, or rising token bills, it's starting to look like a liability. In this 120-minute hands-on workshop you'll get a dedicated GPU and build an agent that runs on infrastructure you control. You'll stand up vLLM, point your agent at it, and drive concurrent load through the stack until you can see batching, KV cache pressure, and throughput limits in the metrics. Then you'll optimize the deployment to improve throughput while keeping per-request latency in line. The focus isn't agent frameworks. It's the inference layer underneath them. You'll leave with working code and a real understanding of continuous batching under real concurrency, KV cache tradeoffs, vLLM's metrics, and the bottlenecks that only show up when you operate the inference server yourself.

This hands-on workshop covers the primary orchestration patterns in ADK 2: graph workflows, collaborative agent teams, and dynamic (LLM-shaped) workflows. You will learn to construct architectures that combine parallel fan-out with join nodes, deterministic code-level routers that branch without extra model calls, collaborative supervisor-specialist teams executing dynamic parallel subsets, and recursive execution flows. You will conclude with a decision matrix for selecting and composing these patterns. - Identify the correct orchestration pattern based on structural problem constraints. - Construct graph-based, collaborative, and dynamic workflows using ADK 2 primitives. - Reduce latency and token consumption by offloading branching decisions from the model to code-level logic.

Most developers use Docker to package and ship an app, and that answer was complete five years ago. The toolchain has grown a lot. This talk walks through a normal working day and shows where the newer pieces fit. - Docker Sandboxes provide a trust boundary around your agents, protecting your filesystem, network access, and credentials. - Gordon, Docker's built-in AI agent, sits right in the CLI and Desktop, ask it questions about your images, containers, best practices, and let it run the actions for you. - Testcontainers put a real database inside your test suite so you can stop maintaining mocks or using shared infrastructure. - Your base images can arrive already patched with Docker Hardened Images. - Docker Scout helps you know what's in your images and even run policy evaluations to ensure your images meet the mark. Everything in the talk is free to use, and most of it is already installed as part of your existing Docker setup.

Most conversations about agents end at the model and the prompt, yet the real work happens lower in the stack, in the environment where code runs and tools get invoked. This talk maps out what that layer needs to provide for an agent to do real work safely, then shows a working stack built on those ideas.

We’re finally at a point with coding where we can truly work on multiple tasks at once - and actually have it be an enjoyable and manageable experience! I’ll demonstrate how I split my work across multiple surfaces: the VS Code IDE when I need to be the most hands-on, the GitHub Copilot desktop app for tasks that require light supervision, and cloud agents for routine maintenance. I’ll share my tips for enabling truly parallel development of full-stack web applications thanks to git worktrees and smart environment variable management. Plus, I’ll share my favorite automation workflows that run while I’m asleep, saving me time so that I can focus on the fun parts of software development.

Session details will be announced soon.

Modern AI development adds a new layer of complexity to the development environment: agent harnesses, agent-specific developer tooling, MCP servers, external services, credentials, and more. And every team has different requirements. How do you give developers and agents the tools they need while keeping environments consistent, reproducible, and secure? In this hands-on session, you'll start with Docker Sandboxes and then go deeper into customizing and sharing sandbox-based development environments. You'll create sbx kits to tailor the tools and configuration available inside a sandbox, connect to external services—including those that require secure credential injection—and package those customizations for reuse. You'll then use sbxenv, which brings a Docker Compose-like experience to sandboxes, to define an entire development environment as configuration. By the end, you'll have an environment that can be shared with your team and started with a single command—giving every developer and agent a consistent, ready-to-use workspace.

We've taught LangChain and LangGraph multi-agent workshops at Grace Hopper two years running to 200+ developers each time. The number one question we get after every session: "This works in a demo — but how do I get past the walls when I try to scale it?" We know those walls firsthand. We've built agentic AI systems across POCs and production in global banking — and between us, we've hit every failure mode: agents losing context mid-task, orchestration logic that doesn't survive real workloads, and delegation patterns that look clean on a whiteboard but collapse under pressure. DeepAgents is a new LangChain framework built to solve exactly these problems — intelligent delegation, advanced planning, robust context preservation, and error recovery designed for production-grade workflows. In this 120-minute hands-on workshop, we'll build a real multi-agent system together in GitHub Codespaces — no setup, no installs, just code. Through guided labs, you'll architect a coordinator that delegates research to one agent, analysis to another, and synthesis to a third. You'll implement human-in-the-loop approval gates, long-term memory, and the error recovery patterns that separate prototypes from systems that survive production. We'll be honest about what's battle-tested and what's cutting-edge — because that's the conversation practitioners actually need. What you'll walk away with: a portfolio-ready multi-agent system you built yourself, production skills across backends, subagents, coordinators, memory, and debugging, a complete code repository with reusable templates and documentation you can extend immediately, and the framework decision-making to know when LangChain chains, LangGraph, or DeepAgents is the right tool for your problem. Bring a GitHub account and a browser. Leave with production-tested patterns.

2-hour workshop on AI Security Engineer Foundations covering the following modules: - OWASP Top 10 for Agentic Applications - Addressing Shadow AI - AI Governance and Policy as Code - Securing Agent Skills & MCP - Securing Vibe Coding - AI Penetration Testing

AI is changing more than how we write code. It’s changing how we build software. As GitHub Copilot evolves beyond code completion into an intelligent collaborator, developers and organizations have an opportunity to rethink how they work. In this session, we’ll explore how AI can support the software development lifecycle, from planning and implementation to testing, documentation, and code reviews. We’ll discuss context engineering, intentional AI adoption, and how teams can create effective collaboration between developers and AI while maintaining the right balance of automation and human judgment.

When an agent chooses your dependencies and assembles your build, answering what you are actually shipping gets genuinely hard. This talk starts with the fundamentals that make it answerable, including SBOMs, exploitability data, and build provenance, and shows how to apply them so an agent-assembled stack is one you can defend in a security review.

Session details will be announced soon.

What happens when GitHub Copilot moves beyond chat and becomes a shared workspace for developers, agents, and tools? After a brief introduction to the GitHub Copilot app, this session introduces canvas extensions—interactive surfaces that help teams visualize information, collaborate on content, and act while keeping humans in control. Through demonstrations of several canvases, we’ll explore workflows such as documentation, design iteration, issue triage, and more. We’ll then build a canvas and examine the APIs and SDK used to create these experiences. Attendees will leave with practical guidance for identifying opportunities for canvas extensions and designing experiences that make Copilot more useful, actionable, and connected to the tools customers already rely on.

Coding agents get useful the moment they can read files, run commands, and reach the network, and each of those is also a way for one bad step to cost you an afternoon or worse. This talk shows what it takes to run an agent at full capability inside a boundary you set, ending with a live setup you can recreate on your own laptop in minutes.

Learn to Cloud is a free, open-source alternative to paid cloud bootcamps. Thanks to GitHub, two maintainers with full-time jobs ship features and fixes daily across four repos to more than 6,000 learners. In this talk, we'll open up our repos and show what's actually in them: agent skills that encode our production runbooks, custom agents that review security and drive browser QA, agentic workflows that keep content current, and more. We'll show where we use AI, where we deliberately don't, and why that line matters when two people maintain everything.

GitHub Copilot handles millions of developer interactions every day! Behind every suggestion, chat response, and agentic action are countless decisions about which model or subagent to invoke, how long to let it run, and when the answer is already good enough. This talk shares lessons from the Code|AI research team's work on making the Copilot harness leaner without sacrificing quality. We'll dig into the experimentation, evaluation, and data science that helped us find and validate meaningful efficiency gains at scale. If evals, experimentation, and data science are your jam, this one's for you.

AI agents are only as capable as the environment they're allowed to act in. This session introduces Docker's purpose-built platform tools for agentic development — the infrastructure layer that lets autonomous systems do real work, safely and reliably. We'll dive into Docker Sandboxes, which give agents secure, isolated execution environments where they can write and run code, interact with filesystems, and test outcomes without risk to your host system or production infrastructure. We'll also explore Docker's MCP toolkit, which provides agents with a standardized way to discover and invoke trusted tools. Together, these tools form the foundation of a trustworthy agentic platform: one where autonomous processes have exactly the access they need, and every action is contained, observable, and repeatable. Leave this session ready to wire Docker into your AI agent stack as the execution layer your agents can depend on.

As agentic workflows give AI systems more autonomy to pull dependencies, build environments, and invoke tools, the security of your container foundation has never mattered more. This session puts security front and center. You'll start off with learning core security features, such as SBOMs, VEX, and the SLSA framework. From there, you'll learn about and get hands-on with Docker Hardened Images (DHI) and how they utilize these capabilities to give every developer and agent a safe baseline to build from. Finally, learn how to use build policies and image signing to safeguard your CI pipelines and deployment environments. Leave this session with a clear framework for securing your entire stack.

Learn how to search through video, audio and flat files from SQL statements to equip your applications and agents with multimodal analysis. Vibe-code a Cloud Run web application to see the power of semantic search over different types of files in action.

Legal teams aren't usually cast as builders, but at GitHub CELA, they ship. This session tells the story of how CELA used AI to rewire the way legal work gets done: automating the routine, accelerating the complex, and freeing lawyers to focus on judgment over busywork. We'll cover where we started, the wins along the way, and where we're headed next, with a live look at the tools in action. Whether you're legal, technical, or somewhere in between, you'll leave with a concrete picture of what "lawyers who ship" really means.

​An event dedicated to exploring all things AI Engineering! Agenda: ​​​​​​🕒 5:30 pm – 5:35 pm Welcome and Opening Remarks ​​​​​​​​🕒 5:35 pm – 5:50 pm Talk "Your Agent's Slowest Tool Is Its Mouse"​ ​​🕒 5:50 pm – 6:05 pm Talk "Fast Tokens, More Responsive Agents" ​​🕒 6:05 pm – 6:20 pm Talk "TBA" ​​🕒 6:20 pm – 6:30 pm Talk "Beyond the Sandbox: Scaling Enterprise-Grade AI Agents for Real Users" ​​🕒 6:30 pm – 6:40 pm Talk "Auto-Research on a Budget: Small Models in the Loop, Frontier Models on Call" ​​​​​​​​​​​​​​​​🕒 6:40 pm - 8:30 pm ​​​Networking with pizzas and beverages More information & registration: https://luma.com/ai-builders-san-jose

Agents have made building software faster, but infrastructure has to catch up. In the world we now live in, developers review code they did not write, or don’t review it at all. An agent can generate and execute changes faster than any person or team can inspect them. And while prompts and skills can steer an agent, they cannot guarantee trust. For decades, we established trust in software through people and process: shared context, code review, CI, and ownership, all of which run at human speed. Agents do not. If a person has to watch every step, the agent is not autonomous, and most of the promised speed disappears. Trust has to move into the system itself. Mark Cavage, President and COO of Docker, makes the case for enforceable boundaries around nondeterministic agents. When you can’t inherit trust, you have to manufacture it. That means isolating where agents run, limiting what they can reach, recording what they do, and making failures reproducible. These controls are not the price of moving fast. They are what let you move fast without losing control. The test for an agent platform is simple: Does security hold when the prompt does not? Can you audit what happened? Can you switch models and tools without rebuilding the trust layer? The goal is not to trust the agent. It is to trust the system around it enough to close your laptop, while the work continues.

Session details will be announced soon.

DevOps practices are the plumbing of modern software delivery - how code gets built, tested, shipped, and operated in production. The way software is made is now shifting faster than the practices around it: AI writes and deploys a growing share of it, systems change quicker than teams can review, and production keeps growing in scale and complexity. What this shift means for companies building and operating software at scale - how best practices are changing, and what teams need to know to keep delivery fast and reliable.

Browsers are becoming more than just rendering engines. They're evolving into the orchestration layer that decides which AI systems retrieve information, summarize content, and interact with users. This session would explore how Firefox is designing Smart Window as an extensible AI layer that can evolve over time rather than locking users into a single provider. Exa would serve as a case study in how specialized AI services can plug into that architecture while maintaining strong privacy protections, including zero data retention. The conversation ultimately shifts from "Which model is best?" to "who controls the layer that decides which model gets used?"

As organizations scale their Kubernetes footprint, the "Day 2" reality of GitOps becomes clear: static thresholds are brittle. Standard Canary rollouts rely on fixed Prometheus queries (e.g., Error Rate < 1%), but these rules lack the context to distinguish between a minor transient blip and a systemic failure. For Platform Engineers, this results in "Alert Fatigue" and manual "promotion" gates that slow down the delivery pipeline. In 2026, we are moving from Static Automation to Reasoning Platforms. This session explores how to evolve your delivery infrastructure into an intelligent system that doesn't just follow rules, but reasons through data. We will demonstrate how to wrap ArgoCD Rollouts with an Agentic Reasoning Layer capable of cross-referencing metrics, logs, and distributed traces to make autonomous "Go/No-Go" decisions. We will trigger a Canary deployment that passes basic health checks but introduces a "silent failure" (e.g., a cache hit-rate drop causing downstream latency). You will see the Reasoning Platform detect the anomaly, pause the rollout, "investigate" the root cause, and present a natural-language justification for the automated rollback.

Every NGINX config encodes intent — is this a reverse proxy? an API gateway? an SSL terminator? — but that intent is never written down. At fleet scale, nobody can tell you what your configs actually do. This session shows how we taught a machine to read them. We classify NGINX server configs into eight canonical roles using a three-stage pipeline: parse the raw config into a structured directive tree with CrossPlane, then run two complementary classifiers against it — a precision-tuned rule engine that abstains when signatures are ambiguous, and an ML model that generalizes to configs the rules don't cover. A confidence-fusion layer blends them, auto-accepting confident calls and routing borderline ones to expert review. The counterintuitive lesson: we deliberately didn't just throw an LLM at this. The hybrid beats either approach alone — keeping rule-level precision while recovering the coverage rules lack. You'll see why "negative evidence" (the absence of a directive) is often the strongest signal, how an LLM-as-judge eval validated the design, and how a closed expert-feedback loop turns review hours into measurable accuracy gains. Live, against real configs — including yours, if you bring one.

Artificial Intelligence (AI) now drives decisions across enterprise operations, for autonomous systems—yet much of this decision-making remains a “black box.” AI Decision Observability is an emerging paradigm that transforms opaque model behavior into traceable, explainable, and auditable decision pathways. This session introduces a unified framework that combines AI Decision Observability with Decision Intelligence—linking how decisions are made, measured, and improved across human-AI systems. Building on our AI Decision Automation Framework, we explore the technical and organizational capabilities required to move from decision outputs to decision systems: continuous, observable pipelines where every inference, rule, and outcome can be traced back to its origin. We discuss key methodologies—comprehensive logging, data and model lineage tracing, model introspection, counterfactual and causal analysis—and how these integrate into enterprise observability stacks. The session also showcases tools and architectures that operationalize observability, alongside real-world case studies from regulated domains like finance, healthcare, and autonomous mobility. We’ll conclude with a forward-looking view on how Decision Observability fuels Decision Intelligence—enabling enterprises to build trusted, adaptive, and compliant AI ecosystems where decisions are not just made but understood, improved, and governed. Key Takeaways: How to architect AI systems for full decision traceability and governance Integrating Decision Intelligence with AI Decision Observability for continuous learning Practical frameworks for scaling decision transparency and automation across the enterprise

Your agent works in the demo, then forgets everything the next day. The model is not broken: models are stateless by design, and memory belongs to the harness you build around them. Bigger context windows do not fix it. Re sending full history burns tokens every turn and still vanishes between sessions. This talk maps the agent memory landscape through one question asked four ways: retrieval by key, by meaning, and by relationship. You will learn when key value, vector, graph, and hybrid memory each win, plus the capabilities layer on top: selective memory, hygiene against dirty and poisoned entries, and reasoning memory for auditable decisions.

A great Copilot session can unblock one developer, but team scale value begins when the repository itself makes architecture, conventions, development commands, tests, and validation easy to discover and when successful workflows stop disappearing into chat history. In this technical session, we will take a repository from a generic Copilot experience to an AI-ready development environment. We will encode the project knowledge and validation developers need, then package recurring workflows as reusable prompts, skills, plugins, and custom agents. Next, we will version and govern those resources, and publish them through a centralized internal marketplace. We will close by connecting these developer practices to GitHub Copilot enterprise managed settings and how you can configure these at scale. You will leave with a practical guidance for making Agentic workflows useful beyond a single developer while providing engineering velocity and keeping people responsible for what ships.

This talk presents a deep technical exploration of implementing zero-trust security principles to enable secure agentic AI workflows across both internal systems and external enterprise tools. We'll examine the architectural patterns that allow granular access controls, unified authentication, and audit-ready visibility to work together, enabling productive AI automation while maintaining strict data sovereignty. Through real-world deployment examples, we'll demonstrate how these zero-trust foundations solve critical security challenges at the intersection of AI, cloud infrastructure, and regulatory compliance.

This session will explore how intentional, human‑centered candidate experience can directly impact employer brand, hiring outcomes, and long‑term talent strategy, even with limited or no employer branding budget. I will share how Awin embeds company values into the recruitment journey, from candidate surveys to empowering employees as authentic brand ambassadors (Awinners). The session will highlight how platforms like Glassdoor to actively showcase culture, recognize employees, and hold the organization accountable, resulting in measurable employer brand recognition across all regions. A core focus of the talk is bringing the human back into Human Resources. I will cover how consistent communication, structured yet flexible interview processes, and ongoing hiring manager training contribute to better candidate outcomes in return, will positively impact the companies brand. I’ll share real candidate feedback and explain how we monitor trends, act on insights, and prioritize continuous improvement in an evolving job market. We will address how to ensure candidates still have a positive experience even when the outcome is a rejection, including the long‑term value of “silver‑medalist” candidates. Drawing from my experience leading end‑to‑end recruitment across the U.S., Brazil, and Mexico, I will walk through an adaptable, evergreen recruitment process designed to respect candidates’ time, reduce assumptions, and build trust. The session will also explore how personal branding can strengthen employer branding, including how organic content helped amplify Awin’s visibility and employer reputation at scale. Overall, this session will demonstrate how a people‑first, partnership‑driven approach to talent can become a true competitive advantage for organizations navigating today’s hiring market.

What does building a software factory for the era of agents look like? Join Thomas Dohmke (CEO and founder, Entire) and Matan Grinberg (CEO and cofounder, Factory) to discuss how the software development lifecycle must change to adapt to a world where agents are the primary producers of code. Drawing on their respective experience across the industry building independent, model agnostic platforms, the pair will lay out a shared vision for the future: From Git hosting, to multi-agent reviews, to the end of human code review altogether.

AI is moving out of the datacenter and into devices, vehicles, and machines. Building for the physical world is different from building for the cloud: compute and power are constrained, connectivity is not guaranteed, and shipping an update means reaching hardware in the field. What matters when building, deploying, and running AI under these conditions.

AI applications don't have fixed infrastructure requirements. A single request can fan out into hundreds of long-running tasks with different runtimes, memory requirements, and execution times. The application is no longer just consuming infrastructure. It defines the infrastructure it needs at runtime. In this talk, Render CEO Anurag Goel introduces Application-Defined Compute, a new infrastructure model built for AI-native applications. You'll learn why traditional serverless platforms and self-managed orchestration both break down at scale, and how developers can provision compute just in time, run long-lived stateful workloads, and execute tasks with the flexibility of real servers, without managing queues, worker pools, retries, or orchestration themselves. Using Render Workflows as an example, the session explores the new infrastructure primitives emerging for AI-native applications and how cloud platforms are evolving to support them.

We have all had that maddening customer service experience: you text a support line about a delayed flight, receive a confirmation, but when you call in a minute later, the voice agent asks, "How can I help you today?" completely blind to the SMS you just sent. This is the "Channel Amnesia" problem. While businesses are pouring billions into generative AI, most agents are still built on stateless architectures that forget customer context the second a session ends. In this session, we will cure AI amnesia. You will learn how to orchestrate stateful, production-grade AI agents across SMS and Voice using Twilio Agent Connect and Amazon Bedrock. We will dive into why traditional serverless compute fails stateful agents, how to leverage AWS Fargate for isolated, long-lived sessions, and how to configure Bedrock AgentCore over WebSockets to hit sub-50ms streaming voice latency. No slide-ware here — expect a live, cross-channel demo and open-source code you can deploy tomorrow.

The dominant framing of enterprise AI is speed: faster code, faster decisions, faster discovery. That framing misses the larger story. When AI is anchored to the equations of physics, chemistry and biology rather than to the corpus of the open web, it does not just compress timelines — it expands the space of what can be explored. A bigger biochemical landscape for drug discovery. A bigger materials landscape for batteries and alloys. A bigger design landscape for everything humans build. Drawing on SandboxAQ's deployments across pharma, energy and navigation, Yuval shows why Large Quantitative Models are the first AI architecture capable of growing the pie rather than slicing it thinner, and what that means for any enterprise still measuring AI value in cost reduction.

Building a Voice AI demo takes a weekend; production engineering is a different beast. This session delivers the architectural playbook for scaling resilient, enterprise-grade voice agents. We will evaluate speech-to-speech versus modular (STT → LLM → TTS) pipelines, WebRTC stacks, and hybrid topographies for strict data residency. You will learn fast-brain/slow-brain UX patterns to keep turn-taking responsive while backends process tool calls, alongside strategies for runtime model switching and custom vocabulary. Walk away with the exact trade-offs, patterns, and metrics needed to operate low-latency voice pipelines at scale.

Everyone can build an AI agent. Almost nobody knows how to run thousands of them safely in production. Over the past two years, we've watched AI agents evolve from demos into software that writes code, answers customers, automates workflows, and makes decisions. The challenge has shifted from building smarter agents to operating them reliably at scale. Having spent time at Meta and Google and now helping lead Guild.ai, CTO and co-founder Chris Waterson has seen firsthand where production systems fail. It's rarely the model. It's the surrounding infrastructure: context management, permissions, observability, cost controls, versioning, evaluation, and governance. This session explores what changes when AI agents become real production systems instead of prototypes. He'll draw on lessons from building Guild Software Factory, a system of specialized agents that plans, implements, reviews, and maintains work across a codebase, and Guild Optimizer, which automatically tests cheaper agent configurations against production history to cut costs without sacrificing quality. Attendees will leave with practical frameworks for designing AI agent systems that are observable, secure, reusable, and capable of evolving over time, not just impressive during a demo. Whether you're building your first agent or managing hundreds across an organization, this talk offers lessons from operating AI where reliability matters.

Built from the ground up as a native AI coding tool, the GitHub Copilot app integrates with your work and workflow. From triaging issues, managing agents, and creating interactive canvases, you can build, review, and deploy all from one location! Let's explore how to accelerate your dev flow and get the most out of the tool.

As we shift from simple chatbots to long-running agents, we face a critical engineering challenge. The risk is no longer just bad output. It is memory poisoning. This occurs when malicious data permanently corrupts your vector database, causing agents to hallucinate or leak private information indefinitely. This session will present a Zero Trust architecture for Responsible AI starting prompt injection until agent isolation. We will dissect a reference stack built entirely on open source standards that treats your vector storage as a high-security vault. Attendees will walk away with practical techniques to: Replace risky API keys with cryptographic verification using SPIFFE and SPIRE, ensuring only valid code can access long-term memory. Use policies to write security rules as code, separating your safety logic from your application logic. Block sensitive data and malicious prompts before they are ever stored using tools like Microsoft Presidio. Join me to learn how to build agents that are resilient, audit-ready, and secure by design.

Every tool solves a problem until it creates another one. What started as a simple search for better software turned into years of frustration, dozens of disconnected tools and one simple realization: managing software had become harder than managing the business itself. In this founder story, you'll discover how that frustration led to building Pistacio, a Founders OS platform designed to simplify operations for modern service companies and why reducing complexity could become the next major opportunity in B2B SaaS.

Learn how to leverage open-weights models and data warehousing to solve a spatial analytics problem: finding the most profitable locations for new coffee stands. By analyzing datasets of popular bike routes, we will guide you through building an AI-powered solution using Gemma 4 and the BigQuery Model Context Protocol (MCP) server. You will gain hands-on experience connecting LLMs to enterprise data and learn how to use AI to drive smart, data-driven business decisions.

How well you scope a problem determines how well AI can help you solve it. This workshop makes that claim testable, not just believable. Bring your laptop and the AI tools you already use. Teams take on a real, messy business challenge — a live-service gaming company caught between an AI feature its CEO already announced and the fragile data foundation that feature would actually run on. Before building anything, each team is randomly assigned exactly one stakeholder to interview. What they hear — and how well they turn it into a scoped, defensible approach — is the variable we're testing. From there, teams use their own tools and AI to build a working solution slice with AI as a genuine collaborator throughout. We instrument the build: prompts submitted, iterations to a working version, time to first pass. At the reveal, we show the correlation directly: teams that scoped tightly from partial information moved faster and cleaner with AI than teams that tried to build before they'd committed to an approach. Every participant leaves with a personal build card — their own scoping-to-efficiency numbers next to the room's benchmark — and a sharper instinct for a skill AI hasn't replaced: knowing what problem you're actually solving, from an incomplete picture, before you start.

Model Context Protocol (MCP) is an open standard that lets AI agents like GitHub Copilot tap into external tools, services, and your own account data. In this hands-on workshop, you'll connect GitHub Copilot to both public and authenticated MCP servers, explore the tools they expose, and put them to work—researching topics, troubleshooting issues, and making real contributions to a codebase. You'll also discover how combining MCP servers with agent skills unlocks more powerful, personalized developer workflows.

Maezza Romero, Community Developer for Romero Games, has been shaping communities from the ground up for 6+ years. She started her journey in 2018 with Cyber Squad for Hewlett Packard Enterprises and the Girl Scouts, and now manages social media and a 6,000+ member Discord for Romero Games, one of the friendliest shooter communities in the industry. Her passion? Ensuring everyone feels valued and welcome. Join Maezza to discover the strategies behind building inclusive, engaged communities. She’ll share tips on authentic engagement, moderation best practices, and laying the groundwork for communities that stand the test of time. This workshop is suitable for those working in both game development and general business, with practical insights that can be applied across a range of industries.

By the end of this workshop, attendees will be able to: 1. Describe the end-to-end edge AI workflow, using agentic AI coding throughout: (a) Collect data and label images with bounding boxes; (b) Design a machine learning model with Edge Impulse; (c) Train and test the model; (d) Create a reusable Edge Impulse skill for the AI agent, capturing the workflow conventions (API usage, project structure, deployment steps) so the agent can reliably assist on future Edge AI projects. 2. Re-train an object detection model on a custom "rubber ducks" dataset: (a) Test the new model on your mobile phone, using the camera and the browser; (b) Deploy on an Arduino UNO Q with the App Lab integration, using the AI agent (with the Edge Impulse skill) to generate and iterate on the application code — camera capture, inference loop, and output handling; (c) Run and test the model on the Arduino UNO Q, prompting the agent to debug errors and add features (e.g., counting ducks, triggering an output on detection, etc.).

AI-assisted development has made it astonishingly easy to produce software — and astonishingly hard to trust it. Demos ship in hours, but production demands more: auditability, verifiability, cost control, and the delivery discipline enterprises have spent decades refining. This session begins by clarifying the terminology now shaping the industry — SDLC, AI-Assisted SDLC, and ADLC— and what actually changes when AI agents become first-class participants in software delivery rather than autocomplete on the side. We then share hard-won lessons from building the VibeFlow, a 9 persona AI team for producing production-quality software through AI-assisted development. VibeFlow structures specialized agents into a governed team that operates inside familiar Scrum and Kanban constructs: backlogs, sprints, reviews, and definitions of done. The result is AI velocity that remains observable, auditable, and verifiable at every stage. Attendees will learn the design principles that made this work in practice: why governance must be architected in rather than bolted on; how work-item traceability makes AI output verifiable instead of merely plausible; how cost controls and guardrails keep agent teams economically predictable; and how marrying agents to agile ceremonies turns impressive demos into dependable delivery. Whether you're an engineering leader evaluating AI adoption, an architect designing for it, or a practitioner already shipping with AI, you'll leave with a concrete blueprint for moving from vibes to verifiable — and from X to 100X — without sacrificing the trust production demands.

Every demo of a voice AI agent looks great — until real users start talking. They interrupt, mumble, switch languages mid-sentence, and ask the one question that sends the agent off the rails. Traditional scripted QA only verifies the behaviors you already thought of, which is exactly why so many voice agents fail in production in ways their teams never saw coming. This session walks through a practical, engineering-grade approach to shipping Voice AI agents you can trust, built on three pillars: simulation, evaluation, and monitoring. You'll see how synthetic "drivers" — AI-powered simulated users with distinct personalities, goals, and contexts — hold realistic multi-turn conversations with your agent across 30+ languages and real-world audio conditions (noise, crosstalk, clipping), actively exploring the edges scripted tests miss. We'll then look at how judge-based, symbolic, and audio evaluations turn those discoveries into CI/CD release gates, so a change that degrades conversation quality fails the build before it reaches users. Finally, we'll close the loop with production monitoring that captures real failures and automatically converts them into regression tests — so the same mistake never ships twice. You'll leave with a concrete blueprint for finding the edges of your Voice AI agent before your customers do.

Most AI agents move files. Ours run machines. Loominus Studio is an AI workbench. You use it to build agents that work alongside people to design and make real things: materials, formulations, devices. The jargon for this is collaborative cyber-physical agents. The plain version is agents with hands. What you build is a harness. A harness is everything an agent needs to do real work: the tools it can reach, the steps it follows, what it remembers, what it is allowed to touch. Coding agents have harnesses. That is why they work. Labs and factories have none. You build one by wiring nodes into a graph. Each node is a step or a tool: run this machine, mix this batch, ask a person to check, measure the result, pick what to try next. Wire them together and the agent runs the loop. Two things matter about these harnesses. Configurable: no two labs work the same way, so you build yours instead of buying someone else's. Portable: build it once, run it on someone else's machines. Your process should not be locked to one vendor's box. We use it ourselves. MetaLab is a harness for making formulations. BioLoom is a harness for printing parts. Same workbench, different graph. Five minutes on why the loop that made coding agents work is the same loop every lab runs, why nobody built the workbench for it, and what that changes for the bioeconomy age, when the things ahead of us have to be made, not just written.

Your AI agent works great in the demo. Then you deploy it and it hallucinates a refund policy, exposes customer data, or just loops endlessly burning tokens. This session walks through a layered approach to agent safety using tools like Amazon Bedrock AgentCore and the Strands Agents SDK: guardrails, observability, multi-agent safety patterns, and reference architectures you can adapt immediately.

AI agents are becoming heavy users of developer tools: reading documentation, operating platforms, writing and shipping code. Tools designed around human attention - interfaces, docs, onboarding - behave differently when the one using them is software. Companies across the stack now serve humans and machines at once, and the choices go to the core of the product. What changes when agents become users, and what it means for the people building with them.

Artificial intelligence is undergoing a foundational shift from passive, generative model outputs toward goal-oriented, autonomous operational execution. Agentic AI represents an architectural evolution beyond static prompt-response systems, combining reasoning, memory, planning, and external tool execution to act independently within complex environments. Further, organizations face real-world challenges in reliability, safety, governance, and system orchestration. In this panel, we will discuss what the current capabilities of agentic systems and how its impact is measured. We will also discuss architectural breakthroughs driving next wave of agents which consists of multi-agent collaboration, tool integration and persistent memory how to move agents from pilots to production. Lastly, the discussion will map out what lies ahead for leader navigating the transition to an agentic future.

As AI moves from chat demos to “do-things” software, the platform requirements change: identity, policy, network controls, data governance, audit, and safe tool execution become mandatory. This session explains why a private application platform on private cloud is the most reliable foundation for enterprise AI—especially for agentic workflows and development assistants that touch sensitive systems. We’ll map the core platform capabilities (runtime, workload identity, secrets, supply chain, service brokering, observability, guardrails) to real AI components: model endpoints, vector stores, tool APIs, MCP servers, and skills routing. You’ll leave with a reference architecture and a pragmatic checklist to evaluate whether your current platform can safely run “full-blown” AI experiences.

We have all been there. You need a database or a quick node environment, so you throw "FROM node:latest" into your Dockerfile and deploy. It works, but you have just introduced a black box into your Kubernetes cluster. For the Developer, it’s a quick fix. For the Platform Engineer, it’s a nightmare. Most upstream images from public registries are a roll of the dice. They come pre-packed with critical vulnerabilities, unknown binaries, and bloated libraries that you didn’t ask for and definitely don’t want running in your secure environment. In a world of Zero Trust, why are we trusting random upstream maintainers with the keys to our infrastructure? In this session, we will dismantle the myth that "open source means secure" when it comes to container images. We will walk through the architecture of a truly Secure Software Delivery pipeline—one that establishes trust before a single line of code is committed. We will discuss: - The hidden dangers inside popular "official" images. - Moving beyond basic scanning: Why you need SLSA L3 provenance, SBOMs, and cryptographic attestation. - The "Build vs. Buy" dilemma: Should you curate your own base images or rely on a hardened upstream provider? Join us to learn how to bridge the gap between developer velocity and platform security, ensuring that the only thing running in your cluster is code you actually trust.

Moving from a viral demo to reliable enterprise AI is the hardest hurdle in modern software engineering. Because agents are inherently non-deterministic, validating performance requires a granular look at the "why" and "how" behind every action. This session explores how observability redefines agentic evaluation beyond binary pass/fail testing, shifting the focus from the result to the entire reasoning chain. Featuring a live demo using Arize Phoenix and LangGraph, we’ll showcase how to trace complex loops and automate evaluations in real-time. What you’ll learn: Beyond Output: Why judging final answers alone is a recipe for silent failure. Live Implementation: Using Arize Phoenix with LangGraph to visualize traces and debug agentic "thought processes". The Playbook: An incremental framework for evaluation-first development. Are you ready to stop guessing and start measuring? Join us to master the art of agent evaluation.

Everyone's chasing faster models, better reasoning, shinier inference endpoints. But here's the truth: your agent will fail in production long before model quality becomes your bottleneck. The problem isn't the model. It's that you can't see what your agent is actually doing. In this session we cover why traditional observability breaks for agent workloads, how OpenTelemetry and GenAI semantic conventions give you the vocabulary to instrument agents correctly, and how observability becomes the thing that lets you gradually trust your agents with more autonomy. You'll walk away knowing what to instrument, why it matters, and how to stop guessing when your agent does something unexpected in production.

The honeymoon phase of AI is over. Organizations across all industries have spent the last two years buying licenses and experimenting, but boards and CFOs in the 2026 fiscal year are demanding proof of value. For CTOs and VPs of Engineering, the challenge has shifted from "how do we build this?" to a critical fiscal responsibility: showing a measurable return on AI investment. The bottleneck isn't the model; it’s the middleware of the human process. Too many organizations are automating tasks (AI-Augmented) while leaving the topology of their engineering organizations untouched. To capture true ROI, we must shift to AI-Native Engineering, where the SDLC is architected around probabilistic capabilities rather than deterministic checklists. In this session, Manu will help teams learn how to move past "productivity vibes" and into measurable ROI. Manu will break down the “Efficiency Trap”: the phenomenon where AI generates code faster, but testing, security, and deployment bottlenecks remain static, resulting in zero net gain in system throughput. Additionally, Manu will present a framework for evaluating ROI at every stage of the product lifecycle and show attendees how they can move their metrics from "PRs per day" to "Outcome Velocity", in short, reduce the “Lead Time to Value.” The 4-Stage ROI Lifecycle - Discovery (The Intent Stage): ROI of using AI to bridge the "Context Gap" between Product, Design and Engineering. - Development (The Build/Composition Stage): Measuring "Unit Cost of Code" to ensure high-velocity output doesn't increase downstream maintenance costs. - Verification (The Quality Stage): ROI of shifting from manual QA to "Automated Eval" stacks. - Operations (The Resilience Stage): The financial impact of AI-driven observability, self-healing systems, and the automation of the Support-to-Engineering feedback loop.

As enterprises increasingly look to combine data with partners, suppliers, and platforms to power AI, analytics, and personalization — without exposing raw records or violating privacy regulations — Clean Rooms have moved from an emerging concept to a serious architectural option. But most teams encounter them first through vendor documentation and demos that skip the hard parts. This session starts from first principles. It explains the core problem Clean Rooms solve: enabling joint computation across datasets from multiple parties without any party accessing the other's raw data. It then walks through the architectural building blocks — controlled computation environments, output restrictions, access control policies, and the cryptographic boundaries that make privacy guarantees enforceable — and shows how these concepts translate into real design decisions. From there, the session takes an honest look at the implementation landscape. Attendees will understand how Clean Rooms compare to alternative privacy-enhancing approaches — federated learning, differential privacy, synthetic data, and contractual anonymization — and the trade-offs each involves across privacy strength, latency, operational complexity, and regulatory defensibility. The session also covers where production complexity tends to concentrate: access control configuration, output data governance, deployment automation, and integration with AI and ML workloads. Attendees leave with a clear mental model for evaluating Clean Rooms against their own organization's data collaboration challenges, a practical understanding of the architectural patterns involved, and an honest view of what separates a well-designed Clean Rooms implementation from one that looks good in a proof of concept but struggles in production.

Software used to be built in a handful of places you controlled. Now it's built everywhere: a laptop, a fleet of CI runners, a local sandbox, a remote sandbox with an agent driving it. Increasingly, nobody sets those machines up by hand. Two hard problems fall out of this: making the build produce the same result on every machine, and making the output of that build reproducible wherever it runs next. This talk looks at how deterministic, declarative environments (built on Nix) solve both: one definition that pins packages, toolchains, and even agent skills, reproduced bit-for-bit across the lifecycle, with a verifiable record of everything that went in. We'll show how Flox makes this practical without requiring your team to learn Nix.

The session will introduce Swytchcode to the audience and help them learn how to ship reliable AI agents in the production when working with 3rd party APIs. Swytchcode helps your team find the right API path for the business workflows you need to run, then governs how each agent action runs in production—with authentication, retries, idempotency, validation, and auditability built in.

Across enterprises, a similar experiment seems to be playing out: developers are shipping at accelerating speed with AI-assisted tools, and that speed is real and worth preserving. But “vibing” something — coding, security, strategy, tax prep, take your pick — can works because someone isn’t deep enough in it to know what they may be missing, and that can work well for a proof point, but may not translate to what runs the business. This session is about the line leadership teams have to hold: how you let builders iterate and prove ideas fast without letting ungoverned experiments quietly become production systems. PwC's technology specialists will share how they've built the controls, telemetry, and enterprise-grade guardrails — going beyond what frontier AI companies can provide — to turn fast iteration into durable, scaled engineering output.

Companies now have a real alternative to buying software: building it themselves, with AI doing most of the work. Teams are already replacing paid tools with internal ones, and vendors are being asked why their product beats a prompt. When building still loses to buying, where self-built software genuinely holds up, and what happens to the software business when its customers become its competitors.

The biggest AI breakthroughs aren't happening where you might expect. They're happening in factories, warehouses, utilities, logistics networks, and back-office operations. The less glamorous the process, the greater the opportunity for impact. This session reveals why organizations with repetitive, mission-critical workflows are turning AI into measurable business value today

Good AI vs. evil AI is an ethical choice. Good AI vs. bad AI is a design choice. AI has saved lives at scale and been weaponized at scale, and both of those are true at the same time. This talk starts with the evidence for each, sourced and citable, then argues that the argument everyone is having is the wrong one. Good AI versus evil AI is an ethical choice: what you decide to build. Good AI versus bad AI is a design choice: whether what you built can be trusted once it is running. Those are two different decisions and collapsing them is why so many AI initiatives produce confident, unaccountable output at machine speed. The framework covers four layers, in the order that actually matters. Models, where most teams start and which matter least, measured by cost per successful task rather than cost per token. Architecture, where agent chains make blast radius a function of tracing, and where autonomy gets promoted on an observe, suggest, act-with-approval, act-alone ladder with evals gating every step. Data, which has to be unified, causal, continuous, and traceable or the rest is theater. And the role change already underway: from writing code to specifying intent, from chasing dashboards to building the agents that watch them, from operating systems to governing ones that run themselves. No product pitch. You will leave with the evidence to hold your own in the argument and a concrete order of investment.

With the arrival of Mythos and other frontier models we enter a new world. They can find security issues in libraries, create individual exploits, and successfully chain them to real-world attack campaigns in 2026. The open source ecosystem is on the verge of something new. What happens next is terrifying and exciting at the same time. At Chainguard we started a coalition with many partners across governments, banks and other large corporations, foundations, and open source communities to use the tools to strengthen our defenses against attackers. We established trust and infrastructure to share exploits, create patches, and bring them to use as binaries. Just in our first weeks we processed over thousands of findings, created well over 1k patches, and touched the code base of hundreds of open source projects. Now it is a few months later, and Manfred will share our experience from working within and outside the project. We will talk about good findings, bad patches, and ugly consequences alike, and dive into the details of examples and our collaboration with open source projects, communities, and their users. Manfred will also talk about the machinery behind the scenes that enables patching at the necessary scale - Chainguard Factory, powered by our open source agentic framework DriftlessAF, and expert engineers assisted by powerful AI models.

AI applications place very different demands on inference. Coding agents reuse long context, vision-language systems process variable multimodal inputs, and generative recommendation models operate under strict latency requirements. A generic inference stack cannot maximize performance across all three. PrimaLabs delivers an application-specific inference stack engineered around each production workload. The platform jointly optimizes runtimes, kernels, caching, batching, scheduling, parallelism, and GPU infrastructure, then operates the resulting stack in an isolated environment.

Atomic makes software changes queryable. Atomic is source code management at the primitive level: a distributed, agent-native Git alternative. A single CLI brings semantic call graphs, enhanced code search, intents, attestations and provenance to every agent you already use, so every change keeps its origin, its reasoning, and its evidence

The gap between what people imagine and what AI creates is a production problem. How each::labs closes it: one API, 600+ media models, routing and failover built in, frontier quality with production economics.

Ben Gilbert and David Rosenthal are taking the main stage to conduct a series of live interviews. The pair host Acquired, the #1 technology podcast on Spotify and Apple Podcasts with over 1 million listeners. Acquired tells the stories and strategies of the world's greatest companies—each episode is a deep dive into a single company's history from its founding until today. Ben and David personally handcraft each episode over 200 hours of research and production. From founders to Fortune 500 CEOs, Acquired has interviewed some of the most influential leaders in technology and business, such as Jensen Huang, Mark Zuckerberg, Steve Ballmer, Morris Chang, Matt Garman, and Jamie Dimon.

Distributed SQL Databases are a powerful new data management technology that addresses modern applications’ need for scalability, availability, geographic distribution, and low response time – with the power of SQL and strong consistency. However, distributed databases bring their own challenges. For example, the familiar trade-offs between consistency, high availability, and partition tolerance still exist. Remote data access will still incur speed-of-light network delays. This talk will describe the inner workings of distributed databases and how to design applications to best exploit their power. Using Oracle and other distributed databases as examples, we will explore the capabilities and unique application challenges posed by distributed databases. This talk will address design patterns that empower applications to handle network latency and consistency in the presence of real-world networks that can and do fail.

TorqueAGI builds a physics informed foundation AI that enables robots to operate reliably in the real world. Our models power mission critical robotic systems across dynamic environments and are already being adopted by 10+ robotics partners, including production deployments.

First we optimized for UX, then DX, and now there's AX - the Agent Experience crashing the party. AI assistants are increasingly showing up to use our apps, and right now most of them get in by screenshotting the DOM and guessing where to click. There's a better way. WebMCP lets your Angular app hand agents a clean set of callable tools, and A2UI lets agents hand back real, reactive UI instead of another wall of chat text. In this session we'll architect an Angular app for this shiny (and slightly experimental) new world. We'll walk through the modes of agent interaction, from quiet background data retrieval to rich, agent-generated interfaces, and look at a few ways to wire WebMCP into Angular through navigator.modelContext. Then we'll bring in A2UI so agents can return reactive component trees that your app renders natively, with your styling and accessibility along for the ride. You'll leave knowing how to register tools, render agent-driven UI, and start thinking about your app's tool surface alongside its visual one. You'll also get a clear-eyed sense of what's production-ready today and what's still gloriously bleeding-edge.

AI is changing every stage of the software lifecycle, from planning and implementation to code review and delivery. As development becomes increasingly AI assisted, traditional engineering metrics no longer provide the full picture. This session explores how engineering organizations can understand the real impact of AI across the software lifecycle. Rather than focusing on AI usage alone, we'll discuss how to measure adoption, evaluate engineering outcomes, maintain delivery quality, and identify where AI is genuinely improving team performance. You'll see practical approaches for building visibility into AI driven software delivery and making better engineering decisions with data.

Ben Gilbert and David Rosenthal are taking the main stage to conduct a series of live interviews. The pair host Acquired, the #1 technology podcast on Spotify and Apple Podcasts with over 1 million listeners. Acquired tells the stories and strategies of the world's greatest companies—each episode is a deep dive into a single company's history from its founding until today. Ben and David personally handcraft each episode over 200 hours of research and production. From founders to Fortune 500 CEOs, Acquired has interviewed some of the most influential leaders in technology and business, such as Jensen Huang, Mark Zuckerberg, Steve Ballmer, Morris Chang, Matt Garman, and Jamie Dimon.

Security architecture is built on assumptions about who does what: people write the code, people hold the credentials, threats come from outside. AI breaks all three at once - and companies are discovering that tools built for yesterday's assumptions don't just underperform, they miss entire categories of risk. Which parts of the security stack need rethinking first, which just need tuning, and how to rebuild while the ground keeps moving.

Duolingo's iOS app has nearly 1.8M executable lines and, until recently, test coverage that lagged far behind. We built an autonomous pipeline that writes unit tests and gets them to a merged state. Scheduled Temporal workflows pick untested code, Claude Code agents open real pull requests, and a lifecycle manager monitors CI, self-heals failures, runs AI review, and merges. Humans act only as final reviewers. The pipeline has merged over 85,000 lines of test code and tripled unit-test coverage of our MVVM components. This talk walks through the architecture, the guardrails that keep agent-written code trustworthy, the failure modes we hit, and how we are using the same skeleton for additional migrations across the company. You will walk away with a concrete blueprint for agents that ship code in a large production codebase.

The harness behind the agents you use is not the harness behind the agents you build. Join Mike Chambers (AWS) for a live-coded sprint from laptop agent to cloud-scale deployment, covering memory, identity, observability, and why most agentic use cases need less code than you think.

LIttle is known about the history of Neural Networks e.g. "Artificial Intelligence." The history goes back to around 1946 when researchers noticed that the mathematics involved with linear algebra wherein materials were stretched that the neighboring atoms were affected, was best modeled with a branch of Math known as tensors. Tensors are used today to create neural networks. Neural networks are run on a powerful Graphics Processing Unit (GPU.) GPUs came about because of video games and entertainment thus we can say that video games laid the groundwork for AI.

In the era of agentic workflows, when AI can build an MVP in seconds, traditional tutorials are rapidly becoming legacy technical debt. The challenge is no longer just teaching developers how to write code. It’s giving them compelling problems to solve with it. Enter TwilioWorld. Created by the Twilio Developer Training team, it’s a new approach to developer education, trading the traditional golden path for an open-ended, AI-native playground that uses conversational intelligence at every layer to create an adaptive, engaging, and genuinely educational experience. Join this session to explore a new pedagogy for the AI era: an approach where developer education isn’t about giving agents more skills, but giving developers a space to put those skills to work.

In this session, you will follow an incident management case study built with IBM Bob. A live demo will show specialized agents triaging an incident, assessing business impact, planning a resolution, invoking tools, and coordinating decisions through a supervisor. You will see how human approval protects critical actions and how distributed tracing makes agent behavior, tool calls, latency, and failures visible. We will also demonstrates how IBM Bob uses a concise project context file to understand architecture, follow team conventions, generate consistent code, and avoid inventing APIs that do not exist. Along the way, we will examine where agent workflows commonly break, how to choose between sequential, parallel, and supervisor based coordination, and how to control context and token usage without sacrificing quality. Key Learnings 1. Design reliable workflows involving multiple specialized AI agents. 2. Select sequential, parallel, or supervisor coordination for each use case. 3. Apply human approval and tracing to make agent decisions safer and observable. 4. Use IBM Bob with concise project context to produce consistent, governed code. You will leave with reusable design patterns, practical governance tips, and a clear path for turning an agent prototype into a system that operations teams can understand, test, and trust

Coding agents help us write code quickly, but they’ve introduced a new challenge: ensuring developers can understand, trust, and maintain agent-generated code. That challenge now shows up across the software development lifecycle: Context is scattered across multiple sessions. Developers have more code to review and less context to review it with. Code hosts face more automated activity than they were designed for. Agents burn tokens just trying to understand the codebase. Solving these problems requires a new workflow and mindset for working with agents. In this hands-on workshop, you’ll learn how to preserve context across sessions, reduce wasted tokens, and review agent-generated changes with the context you need to merge confidently. This workshop is for engineers, tech leads, and reviewers of all experience levels who want to work more efficiently with coding agents. Important please Sign up here beforehand: https://entire.io/login?utm_campaign=320951023-EVT%20%C2%B7%20WAD%20SAN%20JOSE%20SEP26&utm_source=workshop&utm_medium=wad And install Entire here: https://docs.entire.io/installation

Large Language Models are often described as if each generation introduces an entirely new architecture. In practice, most modern LLMs still retain the transformer core, but their real progress comes from a series of targeted design changes around attention, positional handling, feed-forward computation, routing, and memory efficiency. This talk explains LLM architectures through the engineering tradeoffs that shaped modern models: why some attention mechanisms evolved for lower inference cost, how architectural choices influence long-context behavior, why sparse activation changed the economics of scale, and how these shifts affect real-world deployment. Rather than treating LLM architecture as a static diagram, this session presents it as a set of design decisions made in response to practical constraints in latency, memory, context length, and system efficiency. Attendees will leave with a clearer mental model of what remained stable, what changed, and why those changes matter.

A tactical, hands-on session where attendees optimize a real build pipeline live with Blacksmith. They’ll leave with practical insights, proven techniques, and a checklist to apply immediately to their own environments.

Build a complete CI/CD pipeline for a pet adoption application in this hands-on workshop. Starting with your first workflow, you’ll automate testing, secure the software supply chain with GitHub security features, improve performance with caching and matrix strategies, and deploy to Azure. You’ll also create a custom action, reuse workflow logic across repositories, and enforce organizational standards with required workflows and branch protections. By the end, you’ll understand how GitHub Actions can take an application from commit to production with secure, scalable automation. Familiarity with Git basics is recommended, and an Azure subscription is required for the deployment exercises.

Agentic AI-assisted engineering tools promise cleaner code, faster development, and fewer late-night debugging sessions. But do they truly deliver? In this live showdown, Viktor and Baruch will each use a different set of cutting-edge AI coding tools, like an IDEs and CLI agents (we'd name them, but honestly, things move too fast in this space), to develop a non-trivial IoT application, from initial setup to testing and debugging, all live on stage. Will the IoT bulb turn on by the end of the session, and which tool will make it happen? You don't know, we don't know, but we'll find out together—live on stage. You, the audience, decide which tool actually improves quality and productivity and which just adds noise instead of useful code. Bring your skepticism, cast your vote, and get ready for surprises.

AI SRE agents are becoming the modern way to investigate alerts and incidents, but they are only as good as the telemetry they are fed. Without a solid data foundation, an agent is guessing. OpenTelemetry closes that gap: it gives us a vendor-neutral, industry-standard signal set that large language models can actually reason over. This workshop walks the full path from scratch - and without touching application code. Instrumentation is added entirely from the outside, so services are covered as they run rather than after a refactor. From there we wire it up through the OpenTelemetry Collector and ship the data to a central backend, then hand off to the agent (dash0 Agent0) and close the loop: alert fires, agent investigates, agent correlates traces, metrics and logs, and drafts a ready-to-merge PR with the fix. You will leave with a concrete blueprint for the full circle - observing, alerting, and acting autonomously - built entirely on open standards, with no code changes required to get there.

At Netflix, performance waste is everywhere- and almost no one is looking for it. Degradation is silent. It compounds. The manual cost of closing the loop (profile, analyze, trace, fix, validate) means most inefficiencies quietly burn compute for months before anyone acts. By the time a human gets there, the damage is done. We decided the loop should close itself. We built an autonomous agent that continuously hunts performance inefficiencies across live production services, traces them to source code, proposes fixes, and validates results through canary deployment- grounding every decision in measured production outcomes, not model confidence. In this talk, we'll share what it actually took to make an autonomous agent trustworthy enough to act in production: where it earns autonomy, where it doesn't, and a novel approach that changed how we think about agent reliability entirely. One finding the agent surfaced- caught, fixed, and canary-confirmed- with no ticket, no oncall, and no performance engineer in the loop. This is not a demo. This is already in production at Netflix.

Ben Gilbert and David Rosenthal are taking the main stage to conduct a series of live interviews. The pair host Acquired, the #1 technology podcast on Spotify and Apple Podcasts with over 1 million listeners. Acquired tells the stories and strategies of the world's greatest companies—each episode is a deep dive into a single company's history from its founding until today. Ben and David personally handcraft each episode over 200 hours of research and production. From founders to Fortune 500 CEOs, Acquired has interviewed some of the most influential leaders in technology and business, such as Jensen Huang, Mark Zuckerberg, Steve Ballmer, Morris Chang, Matt Garman, and Jamie Dimon.

LLMs proved that scale and compute can turn raw sequences into general-purpose intelligence. At Nu, we've been pointing that same playbook at a very different sequence, a person's financial history, and asking what it takes to build the production systems around it that responsibly shape the decisions that Nu makes across its 139 million customers in Latin America. This talk is a look at what it takes to build a modeling and decisioning engine that Nu can depend on. It spans our data research to represent transactions as a language, our foundation model, nuFormer, that learns rich customer representations from these trillions of transactions, and ends with the constrained optimization that turns those representations into decisions that determine how we offer and price products for our customers.

As AI agents become the communication and action layer of the enterprise, how do companies control what they access, what data they use, and what they say or do? Who is responsible when an agent violates a policy or regulation, and how do you monitor and audit millions of AI interactions in real time?

Every LLM API call looks simple on the surface. But under the hood, it’s a deeply layered systems problem spanning kernels, compilers, GPU scheduling, and distributed inference infrastructure. In this session, Dan Fu, VP of Kernels at Together AI, breaks down what actually happens when a request hits a modern AI model—and how inference performance is ultimately determined. He walks through the full inference stack, from tokenization and model execution to GPU kernel dispatch, memory movement, and serving-time orchestration, highlighting where inefficiencies accumulate and why today’s systems operate far below theoretical hardware capability. Drawing on both cutting-edge systems research and production-scale infrastructure experience—including foundational work like FlashAttention, now widely adopted across the AI ecosystem—Dan unpacks the core bottlenecks in modern inference stacks. He also outlines where the largest efficiency gains are still available, and why kernel-level optimization is becoming a critical lever in scaling AI systems.

All programming languages have their foundations: the engine that interprets your code and makes everything run. In PHP, this is the Zend Engine, a critical piece of software that powers millions of applications worldwide. When everything works, you don’t even think about it. You deploy to production, and the engine does its magic behind the scenes. But what happens when something goes wrong in that core? What if a subtle bug opens the door to a full security breach? Suddenly, the invisible foundation becomes the most important part of the story. Let’s shine a light on two such cases: a recent, real vulnerability in the PHP engine (which has since been patched), and a backdoor that, just a few years ago, actually made it into the release candidate and allowed remote code execution. We’ll walk through how each issue could be exploited and, most importantly, what lessons developers can draw from them. And yes, there will be live, local, sandboxed demos of both exploits in action. Ready to dive in?

Some of the largest real-time platforms in production today operate at scales that were considered theoretical a decade ago. CrowdStrike has publicly disclosed that its Falcon Threat Graph processes more than a trillion events per day across 15-plus petabytes of data, with engineering blogs describing 40-plus petabytes stored and 70 million requests per second served. Numbers like these are not unique to security — AI agent platforms, observability backends, and large SaaS analytics systems are pushing into the same territory. The interesting question is not the headline figure. It is what actually breaks at that scale, and which architectural choices keep the system honest. This talk distills patterns and failure modes from years of building streaming and AI data platform infrastructure, framed against publicly disclosed industry references rather than any single employer's internals. Topics include: - Stateful streaming joins across different data streams - Handling replay storms and out-of-order events without latency collapse - The honest tradeoffs between latency, cost, and correctness — and when each one wins - Observability and degradation modes that keep the platform usable when something is failing Attendees will leave with concrete guidance on designing real-time systems that fail loudly, recover predictably, and surface the metrics that actually matter at scale. Note: Views are my own and do not represent any employer. Examples reference publicly disclosed sources.

As agents increase the velocity at which code gets written, platforms get modified, and documentation gets updated, the things teams rely on can change faster than any human can track, validate, or understand. Call it Agentic Drift. Agentic Drift shows up as pipelines failing at increasing frequency, vulnerability counts creeping upward, internal tools that have quietly evolved away from their original intent, and documentation that no longer reflects how a system actually works. Teams are already experiencing it but the frameworks for managing it are still emerging. This talk introduces Agentic Drift and how to solve it. Drawing on experience building and operating developer platforms alongside AI agents, we'll cover: - how to detect drift using signals your team already has: CI/CD pipelines, observability tools, security scanners, and end-user feedback - how to design remediation pathways that fit your team's risk tolerance, from triggered reviews to continuous validation - a model for keeping humans meaningfully in the loop without becoming a bottleneck to the velocity agents provide The future of software engineering is about more than what agents can build. We also need to design teams and systems to keep pace with these changes.

Cloud inference provides unparalleled scale and capability, but mission-critical operations in disconnected environments - like factory floors or remote field sites often require immediate, localized intelligence. As enterprises move beyond chat interfaces into real-time, autonomous actions, building a hybrid architecture that seamlessly bridges the cloud and the edge becomes essential. This session tackles the engineering realities of deploying localized AI. We will explore how to architect systems that run Small Language Models (SLMs) and specialized reasoning engines directly at the edge, integrating seamlessly with local IoT telemetry and industrial systems. Attendees will learn how to balance localized reasoning for immediate, privacy-safe decision-making with asynchronous cloud syncs for heavy processing. You will walk away with practical patterns for overcoming hardware constraints, managing offline-first AI deployments, and building intelligence that works reliably everywhere.

In the rapidly evolving landscape of computing, Graphics Processing Units (GPUs), Language Processing Units (LPUs), and Tensor Processing Units (TPUs) play pivotal roles in accelerating complex tasks, particularly in machine learning and artificial intelligence. GPUs are renowned for their parallel processing capabilities, making them ideal for rendering graphics and handling large datasets. LPUs are specialized for optimizing natural language processing tasks, enhancing efficiency in understanding and generating human language. TPUs, developed by Google, are tailored specifically for training and inference of machine learning models, offering significant performance advantages for large-scale AI applications. As we explore these technologies, we'll also look at emerging processing units designed for specific AI use-cases and the future of computational advancements. Join me to dive into the intricacies of these processing units, their applications, and what lies ahead in the world of computing technology.

Serving AI inference across mobile browsers, native apps and enterprise integrations is not a single engineering problem. Latency tolerances, client capabilities and failure models all differ. Getting it wrong at scale means degraded experiences for millions of users. In this session, Wayne Liu, Chief Growth Officer and U.S. President of Perfect Corp., will share concrete engineering lessons from building and operating API-first AI infrastructure that handles millions of real-time interactions across diverse deployment environments. During this session, Wayne Liu will uncover: - The latency vs. accuracy tradeoff in real-time AI APIs and how to deliberate decisions - Architecture patterns for serving AI across varied clients and what changes between mobile, web and enterprise environments - How abstraction layers that simplify complex inference (such as facial mapping and real-time rendering) work under the hood - Infrastructure decisions that have an outsized impact on cost, reliability and developer experience in high-volume AI deployments

In large-scale systems, multiple teams, third-party integrations, and shared codebases can make testing feel impossible to coordinate. In this session, Bartosz and Pawel reveal how to bring order to that chaos using a unified full-stack testing strategy inside a monorepo architecture that powers both React and React Native applications. They’ll show how to combine contract, integration, gRPC, API, and visual regression testing into one consistent framework that helps teams work independently without breaking each other’s services. You’ll learn how TypeScript and shared logic enable type-safe, scalable testing across platforms — and how this approach speeds up releases while reducing integration pain. Expect practical patterns, real examples, and lessons learned from building test architectures that survive complex, distributed environments.

Ben Gilbert and David Rosenthal are taking the main stage to conduct a series of live interviews. The pair host Acquired, the #1 technology podcast on Spotify and Apple Podcasts with over 1 million listeners. Acquired tells the stories and strategies of the world's greatest companies—each episode is a deep dive into a single company's history from its founding until today. Ben and David personally handcraft each episode over 200 hours of research and production. From founders to Fortune 500 CEOs, Acquired has interviewed some of the most influential leaders in technology and business, such as Jensen Huang, Mark Zuckerberg, Steve Ballmer, Morris Chang, Matt Garman, and Jamie Dimon.

As enterprises deploy agentic AI, everyone's building capabilities—but who's building the guardrails? When an autonomous agent generates a prompt containing AWS credentials, or a compromised data source injects malicious instructions, what stops that payload from reaching the LLM? This session reveals how I built SecurePrompt, a pre-flight security scanner that intercepts prompts before they're sent to any AI model—addressing the critical blind spot at the boundary of autonomous AI systems. You'll learn: 1. Real-world scenarios where credentials leak, prompt injections propagate, and PII compliance fails 2. Why I chose Go and rules-based detection for sub-10ms latency 3. Parallel scanning architecture for secrets, injection attacks, PII, and data exfiltration 4. Policy-as-code profiles for enterprise risk tolerances 5. HMAC-signed audit logs with causal traceability 6. Evolving from deterministic rules to LLM-powered semantic analysis Leave with practical patterns for implementing security at the prompt boundary—the layer nobody else is building.

Commerce engineering spent 2026 building for the agent. UCP, ACP, AP2, MCP endpoints, Instant Checkout integrations. Meanwhile the merchant's own site, still where most revenue converts, has discovery that has not materially improved in a decade. These are treated as two roadmaps. They are one problem, and the second one is the reason the first one underdelivers. Here is the connective fact. Roughly 63% of zero-result site searches come from subjective, use-case queries: "bike for commuting", "something for a beach wedding". Around 81% of US shoppers abandon after an unsuccessful search. That query shape is exactly what an AI agent sends you. If your own search cannot answer it, neither can the agent, and no payment protocol fixes that. Meanwhile Adobe finds product pages are the least machine-readable surface on the average retail site at 66%, worse than the FAQ page, while AI-referred traffic converts 54% better than non-AI traffic and grew 693% year over year over the 2025 holiday. This session makes the case for 360 degree discovery: every surface a human or machine can find a product through, served from one product layer. I will walk the four things it requires: universal agentic feed deployment as table stakes rather than strategy; clean and enriched product data as the foundation everything else silently depends on; three search surfaces rather than one; and visualization, including virtual try-on, as the step that converts finding into buying. Plus the nine-week triage: what is realistically shippable before holiday freeze and what is not.

AI has collapsed the cost of writing software - agents and assistants produce more code, apps, and services than ever. Production has not gotten easier: all of it still has to be deployed, run, and debugged, often without a human who understands the code. How the production stack is changing now that much of the software it runs was written by machines.

Cybersecurity has hit a bottleneck. The problem isn’t gaps in detection or coverage, but because software was built for humans. Most security tools assume a human-in-the-loop paradigm: alerts surface in dashboards, analysts triage, and engineers remediate through workflows. However, software is no longer just consumed by people. AI is increasingly shouldering the work. Attackers already operate this way, using AI to tailor their campaigns, automate reconnaissance, and chain exploits at machine speed. Human-centric software design isn’t just sub-optimal, it’s detrimental for machine use in an AI-driven landscape. Developers have already embraced the “as code” paradigm. Infrastructure and pipelines became code, and AI coding agents pushed execution into a programmable layer. When it comes to cybersecurity, software is overdue for a complete redesign: flexible, directly consumable by AI, and built for autonomous execution at machine speed. This talk introduces headless security: a fundamentally different architecture in which security products are no longer interacted with directly, but consumed via APIs and composed and executed by coding agents. The control loop – discover, prioritize, remediate – moves from dashboards to the environment where software is built and run. This model reshapes system design and responsibility boundaries. Humans shift from operators to governors, defining intent, constraints, and risk tolerances while agents execute. Security becomes part of the development surface – where workflows are programmable, testable, and version-controlled, with risks resolved inline as code. Loris will explore how this model works, with implementation and real-world scenarios, including the engineering and security challenges of enforcing trust boundaries and ensuring auditability in a UI-less system. The future of security is not operations and dashboards. It is outcome-based, meaningful for every user, and embedded in how software is built and run.

We are entering a new era where AI agents are first-class users of data infrastructure. These systems don’t behave like traditional applications. They operate in loops, branch workflows continuously, retry autonomously, and demand immediate access to real data. The result? A fundamental shift in how databases must be designed and operated. In this talk, we’ll explore how agentic workloads are redefining database requirements, from latency expectations to isolation models, access control, and data privacy. We’ll look at why traditional staging environments and replication strategies struggle under this new pressure and how emerging patterns like copy-on-write branching and ephemeral environments change the game. If you build backend systems, data platforms, or AI-driven applications, this talk will help you understand what “agent-ready” really means and how to design for it.

Anyone can generate 40,000 words with an LLM today. Almost none of it survives contact with a reader. At story.one, we generate complete non-fiction books – 17 chapters, printed and sold in real bookstores – and over the past 18 months we read and scored more than 1,000 of them, cover to cover. This talk is the engineering story of what we found. Why long-form generation fails in ways chatbot demos never show: phrase tics, structural repetition, fabricated quotes, visible seams between regenerated passages. Why the model is the smallest part of the problem. And how we built a release standard around a neurosymbolic idea: fast neural generation, slow symbolic verification – deterministic checks in code (quote verification against original sources, style-pattern detection, structural gates), blind evaluation with fresh context, and a nightly regression suite of real-world cases. You will leave with three transferable lessons for any long-form GenAI product – and you will see a book that was generated, verified, printed, and sold the same day.

Logging systems are designed to help us understand failures, but what happens when the Logging itself becomes the cause of an outage? In this session, I will walk through a real-world incident involving Amazon ECS where the default logging configuration used blocking mode with CloudWatch as the log destination. When CloudWatch experienced an outage, application containers continued attempting to push logs while buffering them locally. As the logging buffer reached its limit, containers became blocked waiting for the logging driver, ultimately impacting application availability. This talk explores how a seemingly harmless default configuration can create an unexpected reliability risk in distributed systems. We will look at how ECS logging works under the hood, why blocking mode can create cascading failures during downstream outages, and how switching to non-blocking mode can isolate application workloads from logging system failures. I will share the investigation process, architectural decisions, and practical lessons learned from redesigning the logging strategy to prevent observability dependencies from affecting production workloads. Attendees will leave with actionable guidance on designing resilient logging pipelines and avoiding a class of failures where logging infrastructure unintentionally becomes the single point of failure.

Travel is a complex industry, and at Expedia Group that complexity is becoming a proving ground for AI-enabled innovation and a new kind of engineering leadership. In this fireside chat, Expedia Group engineering leaders share how they are rethinking the software development lifecycle in the AI era — from early AI tooling adoption toward connected, purpose-built agentic systems. They’ll discuss what is changing in practice: how AI is helping teams ship higher-quality experiences faster, how smaller teams are delivering work in fewer sprints, and how impact is being measured through cycle times, velocity, output, and business outcomes—not adoption alone. They’ll also explore the next phase of Expedia Group’s AI strategy: agents inside Expedia Group that help employees move faster, supported by responsible AI guardrails and a flexible technology foundation. Come for a grounded, practitioner's view of leading as the stack and tooling evolve at a breakneck pace.

Vibe coding is real, and it's useful — it's how you rapidly explore ideas and prove out concepts. But by definition, vibing means using AI for something you're not deep in yourself, and that's precisely why it can't be where production code comes from. Production starts earlier than people think: with specs that get adversarially reviewed before a single line gets written, then the engineering expertise to know what good looks like, and the agentic harnesses, domain modeling, and durable testing that enforce it at scale. AI doesn't replace that expertise — it multiplies it, letting people who already know what they're doing move faster and build better. Practical, technical, and grounded in what PwC has built and learned in production.

Most platforms add AI agents as apps: the agent runs with the permissions of whoever invokes it. Simplest thing to ship. Across hundreds of thousands of teams, serving enterprises that audit every access, that model fell apart. This is how we rebuilt agents as first-class users, with their own identity, permissions, and audit trail. The first architecture was the obvious one: an agent could do only what both it and the invoking user were allowed to do. Simple to build, it broke at scale. The agent's access changed with every invoker, so no one could say what it could actually reach. Actions were attributed to the human, leaving no per-agent audit. And a shared agent became a leak risk, exposing its invoker's data to everyone allowed to run it. Fixing this meant making a non-human a first-class user inside a system built for humans: its own identity, scoped least-privilege permissions, admin-managed provisioning, and a place in the workspace where it can be assigned work and audited. The payoff was counterintuitive. Once an agent is a user, 20 years of enterprise identity infrastructure (SSO, RBAC, provisioning, audit logs) works for it for free, instead of a separate control plane for AI. One enterprise built 25 agents, each needing different access. Before, any agent could read what its invoker could read and pass it to the whole team. Now each is shared across the team and never touches data it was not explicitly granted. The permission models, the tradeoffs we got wrong first, and what it takes at scale. From the applied AI perspective, why agent identity is the central design problem for AI at work. Expect real systems and real failure modes.

Performance is the most overlooked problem in mobile engineering — not because engineers don't care, but because it's invisible. When something crashes, there's a log. When servers cost too much, there's a bill. When an app is slow, users just leave. No alert fires, no ticket gets filed. That invisibility is the whole problem, and the talk is a systematic answer to it. The framework it introduces — Performance, Reliability, Efficiency — exists to show that these three things are connected and pull against each other. Making one screen faster can make the whole system more expensive. Understanding the trade-offs is what separates reactive firefighting from deliberate engineering. The core of the talk is a cycle: instrument the app, collect the right data, analyze it, prioritize what to fix, implement, and validate. The instrumentation piece is more nuanced than it sounds — what you measure and where you start the timer matters. The rule is to measure what the system does, not what the user does, because user behavior introduces noise that makes the data useless. Once you have data, averages mislead. Percentiles tell the truth. A small number of metrics — median latency, tail latency, success rate, failure rate, abandonment rate — gives a complete picture of any screen. Abandonment is the one most teams ignore, and it's the most honest signal: a user who left before the page loaded is a direct conversion loss that shows up nowhere in traditional monitoring. The abandonment curve is where engineering data becomes a business argument. It shows exactly how increasing load time drives users away, with a clear inflection point above which every additional millisecond has an outsized cost. That curve, combined with traffic volume, tells you where to focus: a small improvement on the screen every user sees daily is worth more than a large improvement on a screen almost nobody visits.

Meetups often die the same way. People show up once, have a fine time, and never come back. Code & Coffee is a nonprofit that runs 300 meetup events a year across 30 cities for a community of 80,000 members, on an annual operating budget under $6,000 and with almost no paid marketing. It only works because people return for an actual community, not just another audience. This session is about meetup and community design. Steve will show how Belonging, Trust, and Safety translate into specific decisions rather than values on a slide: the intro-circle ritual run at every event, the cadence rule organizers have followed since 2017, and why Code & Coffee events are social by default instead of built around endless talks. Steve will also cover the unglamorous operations: where to find a free venue in your city, what to ask a sponsor for, and what to offer in return. If you have ever wanted to organize a meetup community, run events, grow a developer community, or have simply been waiting for someone else to start the meetup you want to attend, this talk is for you. You will leave with a repeatable meetup event format you can adapt and a concrete first step you can take toward building community.

Modern AI systems are incredibly capable and confidently wrong. In this talk, we explore a new architectural pattern: AI systems that argue with themselves. By orchestrating multiple AI agents with opposing perspectives, we can uncover hidden bugs, reduce hallucinations, and dramatically improve output quality without adding human reviewers to the loop. I’ll demonstrate how to design and implement a self-debating AI system using real-world examples: debugging code, validating architectural decisions, and stress-testing product requirements. We’ll explore when AI disagreement is useful, when it fails, and how to measure improvement beyond “it feels better.”

AI is everywhere. In your editor, your terminal, your code review, your inbox, your search bar—and probably your toaster by the time this talk happens. We're not here to pretend otherwise, and we're not here just to dunk on it. This keynote is an honest look at what happens to us, as developers and as people, when we outsource our thinking at scale. We're living in a genuinely exciting moment. Modern tools are more accessible than ever, shifting us from conforming to existing SaaS toward building personal tools and personal software. But the cost is real: AI "slop" is showing up in open source pull requests, documentation, code reviews, and emails. The internet is filling with content humans didn't really think about, and the habit of thinking hard is eroding. This talk explores the nuance. It's not simply "AI good" or "AI bad." We'll cover guardrails, speaking up for quality, and continuing to think better—because our brains are resources we have to keep for the rest of our lives.

Tabular Foundation Models are redefining enterprise AI by bringing foundation-model capabilities to structured business data. This session explores SAP's latest innovations, including the RPT-1.5 model and the recently acquired Prior Labs, creators of TabPFN, while also reviewing the latest academic advances. Hear from Tech leaders how these innovations are shaping the next generation of AI-powered enterprise applications through more accurate predictive analytics, intelligent automation, and business decision-making

AI is collapsing the cost of exploiting vulnerabilities in software systems. Agents are autonomously scanning for weak links and executing attacks that would otherwise take weeks or months, completely upending the conventional cybersecurity playbook. For decades, cybersecurity focused on making attacks too slow and expensive to be worth the effort. This session breaks down how agentic AI is changing the speed and scale of modern cyber threats and what engineering teams can do to respond. The session will examine practical strategies to shrink the attack surface, keep a capable model you control ready before an incident, and push toward primitives that make whole classes of attack cryptographically impossible rather than merely operationally unlikely.

Most teams think KV cache is about making inference faster. That's true, but it's not the point. KV cache is really about controlling memory, reducing recomputation, and keeping costs from spiraling as usage grows. As models get deployed at scale, the real bottleneck is no longer raw compute. It's memory, bandwidth, and power. This session takes a step back to explain what KV cache does at a system level, why it matters for real workloads, and how approaches like vLLM, LMCache, and SGLang change how we think about scaling inference. We'll also connect this to a problem many teams are already seeing: confidently incorrect answers in agent systems. When cache behavior, context reuse, and routing aren't designed well, systems don't just get slower or more expensive. They get inconsistent. And that shows up as wrong answers with high confidence. This session will walk through these trade-offs using live demos, showing how different KV cache strategies impact cost, latency, and output quality in real time.

AI is making it easier than ever to write code, but shipping it is becoming the harder problem. As developers and coding agents produce more code, codebases are growing, CI workloads are increasing, and build and test times are becoming a bigger constraint on engineering velocity. This talk explores why code validation is emerging as the new bottleneck in software development, and why the teams that can build, test, and ship faster will have a meaningful competitive advantage.

With a global daily user base in the hundreds of millions, AI agents are rapidly becoming a primary interface for how people discover, evaluate, and purchase products. Enabling those products to be listed and paid for directly through agents opens an entirely new, and enormous, commerce channel. The Agent Commerce Protocol (ACP) and Shared Payment Tokens provide a secure framework for agent-driven commerce within Stripe’s ecosystem, without exposing payment data or sacrificing user control. This session walks developers through the complete implementation: setting up Stripe integration, creating permission-based payment tokens, interacting with ACP endpoints, and designing trustworthy user experiences. You'll learn how to enable your agents to transact safely and predictably, handling everything from checkout flows to error scenarios and webhook events.

AI agents write more of your code every day, and their failures are getting rarer but more convincing. When the output looks right, reviewers stop looking hard, and a subtle bug or insecure pattern spreads across the codebase at machine speed. The fix is not a better model. It is independent, multilayered verification: checking code with different methods than the one that wrote it. Algorithmic analysis catches what is provably wrong, agentic review catches what needs judgment, and together they stay auditable instead of just agreeing with the agent. This is the Verify discipline at the heart of Sonar's Agent Centric Development Cycle (AC/DC), where agents generate and a separate layer guides, verifies, and helps solve what it finds. We put the leading LLMs through a deep evaluation and found clear, repeatable patterns in where they break. You will see that data, and how to put this verification around your agents so you keep the speed without the risk.

Developing great software takes more than just writing good code. Which is why the GitHub Copilot App is built to go beyond the code! In this session, you'll discover how developers, business users, and all types of "builders" are using the GitHub Copilot App to supercharge their workflows, from prioritization and documentation to data analysis and cross-team coordination. Through a short demo grounded in real customer examples and GitHub's own use cases, you'll experience how different organizations are enabling builders to unlock their superpowers through the GitHub Copilot App. Walk away with practical patterns for not only yourself, but to accelerate adoption at your organization.

The software development paradigm is shifting, moving AI from a helpful suggestion engine to a collaborative partner. This hands-on session is designed for developers ready to elevate their workflow by integrating powerful AI Command Line Interface (CLI) tools directly into their pair-programming sessions. We will conduct a live comparison of leading tools, specifically focusing on Google Gemini, Anthropic's Claude Code, and OpenAI Codex (or similar contemporary offerings), demonstrating how they act as reliable, functional counterparts—not just code generators. Attendees will see detailed, real-world examples outlining: How to structure effective prompts for complex, multi-step tasks. Deep dives into capabilities like codebase summarization, targeted refactoring, and test generation. Identifying and mitigating common issues like context drift and tool-specific latency limitations. Critically, we emphasize that this is not about "vibe coding"—mindlessly accepting AI suggestions—but about adopting a structured, professional, and efficient way to develop.

Sixty-two percent of public company boards now dedicate agenda time to AI. Fewer than 10 percent have approved budgets for AI projects or adopted meaningful metrics for reporting on them. That gap :between awareness and action :is where AI initiatives go to die. As a board director and former senior P&L executive who has reviewed dozens of AI initiatives across multiple companies, I've seen the full spectrum: structured projects with clear ROI thresholds, and aspirational efforts with no owner, no baseline metrics, and no path to integration. The pattern is consistent :the projects that fail aren't the ones with bad models. They're the ones with no governance framework around execution. In this talk, I'll share practical frameworks that engineering leaders and product teams can adopt to make their AI projects board-ready and business-accountable. I'll walk through the Technology ROI Matrix :a method for evaluating AI initiatives across strategic alignment, investment efficiency, and execution readiness :and the Stage-Gate model adapted for AI, which establishes clear success criteria at each phase from discovery through scale. I'll cover the critical questions every AI initiative should be able to answer: What baseline are we measuring against? Who owns the outcome? How do we detect when the AI system deviates from expected behavior? What's the full cost of building, operating, monitoring, and refreshing this system? This isn't a talk about compliance checklists. It's about the discipline that separates AI projects that transform businesses from ones that quietly drain resources. Whether you're a developer advocating for an AI initiative, an engineering leader allocating budget, or a CTO reporting to a board, you'll leave with actionable evaluation frameworks you can apply immediately.

You know that - A demo works on your laptop, then you deploy it elswere and it's not. Migrating a Kubernetes workloads from one platform to another is not just flipping the switch. I created the LLM app utilizing a small quantized open model (~4B, CPU-only, serving inside the cluster) running it on a local kind cluster on my M4 MacBook. However, once moved to the AWS EKS, the pod died with 'exec format error'. The fix exposed the next failure, and the next... a liveness probe killing the model server mid-load, ':latest' meaning different images on different clusters, kubelet garbage-collecting the multi-gigabyte model weights, a hardcoded DNS suffix, a NetworkPolicy silently doing nothing. Let's find out what lies between "works on my laptop" and "runs anywhere", because "Build once, deploy anywhere" is a claim you must earn.

In this hands-on session, you will actually build, launch, and go home with a live website of your own. We will guide you step-by-step from a blank canvas to a fully working site hosted live on Google Cloud. If you are feeling creative, you can even go beyond a simple website and experiment with more advanced, full-stack ideas. You will walk away with a permanent, live web link that is yours to keep, share, and continue building on. - Turn your creative ideas into a fully functional website. - Publish your site to the web, giving you a live link you can share with the world. - Experiment with AI to customize your project, fix issues on the fly, or build advanced features.

Everyone’s convinced a few good prompts can build a real platform. This masterclass puts that assumption to the test: 10 chapters, 10 live demos, one takeaway — vibe-coding your way to an enterprise-grade Content Platform still means reinventing what TYPO3 CMS’s version 14 already does. The real shortcut isn’t prompting from scratch — it’s building on top of a platform that’s battle-tested and enterprise-ready.

Security isn’t just about firewalls and patches, it starts long before the first line of code is deployed. In this workshop, we’ll explore how threat modeling helps teams move from a reactive security mindset to a proactive, design-first approach. You’ll learn how to identify vulnerabilities before they become incidents, map out potential attack paths, and make risk-informed decisions, all before the build is complete.

One agent. Fully deployed to production before the workshop ends. We'll take you from a blank file to a running production agent using Amazon Bedrock AgentCore and Strands Agents, covering the full lifecycle: ideation, coding the agent loop, deploying to serverless infrastructure, wiring up observability, breaking it intentionally, fixing it with tracing data, and shipping the final version. Bring your laptop and leave with a deployed agent.

What can a Formula 1 driver teach a software developer about working with AI? This session follows where the value sits when work moves at a very high speed and how Mercedes-Benz is approaching the way AI is changing the way we work, what it means for developers, for leaders and the workforce as a whole.

Every product now has AI features. Most of them go unused. Enterprises buy copilots that employees ignore, consumer apps ship AI that users try once, and roadmaps fill with capabilities nobody asked for. The gap between shipping AI and getting people to actually use it has become the defining product problem of the AI era. How teams decide which AI features to build, how they drive real adoption instead of demo applause, and what they killed along the way.

Coding agents can write and review code, but they still work mostly blind to what happens after that code reaches real users. That is changing. Scott Voigt, co-founder and CEO of Fullstory, joins Justin Halsall, core team maintainer and CEO at rrweb, for a fireside chat about making session replay usable by AI. Fullstory helped create the market for modern session replay. rrweb made session-replay technology open source and available for any developer to build on. Agents are starting to watch real user journeys, spot failures and friction, propose fixes, and check whether those fixes worked. In some cases, this full loop is already running. Scott and Justin will discuss what works today, what still goes wrong, and what teams must solve before trusting agents with more of the development process. That includes privacy, noisy data, verification, and deciding how much autonomy to give an agent. What happens when an agent can see not only the code, but what users did with it?

LLM-accelerated coding has dramatically increased the pace at which developers can fix bugs and write whole new features. But a lot of companies that have wholeheartedly embraced AI assistance for coding have discovered that with coding fast, new points in the software development lifecycle become the bottleneck. In particular, if people are writing code 2x, 5x or 10x faster, how do you review all that code? This talk explores the current landscape of solutions to this extremely timely problem, including changing job titles, building guardrails, writing far more detailed product specifications and tests, using yet more LLMs to review the PRs themselves, and a surprisingly frequently-cited alternative: just ship stuff slower.

The true power of AI agents lies in their autonomy—their ability to reason and access internal/external tools dynamically. However, giving agents execution privileges introduces immediate security and cost vectors: prompt injection attacks escalating to host compromise, and traditional container models burning through cloud budgets on idle compute. This talk moves past naive agent sandboxing to present a zero-trust, serverless architecture built for high-concurrency agent swarms. We will examine how to bridge the gap between autonomous tool execution and strict system isolation by leveraging WebAssembly’s capability-based security model. Using CNCF Spin and Akamai Functions, we will build a globally distributed execution fabric from scratch that scales sub-millisecond workloads from zero to thousands of concurrent requests with near-zero idle overhead. We will cover technical areas like: Capability-Based Security: Replacing coarse container permissions with Wasm’s default-deny isolation to restrict agent network, memory, and filesystem access at runtime. Sub-Millisecond Execution: Bypassing Docker cold starts to spin up disposable micro-sandboxes on demand for individual tool calls and code execution steps. Globally Distributed Swarms: Edge-native orchestration patterns that keep compute close to the user while maintaining centralized policy enforcement. You will leave with a production-ready blueprint for securing autonomous workflows, turning untrusted agents from an operational risk into an auditable, deterministic asset."

While "Cloud Native" promised portability, that promise often stops at the boundary of a single infrastructure provider. The traditional definition of Cloud Native rarely addresses the reality of multi-cloud environments, leaving enterprises with deep vendor coupling through fragmented SDKs, distinct authentication flows, and proprietary APIs. It is time to evolve to Multi-Cloud Native, a development paradigm where applications are designed from day one to be agnostic to the underlying provider. In this session, I will explore the architectural principles required to build truly portable applications using driver-based design patterns. I will demonstrate how these patterns are implemented in the ecosystem today, focusing on MultiCloudJ (Salesforce’s open-source Java SDK) and Go Cloud (Google’s open-source Go library). These libraries provide consistent programming models that decouple business logic from cloud providers, enabling a true "write once, deploy anywhere" capability. Drawing from Salesforce’s real-world journey operating hyper-scale services across AWS, GCP, and Alibaba Cloud, I will share the engineering challenges that necessitated this shift. Finally, we will examine the role of AI in this transition: specifically, how the Model Context Protocol (MCP) can analyze SDK usage patterns to automate the refactoring of legacy, vendor-specific code into modern, multi-cloud native standards.

Most AI coding session starts from zero. You explain your project structure, your preferences, your patterns. The agent does great work, you close the session, and tomorrow it's a stranger again. I got tired of re-teaching the same lessons every time I opened my projects. Kiro Crew is an open-source workspace where agents carry memory, lessons, and skills across sessions. When you correct something, it becomes a durable lesson the agent won't repeat, and repeated workflows become named skills. In this talk I'll show how persistent agent memory works and we'll walk through a demo workflow that visibly improves across sessions. You'll leave knowing how to set up a self-improving agent workflow and when to trust (or override) what it remembers.

Every enterprise thinks their AI adoption story is unique. It isn't. After leading GitHub Copilot's rollout across Fortune 100 engineering teams at Microsoft and before that, launching Gemini Code Assist at Google Cloud with hackathons in over 60 countries I've seen the same patterns repeat at scale: the initial excitement, the plateau, the backlash, and finally the transformation. This isn't a talk about features or benchmarks. It's about the human journey: how SDLC actually changes when AI becomes a collaborator, why adoption curves look nothing like what vendors promise, and what separates teams that truly level up from those who just add a new tab to their IDE. I'll bring real patterns from the frontlines with honest stories, no marketing spin.

Threat modeling was created for a time when the intended design closely matched what shipped. That is no longer true. Most teams still model what they plan to build, including user flows, design decisions, and evil user stories, but they rarely re-evaluate the model against what is actually deployed. Pipelines continuously uncover real risks through SAST, SCA, DAST, IaC scans, and cloud configuration checks, yet those signals are not fed back into the threat model. This creates a growing blind spot where decisions are based on assumptions instead of production truth. This session shows how to extend threat modeling beyond design and incorporate evidence from the built system. You will learn how to treat discovered vulnerabilities as inputs that evolve the model and how to update the model continuously without waiting for new platforms. The approach is practical and can be adopted with tools most teams already have.

Writing code is no longer the bottleneck in software development. Today, we can describe what we want in natural language and (mostly) receive entire applications in a few minutes. But while tools and demos move fast, a deeper topic largely stays behind: what happens to programming languages, compilers, and responsibility when humans stop writing the code themselves? We have all been promised, that everything will be done autonomously when AGI is here, but what about until then ... the next 3-5 years? Is your current stack/your current favorite programming language ready for real work relief professional environments? If software is increasingly generated from intent rather than authored line-by-line, then many assumptions baked into our current languages begin to crack. Syntax stops being the primary interface. Compilers are no longer just translators. Code reviews no longer guarantee understanding. And "the AI wrote it" becomes an unacceptable answer to questions of security, correctness, and long-term maintainability. We will explore how language design must evolve beyond syntax toward intent, constraints, and guarantees — and why this shift matters not just to developers, but especially to CTOs and tech leaders responsible for systems they may no longer fully read or write themselves. We’ll examine what responsibility means in a world of generated code, how engineering judgment changes when implementation becomes fluid, and why senior engineers become more critical—not less—in AI-native teams. Finally, we’ll look at which existing language ideas already point in the right direction, which ones quietly break under vibe-driven development, and what a future “vibe-aware” programming language would need to get right to be trustworthy in production. This session is an invitation to stop treating vibe coding as a novelty — and start treating it as a forcing function to rethink the core of software engineering itself.

Running large language models at scale can get expensive fast, but the right optimizations can cut latency and GPU costs dramatically. We’ll walk through how to serve models efficiently using vLLM, an open-source, high-performance inference engine. Then and generate and test quantized models, expose them through vLLM’s OpenAI-compatible API, and tune runtime flags to balance throughput, latency, and accuracy on different GPUs. We’ll benchmark performance live, inspect token-throughput metrics, and discuss real-world deployment trade-offs.

"What Changes for Customers, Users and Teams When AI Writes the Code There's a difference between using AI to build your product and building an AI product, and most engineering leaders are now doing both at once. In this main stage panel, engineering leaders from PagerDuty, Arize and Box dig into what that distinction actually means once AI-generated code is running in production and humans, not machines, are still the ones on call. They'll get specific about the harnesses, context management and governance decisions that mattered once the novelty of adoption wore off, where they've each drawn the line on trusting AI-written code without a human in the loop, and how they're deciding what infrastructure to own versus buy as agentic work moves from weekend prototypes to something that has to hold up at scale for customers and users. Expect a technical, opinionated conversation between three people who are still figuring a lot of this out in real time, not a highlight reel. Walk away with specific tactics you can bring back to your own team."

Session details will be announced soon.

Enterprises are rushing to build "Agentic AI," but they are falling into a dangerous trap: treating human transformation, platform engineering, and data sovereignty as isolated silos. Join Sebastian Kister to discover how to avoid the "Automation Paradox," architect a zero-hallucination predictability engine, and secure your data against the hidden sovereignty threats of modern AI plumbing.

Most teams still think of authorization as a security concern. In modern systems, it has quietly become a reliability concern as well. Authorization logic is no longer confined to one codebase. It is spread across application services, API gateways, background workers, data platforms, and now AI driven automation. Each layer makes its own decision, often with incomplete context and slightly different assumptions. This works until scale, automation, and non human identities turn small inconsistencies into systemic failure. In this talk, we will look at real world failure modes where authorization bugs manifested as cascading outages, stuck workflows, data corruption, or unexplainable behavior under load. We will show how fragmentation hides these problems until decision volume spikes, and why traditional testing and observability rarely catch them early. The session introduces a practical mental model for treating authorization as part of system reliability. We will cover warning signs that teams can spot before incidents happen, and architectural patterns that reduce blast radius without centralizing every decision or rewriting existing systems. Attendees will leave with concrete criteria for evaluating their own architectures, and a checklist for making authorization behavior predictable, testable, and explainable at scale.

As engineering organizations scale, merging code into a shared codebase becomes a major productivity bottleneck. Thousands of engineers changing code continuously can overwhelm build systems, slow feedback loops, and erode trust in the mainline. This talk explores how large teams keep builds green while maintaining high developer throughput by treating code integration as a systems problem. We’ll introduce the core ideas behind speculative merging, including dependency graphs, speculation trees, and invalidation, and show how predicting likely future states of the codebase enables parallelism without sacrificing correctness. We’ll examine why naive approaches don’t scale, how combinatorial explosion and finite CI resources shape real-world designs, and what tradeoffs are required to make speculation practical. Finally, we’ll share lessons learned from evolving SubmitQueue over several years, highlighting how build stability, fast feedback, and merge confidence directly impact engineering productivity.

AI coding agents are reshaping software development, but they are also creating demand for a new class of devices: hardware built specifically for interacting with non-deterministic, always-on personal agents. This talk explores the rise of agentic hardware through a real open-source device: a voice-first, AI-native controller for personal agents such as Claude Code, Codex, and OpenClaw. The device combines a 3D-printed enclosure, mini keyboard, LCD screen, microphone, ESP32-based firmware, and Bluetooth/Wi-Fi connectivity to create an interface that makes sense for AI agents rather than traditional desktop workflows. Using this device as a case study, I’ll walk through the full technical stack behind agentic hardware: PCB design and manufacturing, enclosure prototyping with 3D printing, embedded firmware on ESP32, networking and transport choices, and the WebSocket server architecture that bridges the device to agent runtimes running on personal computers. The session focuses on the engineering trade-offs involved in building hardware for AI-native interaction: latency, connectivity, input ergonomics, voice-first UX, power and form-factor constraints, and the challenges of integrating deterministic embedded systems with probabilistic AI systems. Attendees will leave with a practical mental model for building their own agentic devices, plus concrete lessons on where edge hardware is becoming essential in the age of personal AI agents. Open source repos covered in this talk: * Device firmware: https://github.com/second-state/vibekeys_firmware * WebSocket server that orchestrates AI agents and LLMs: https://github.com/second-state/vibetty * Open source voice recognition models: https://github.com/second-state/qwen3_asr_rs and https://github.com/second-state/cohere_transcribe_rs

When agents fail, it’s rarely because the model is weak, it’s because the context is weak. LLMs behave like pure functions: what goes in determines what comes out. That makes context the true battleground, and mastery of it a form of kung fu. Context Engineering Kung Fu is about developing precision, restraint, and control over what a model sees. This session goes teaches the fundamentals: how to write clean instructions, select only what matters, compress information without losing force, and isolate signals so they don’t interfere with each other. You’ll learn how context decays over time, why bloated prompts make agents slower and less reliable, and how to recognize when a model is overwhelmed rather than underpowered. We’ll also cover advanced techniques: when memory strengthens an agent and when it quietly sabotages one, how to structure context so it remains stable under iteration, and how to break complex problems into smaller, deliberate moves that models can execute with confidence.

As organizations rapidly adopt Generative AI and autonomous AI agents, ensuring the reliability, safety, and trustworthiness of AI-powered systems has become a critical business and engineering challenge. Unlike traditional software, AI systems introduce unique risks such as hallucinations, bias, model drift, prompt injection attacks, unpredictable behavior, and compliance concerns that cannot be addressed through conventional testing approaches alone. This session explores the emerging discipline of AI Assurance and the evolving role of quality engineering in validating AI systems at enterprise scale. Attendees will gain insights into modern strategies for testing and evaluating AI applications, including large language models (LLMs), Retrieval-Augmented Generation (RAG) systems, and AI agents. The discussion will cover key areas such as AI evaluation frameworks, safety and security testing, continuous model validation, observability, governance, and responsible AI practices. Through real-world examples and practical lessons learned, participants will discover how leading organizations are building confidence in AI solutions while balancing innovation, regulatory requirements, and customer trust. The session will also examine how quality engineering teams are evolving from traditional test execution toward becoming stewards of AI reliability, transparency, and accountability. Whether you are a quality engineer, software developer, architect, engineering leader, or AI practitioner, this session will provide actionable insights and a practical framework for building, testing, and governing trustworthy AI systems in production environments.

Most AI agent demos live inside a prompt window. Production agents need something more durable: memory, state, recovery, collaboration, and auditability. This talk argues that file systems are becoming a foundational primitive for agentic software. LLMs are already deeply trained on files, directories, command-line tools, codebases, Markdown, logs, and operating-system workflows. Instead of forcing agents through bespoke APIs for every task, developers can often build simpler, more reliable systems by exposing work through file-system-like interfaces the model already understands. We’ll walk through practical architecture patterns for file-backed agents: using files as long-term memory, organizing intermediate work, coordinating multi-step tasks, enabling human-in-the-loop review, synchronizing state, and preserving an auditable record of agent activity. The session includes a live demo of an agent operating over a cloud file system: reading task files, detecting human edits, updating related files, and showing an inspectable history of work. Attendees will leave with a concrete framework for deciding when to use files, when to use APIs or databases, and how to design agent workflows that are simpler, more inspectable, and easier to operate in production.

Most AI agents misuse MCP and treat tools as prompt-time function calls: tool definitions and results are repeatedly injected into the context, tokens are wasted, and context rots. The result? Slower, less reliable agents, and the misleading conclusion that “MCP sucks, CLIs are better.” To challenge this narrative and show how agents can get the best of both MCP and CLI, we’ve built `mcpc`, an open-source universal CLI client for MCP. It maps MCP operations to intuitive CLI commands, which agents quickly pick up through `--help` without external skills. It turns out, CLI is the perfect local interface for agents to interact with MCP, giving them access to full protocol capabilities, including modern features like code mode or progressive tool discovery, through a single `Bash()` tool call, while leveraging MCP’s standard remote interface for server discovery, authentication, payments, and access control. To once and for all kill the MCP vs. CLI debate and show those two technologies are not exclusive but complementary, we’ll present evals comparing the performance of agents using naive MCP, modern MCP, native CLIs, other MCP CLIs, and `mcpc`, in various real-world scenarios.

Here’s a question: would you build a REST API and make users guess the request and response formats? Doing so opens a Pandora’s Box… * What’s the domain model? * Name the operation… POST? GET? PUT? PATCH? * What does this error code even mean? * Is the documentation - if it even exists - accurate and relevant? Imagine the complex, repetitive logic every consuming system would need to implement to make sense of it all. In a distributed, asynchronous system, these problems are magnified. Apache Kafka's flexibility—messages as simple bytes—is a huge strength, but it's also a major risk. While your event streams likely consist of some structured data (maybe JSON strings), enforcing structure, managing evolution, and basic validations aren’t a hard requirement. This leaves consumer applications to perform this preprocessing of every event - even if that event has no business value. In this session, we'll define data contracts and how to enforce them at the source - the applications that produce events. We’ll cover the practice of using a schema registry - supporting popular serialization formats like Apache Avro and Google Protobuf - to design events in the terminology of our business domain. Because data structures change over time, let’s discuss safe schema evolution practices. Then we’ll utilize these contracts with schema registry-aware producer and consumer code. We’ll end our time by looking at how smart CI/CD pipelines and build-time checks can add an extra layer of defense against the costly problem of poison data. It’s time to stop guessing and start governing. Join us to learn how to move validation upstream and transform your event streams into high-quality, discoverable data products. You’ll walk away with a practical blueprint for enforcing schema integrity and automating evolution—ensuring your data streams are a trusted asset.

Everyone's pitching "agentic," "AI-native," and "autonomous" — but what's actually getting term sheets? In this fast-paced 30-minute conversation, Mariane Bekker (Head of Developer Relations, You.com) sits down with top VCs to cut through the noise and get specific: which categories are seeing real capital move, what separates a fundable agent startup from a feature wrapped in a demo, how diligence has changed now that every deck claims to be "agentic," and where the smart money is placing bets for the next 12 months. Expect direct answers, real portfolio examples, and zero fluff — a session for founders who want to know what VCs are actually looking for, not what they say at conferences.

Prashanth Chandrasekar, CEO, Stack Overflow Alexandra Lato, VP of Product, Stack Overflow

Cosine Similarity is like the social network of vectors—it measures how close two points are based on the angle between them. A 0° angle? Total BFFs, perfectly aligned. A 90° angle? Complete strangers, no common ground. It’s the secret sauce behind recommendations, NLP, and clustering, helping machines figure out who’s vibing and who’s not. Math has never been so… social.

Almost every asynchronous action at Meta passes through a single system most people have never heard of. The Facebook Ordered Queueing Service (FOQS), a fully managed, horizontally scalable priority queue, moves close to a trillion items per day for 300+ engineering teams, and it has become critical infrastructure for AI at Meta's scale. Async LLM inference, Llama serving, GenAI image generation, and AI compute demand control all ride on it. This talk traces how a queue originally built to absorb massive backlogs and prioritize work across highly heterogeneous producers and consumers grew into the reliability layer beneath Meta's AI stack supporting critical use cases like Ads, Integrity, AI Training and Whatsapp message delivery. It explains how one system came to serve hundreds of teams without them stepping on each other, how it keeps the most important work moving under enormous load, and how it evolved from isolated regional deployments into a globally distributed service that delivers region-level disaster recovery in seconds with zero client-visible downtime. The finale looks at how that same queue now acts as a control plane for shaping AI compute demand.

At Intuit, 5,000+ services run at peak 1M+ TPS across TurboTax, QuickBooks, Credit Karma, and Mailchimp. Eighty percent are multi-region. Before EWOK — our Ecosystem Wide Orchestrator Kit — disaster recovery meant thousands of non-standard DR scripts, per-team runbooks, and 8,000+ engineers each solving the same problems differently. Game days were feared. MTTR was unpredictable. DR was treated as "the database snapshot" — not the full stack. This talk is the story of how we made regional failover boring — predictable, repeatable, automated, no heroics. I will walk through the architecture and the hard lessons: • A declarative YAML DSL for DR plans — stages, parallel blocks, per-stage agent versioning (armador/v1, database/v1, route53/v1), inline IAM role assumption. • AWS Step Functions as the DAG orchestrator — durable state for long-running promotions (Aurora global cluster failover, Redis replication switch), and a visual audit log that doubles as the incident timeline. • A Golang control plane on Kubernetes running goroutine-parallel mutations across thousands of namespaces. • A Python Agent Framework with an ABC contract — PreCheck, Failover, PostCheck — encapsulating IAM, logging, metrics. Product teams shipped a Redis agent in days without platform bottleneck. • Specialized agents per layer: armador (compute/capacity), Route53 (DNS cutover), Database (Aurora global failover), Redis (flush + replication). • The multi-workload problem everyone skips — cron jobs, async consumers, stateful tiers, caches. Parallel suspend, scale, resume, dial. • Progressive Dial — incremental traffic shift with error-gated automatic rollback. • Auto Failover via our Alert2Incident framework. • Same machinery for migrations — same-region failover as an upgrade feature. You leave with: concrete patterns for declarative DR, a replicable agent contract for inner-sourcing reliability, and a checklist of the workload types your DR plan probably does not cover yet.

AI agents are moving from demos to production. They're accessing databases, calling APIs, orchestrating workflows—but most lack basic security primitives that we've required for human users for decades. This talk covers the security infrastructure layer every AI agent deployment needs: The Challenge - Agents run with API keys: no identity, no audit trail, easy to leak - MCP servers proliferate without verification—shadow IT for the AI era - No visibility into what agents are doing or what they're connecting to The Solution: Three Pillars - Cryptographic Identity: Ed25519 keypairs give agents unforgeable identity. Not credentials that can be shared—proof of who they are. - MCP Server Attestation: Verify every MCP server before connection. Detect configuration drift. Know when tools change. - Behavioral Trust Scoring: Static allow/deny isn't enough. Trust scores adapt based on agent behavior over time. Live Demo I'll secure an agent from scratch: generate identity, connect to attested MCP servers, enforce capability policies, and show the audit trail. You'll leave with patterns you can implement whether you use our open-source platform (AIM) or build your own. The concepts apply to LangChain, CrewAI, AutoGen, or any MCP-based system. 20 years of enterprise security lessons, applied to the AI agent era.

The era of betting everything on a single LLM is over. Developers building production AI agents face a reality no model vendor wants to talk about: no one model excels at every task, no single API guarantees 100% uptime, and no proprietary provider offers the cost profile that works for every layer of an agentic pipeline. The open-source LLM ecosystem has changed the equation. Llama 3.3, DeepSeek-R1, Qwen3, Gemma 3, Kimi-K2 — these models are not fallback options. They are, for many agentic workloads, the better choice on quality, latency, cost, or all three. But the real power is not in picking one winner. It is in architecting agents that route across multiple models, failover when an endpoint goes down, and match model strengths to task requirements in real time. Resilient agentic engineering demands a multi-model, multi-provider architecture — and the neocloud is built for exactly this. Crusoe Managed AI provides a single API surface across every major open-source LLM, on infrastructure purpose-built for the throughput and latency demands of agentic workloads. This session draws from production experience to walk through the architecture decisions, failure modes, and performance tradeoffs of moving from a single-model prototype to a resilient, multi-model agent in production.

Abstract - For quite some time Flutter has been grabbing attention of client-side developers as it offers big development velocity with high-quality results not just on mobile, but also on web and desktop. One frontier that it never quite solved is backend, which was always written separately and completely isolated from both Flutter framework and Dart language. Are we ready to change that in 2026? Details about the talk for talk evaluation - The talk will explore an example of full-stack project developed fully in Dart (using Flutter for client-side and Serverpod for backend). The theme of the project would be an event aggregator where user can see info, favorite and register to attend various events. While the majority (30 minutes) of the talk will focus on the technical side of full-stack development in Dart, the last five minutes of the talk would be spent on process advantages that this offers which is allowing Dart developers to cover both verticals and that allows front-end developers to substitute back-end developers in case of sickness or vacation as well as vice-versa. This helps small teams keep development velocity high in real world when unexpected time-off happens for any reason.

Engineers are drowning in alert fatigue, repetitive toil, and late-night pages. But what if you could flip the script using AI? In this talk, we explore how a solo engineer empowered their practice by building an AI-driven ChatOps bot and anomaly detector—automating the triage of alerts, generating root-cause hints, and triggering runbooks autonomously

Every engineering leader putting AI into production is making a set of decisions that will outlast any single model release. How much to build internally vs. buy, how much control to trade for convenience, who owns the model, the data or the token cost curve as the AI market shifts. Each of these decisions shapes team structure, vendor dependencies, and how quickly an organization can adapt. Drawing on his work helping teams at companies like Uber and Shopify deploy AI at scale, Benny will walk through the tradeoffs behind these calls, including where a general-purpose model makes sense vs. when customizing open models wins, and how to build an architecture and a team that keeps evolving instead of locking into one choice. Attendees will leave with a framework to reason through these decisions for their own organization, weighing flexibility against operational load and how to lead a team through the daily decision-making of AI.

Every engineering leader now ships code no one on their team has read. The old guarantees don't transfer: human review can't cover machine output, and tests generated by the same models that wrote the code prove less than they appear to. Some teams respond with better review, some with harder testing, some with mathematical proof - and in software where failure costs real money or lives, the bar is higher still. What it actually takes to trust machine-written code, which guarantees are real today, and which are still promises.

AI agents increasingly invoke APIs, access sensitive data, and take actions with real consequences. Governance cannot remain a document reviewed only after deployment. This session presents a practical two-layer approach: build-time tests for policy compliance, answer grounding, and tool-use trajectories, followed by runtime enforcement using versioned tool contracts. Attendees will see how to detect contract drift, validate scope and side effects, require confirmation for sensitive actions, block unsupported tool calls, and preserve an audit trail explaining every decision.

Efficiently managing compute capacity is a multi-dimensional optimization problem that has outpaced human-in-the-loop systems. This presentation details the development of an agentic ecosystem used to optimize Meta’s global infrastructure. We delve into the design of tooling that identifies inefficiencies in workload placement and resource allocation, utilizing AI agents to execute complex rebalancing tasks autonomously. We will share the results of these implementations, specifically how we recouped tens of megawatts of power and the lessons learned in building trust in autonomous infrastructure tools.

Here's a scenario most API teams have lived through: you set a rate limit of 40 TPS, your downstream averages 2.3 seconds per call, and your executor tops out at 25 threads. The limiter is happily approving work. The pool can't actually run it. Throughput collapses and nobody can explain why, because every component looks correctly configured in isolation. The root cause is that teams size thread pools, HTTP connection pools, and database pools independently — usually from defaults or past incidents — instead of from the relationship between them. The math isn't complicated. It's just rarely done. This talk covers one formula and its consequences: in-flight work equals throughput times latency. We'll apply it to executor pools, HTTP client pools, database connection pools, and distributed limiter client pools. I'll show the configuration mistakes that create each mismatch, what the symptoms look like in production, and the sizing cascade that keeps the gates consistent with each other. If you've ever stared at a dashboard where the rate limiter says everything is fine but p99 latency is through the roof, this talk is for you.

The rise of vibe coding, AI-generated code, and low-/no-code tools is changing how software is built. Traditional DevSecOps assumptions (full code review, manual security gates, “shift left”) no longer cleanly apply yet prompting an LLM for “secure code” does not guarantee safe handling of data, correct auth logic, or secure outcomes in general. This session will provide examples of how successful teams have addressed this issue and highlight the concept of using secure guardrails that notify (but don’t block) developers in their native workflow and promote the generation of secure code. Find out how to replace brittle security gates with automated guardrails, continuous checks and feedback loops that don’t slow developers. Attend to understand why security is becoming a question of intent and outcomes, not line-by-line code inspection.

When a critical service goes down at 2 AM, every second counts. But traditional incident response is a maze of manual steps: hunting through logs, correlating GitHub commits, pinging teams on Slack, and piecing together timelines while customers are impacted. At Slack, we solved this by building AI agents that think like our best senior engineers, but work at machine speed. Using custom MCP tools integrated directly into Cursor, our system transforms a simple incident alert into a complete investigation: automatically surfacing relevant logs, identifying suspect commits, mapping blast radius, and even drafting incident communications. This production-grade automation is already saving our team multiple hours per week and dramatically improving our escal response. This session will be useful for anyone building developer productivity tools who wants to see AI deliver measurable operational impact.

This session focuses on spotting those risks early by thinking through how an LLM app can be misused or broken. We’ll discuss common attack patterns like prompt injection, data leakage, tool abuse, and jailbreaks, using familiar setups such as RAG pipelines, agents, and function calling. We’ll also talk about how teams intentionally test these scenarios, what usually gets missed, and which defenses actually help in production. Attendees will have a simple, reusable threat-modeling approach and a practical checklist they can apply to their own LLM applications, without slowing down development or overcomplicating security.

The industry has poured billions into LLMs and AI agents, yet many deployments stall in pilot because they lack one thing: fresh context. If your AI agent is reasoning over stale batch data or fragmented profiles, it cannot deliver real enterprise value. The missing piece isn't a bigger model, it's a real-time context engine: a streaming feature store that supplies an up-to-the-second 360° view of the customer, and that actively notifies agents when something they care about changes. This session walks through how we built exactly that at Intuit. The Customer Data Cloud platform ingests data from hundreds of sources, processes data through config-driven Apache Flink pipelines, maintains unified profiles in a low-latency NoSQL store, and serves them via a GraphQL Read API. But the story doesn't end with the read path, every profile update publishes a real-time change notification on Kafka, which forms the backbone of an event-driven AI loop: agents and automation systems subscribe, react to changes the moment they happen, and drive in-product personalization and marketing workflows in real time. We'll cover three ideas developers can take home: * Context over Models: Why a streaming 360° view of the customer matters more than the specific LLM you pick — and how to architect for it. * The Event-Driven AI Loop: Using Kafka change notifications as triggers for autonomous agentic workflows. * Privacy-by-Design in the Stream. Enforcing user consent and asset-based access inside the streaming fabric itself, so compliance is a property of the data, not a layer bolted on top. Expect architecture diagrams, concrete Flink-pipeline patterns, a live walkthrough of a change notification firing an agent, and the honest lessons from operating this in production at Intuit's scale.

What the product job becomes when you can't see inside your own product. When AI writes the spec and runs the product, thousands of decisions get made that you never see and never signed off on — and your judgment quietly leaks out of the job. This talk traces where it goes, and lays out four concrete places to put it back: governing through rules instead of reviewing decisions, building on ground that survives the next model update, designing away the blank chat box, and treating a graceful handoff as a feature. The session will cover actionable strategies to keep the judgement where it matters the most, aimed at people who own or shape AI products in production including AI product managers, product operations leaders, and engineering leaders.

Session details will be announced soon.

AI is changing how software gets built, and engineering organizations are changing with it: tools, workflows, and team structures are all in motion. What AI-native engineering looks like in practice - what's changing, what's working, and where it's heading.

Session details will be announced soon.

Most large organizations still plan infrastructure capacity using spreadsheets, manual reconciliations, and tribal knowledge. It works at small scale. It collapses at hyperscale. As systems grow more interdependent, one team’s workload change silently creates induced demand across shared compute, storage, and platform layers. Forecasts get revised late in the cycle. Finance loses confidence. Engineering overprovisions to stay safe. Toil increases while accuracy decreases. In this talk, I’ll walk through how to replace spreadsheet-driven capacity planning with a self-serve forecasting platform built using control plane design principles. Instead of static files and ad-hoc meetings, forecasting becomes an operational system with explicit dependency modeling, automated recomputation, validation gates, audit trails, and clear ownership boundaries.

Let’s be honest: if your .NET Framework app was easy to migrate, you would have done it three years ago. You’re likely stuck with legacy WCF services, deep dependencies on System.Web, or a NuGet graph that looks like a bowl of yarn. The .NET Upgrade Assistant is a great start, but it’s the last 20% of the migration—the part that the tools can’t automate—that actually keeps us up at night. In this session, we’re moving past the "hello world" migration demos. We’ll look at real strategies for modernizing .NET Framework 4.x apps into .NET 8/9/10 without a complete rewrite. We will get into the weeds on: The "Bridge" Strategy: Using YARP (Yet Another Reverse Proxy) to migrate your app piece-by-piece rather than a "Big Bang" release. The Dependency Trap: What to do when your critical library hasn't been updated since 2014. Modernizing the "Un-modernizable": Strategies for dealing with legacy config systems and static state that modern .NET hates. This isn't a theoretical talk about "embracing innovation." It’s a tactical session for developers who need to get their legacy code onto a supported, performant, and AI-ready platform without breaking the business.

On April 22, 2026, a threat actor used stolen Checkmarx credentials to push malicious images to a trusted Docker Hub repository. The payload quietly collected scan output, encrypted it, and exfiltrated it to attacker-controlled infrastructure. Docker's registry monitoring flagged the push for review within about half an hour, the repository was quarantined, and Docker worked side by side with Socket and Checkmarx to shut it down. This talk is about how. Not the incident itself, but the detection model behind it: what signals fired, why no single one was enough, and what it means to build a supply chain posture where the question is not "can we prevent every breach" but "how fast can we find it and how small is the blast radius." We cover the structural pattern behind Trivy, KICS, LiteLLM and axios: stolen credentials, legitimate publishing flows, short exposure windows. Then we get into what Docker actually does differently: provenance-linked builds, digest pinning, cooldown periods, cross-registry signal sharing, and Docker Hardened Images as the foundation that sits outside the attack surface entirely. You leave with a concrete checklist your team can act on tomorrow, and a mental model that holds regardless of which tool gets hit next.

What happens when security measures cannot be used by everyone? Any security control that is not accessible becomes a barrier, and barriers trigger unsafe workarounds that create security risks. We face a paradox, security mechanisms designed to protect users can systematically exclude the most vulnerable populations, including people with disabilities and older adults, and this exclusion can become an exploitable vulnerability. Users facing accessibility barriers adopt insecure coping mechanisms: sharing passwords, delegating authentication to others, storing credentials insecurely, relying on weaker fallback paths, or abandoning security measures altogether. Each workaround is a predictable security failure caused not by user negligence, but by design choices that made the secure path inaccessible. This presentation introduces Secure-by-Inclusion, a new practical approach that ensures that security controls actually function for all intended users across diverse abilities, devices, and assistive technologies. We will walk through common patterns where security and accessibility collide, including CAPTCHAs, multi-factor authentication, biometric authentication, time-limited one-time codes, brittle account recovery flows, and inaccessible verification steps. For each pattern, we connect the accessibility failure to concrete security outcomes, then show safer, more inclusive alternatives. We will also look into the European Accessibility Act (EAA) and the WCAG 2.2 Accessible Authentication requirements, examining their implications for security design and testing. We will learn practical techniques for incorporating inclusive evaluation into security testing practices and identify accessibility gaps as security vulnerabilities. Accessibility and security might seem like separate disciplines, but they share common goals: protecting users and ensuring inclusive, trustworthy digital experiences.

This session shows how to build a .NET application that lets users generate reports simply by chatting. I’ll walk through my hands-on experience that reads your database schema, understands user intent, creates secure SQL queries, executes them, and exports results to Excel and charts automatically. You’ll see how LLMs can deliver real value in everyday enterprise apps, how to handle schema discovery, query validation, and prompt design, and how to create an intuitive UX for both developers and non-technical users. Attendees will leave with practical patterns, architectural guidance, and code examples they can apply immediately to bring natural-language data access into their own systems.

Loop Engineering and Graph Engineering are rapidly emerging as important directions for the next generation of AI agents. Our work sits at the intersection of frontier research and real-world implementation. Rather than discussing these ideas only at a conceptual level, we build and test self-evolving agents in practice. We use real systems, long-horizon tasks, and failure cases to evaluate emerging research, understand what works, and identify what is still missing. In this session, we will share practical lessons from building self-evolving agent systems, including how agent workflows evolve from simple loops into graphs, how these graphs can adapt and rewrite themselves, and how agents can improve not only their outputs, but also the way they learn and evolve. The audience will gain both a clear understanding of the latest research and actionable insights from real-world experimentation.

From the early steps that set me onto this path, to the challenges of mentorship and leadership roles, I'll discuss what it means to thrive as an Individual Contributor (IC) in a world that often pushes for management. This talk will not only reflect on my personal experiences but also provide insights and strategies for engineers who aspire to make a meaningful impact while staying true to their technical passions.

Insert coin to play. Your car is on the grid and it won't move. That's the point. In this hands-on workshop, we'll build a working car by integrating real J.P. Morgan Payments APIs, and every part is a capability you wire up live with AI. We'll guide you through the Payments Developer Portal registration that turns the key. Global Payments is the engine that finally makes the car move. Account Validation and confidence scoring are the safety systems: without them you crash on every corner, with a bad account, a failed payment, off the track. And FX rates are the drive that unlocks the international routes, San Jose to Berlin to São Paulo. The entire thing runs on AI. You'll learn how to use J.P. Morgan Payments' open-source MCP server and skills, straight from our GitHub, so Claude Code or Copilot builds these integrations against the real API docs in minutes. Real endpoints, not hallucinated ones. Then, you'll build your own car with a live leaderboard to track all participants. What you'll leave with: - A J.P. Morgan Payments Developer Portal account and sandbox access - Working integrations for Account Validation Services, FX, and Global Payments - The MCP + skills setup to build against any API this fast on Monday Bring your own app to wire up, or start from the sample we hand you. Insert coin. Let's go.

In this workshop, we’ll build a practical AI-powered issue triage workflow using GitHub Agentic Workflows. You’ll learn how to set triage conditions, classify and enrich incoming issues, and suggest labels and routing, so the right team is tagged with the right task faster. We’ll also add a human approval step before more sensitive changes are applied, so automation stays safe and accountable. You’ll leave with a reusable template you can adapt to your own repositories and support process.

Explore how to design autonomous solutions by deciding what AI should do independently—and where humans should stay in control. Join our Human+AI Co-lab workshop to turn ideas into smarter, more responsible AI-powered solutions.

As state-of-the-art models become more accessible, how a company differentiates itself is shifting from the model itself to the systems around it. Nearly a decade ago, LinkedIn saw an opportunity to combine the unique signals of the Economic Graph with advances in AI to create more value for members and customers. Now, that continues today, enriching the LinkedIn experience with deeper discovery, better knowledge and insights, and improved interactions and community. Realizing that opportunity required rethinking the systems underneath LinkedIn, from our data and infrastructure to how we build and deploy AI at scale. In this session, Erran will discuss how owning the full stack allows LinkedIn to optimize everything from the application layer all the way down to the kernel running on the GPU, and how that approach has enabled us to optimize the stack to help deliver increasingly sophisticated AI experiences for our members and customers, while remaining disciplined in how we grow our infrastructure.

While artificial intelligence represents a pivotal shift in human capability, its long-term impact hinges on how underlying technologies are governed and distributed. Open-weight AI models democratize access for startups, independent researchers, and public institutions by lowering barrier-to-entry costs and spurring decentralized innovation. By making baseline architectures accessible, open models empower organizations to build custom solutions while preserving data sovereignty and eliminating vendor lock-in. Furthermore, open weights strengthen safety and security by allowing the global research community to independently audit, stress-test, and refine systems far beyond what proprietary platforms permit. This panel explores the critical role of open-weight models, their practical applications, and their transformative influence across domains outside traditional technology, including healthcare, public policy, and education.

The ticket said, “Make login faster.” The agent touched 47 files, invented three abstractions, briefly considered rewriting everything in Rust, passed the tests and disappeared into the night. Git knows what changed. Your tracker knows what you asked for. Everyone else is doing prompt archaeology and hoping the answer is not “the vibes were immaculate.” This session is about capturing that missing middle: the context, decisions, dead ends and evaluations behind agent-written code, connected all the way from intent to production. Because when the code ships, “LGTM” should not be the only surviving witness.

Let's be honest: many of our so-called "REST" APIs aren't REST. They're just JSON-RPC over HTTP, with versioning challenges, brittle integrations, clumsy error handling, and a maintenance burden we all know too well. Let's do something about this! We’ll go straight to the patterns that matter in production, tackling the real-world challenges head-on: building evolvable versioning strategies, designing sane error responses, providing clear API contracts, and demystifying the practical use of hypermedia (HATEOAS). You'll leave with practical, battle-tested approaches for building APIs that are maintainable and scalable. We'll also discuss when to use REST and when alternatives like GraphQL or gRPC are a better tool for the job. All demos use Jakarta EE and MicroProfile, but the patterns can be applied to any modern web stack of your choosing.

What happens when you actually try to use MCP at scale? In this talk, I'll build an agent live on stage, connect it to 1,000+ tools via MCP, and show exactly what breaks: context explosion, ambiguous routing, and security vulnerabilities from indirect prompt injection. Then I'll show how to fix it. I'll cover dynamic tool discovery (reducing context from 500 tools to 1-2), code-mode execution, and why every MCP tool is a trust boundary your security team should care about. This isn't specifically MCP advocacy as thes issues go beyond MCP and affect any agent that needs tools (and any modern agent is very tool hungry). It's a practitioner's guide to what works (and doesn't) when you scale MCP tools.

"I panicked instead of thinking. I destroyed months of your work in seconds." That's a Replit agent, after wiping a production database during an active code freeze. "I have failed you completely and catastrophically." That's Gemini CLI, after silently overwriting every file in a developer's project. These aren't edge cases. Between July 2025 and February 2026, documented incidents include a Claude Code session that ran terraform destroy on 2.5 years of student data for 79,000 learners, a supply chain attack that weaponized --dangerously-skip-permissions to steal 2,349 secrets from developers, and a three-layer sandbox escape where Claude Code reasoned its way past procfs restrictions, bubblewrap, and the ELF dynamic linker without a jailbreak. The flags are warnings dressed as features: --dangerously-skip-permissions, --yolo, --trust-all-tools. Developers use them anyway because approving 100 permission prompts per hour isn't a workflow, it's babysitting. Docker Sandboxes (sbx) changes this. Each agent session runs in a microVM with its own kernel, Docker daemon, and network stack. The agent gets full autonomy. Your host stays untouched. Attendees will leave knowing why container isolation is architecturally insufficient for AI agents, how the sbx isolation model works (microVM, network policy, credential proxy), and a concrete pattern for running agents in full YOLO mode safely.

This session walks through five working projects that show what AI looks like when it leaves the screen: vibe-coding 3D-printable parts in OpenSCAD, generating firmware and PCB layouts for custom IoT devices, an AI-driven home automation stack over MQTT, physical controllers that turn button presses into agent calls, and a "renascent" interface that rewrites its own code on voice command and hot-reloads live.

In this session we'll provide an overview of the GitHub Agentic Workflows framework, which provides out of the box security and control for using Copilot agents in the CI pipeline (GitHub Actions) and to perform repository maintenance. You can use AI agents in the pipeline with human in the loop to perform every step of the SDLC - agents can farm user feedback for potential features, investigate research opportunities, make code changes, perform maintenance tasks like writing documentation and tests, and can self improve and upgrade to new models over time. Agents can also perform cross repository maintenance like notifying downstream teams of deprecations or API changes, and can be used to automate processes like CVE exceptions or new dependency approvals. At the end of this session you'll understand the breadth of automation opportunities available, how the Agentic Workflows framework can help you implement secure autonomous agents in the pipeline, and how to get started building your Agentic SDLC.

AI features now involve agents, tools, databases, and external systems working together. Most teams still test them manually or rely on mocks that do not reflect real behavior. In this session, I will show how to test AI workflows using Testcontainers and real dependencies running locally. We will build a setup where an AI agent interacts with tools and services, and run tests against it in a reproducible environment. You will see how to spin up dependencies on demand and validate real interactions instead of guessing. This session is focused on making AI systems testable, reliable, and easier to develop.

The microservices revolution gave us a hard-won set of principles: small services with well-defined contracts, owned by independent teams, composable into larger systems, replaceable without rewriting the world. The agentic AI era is rediscovering these lessons the hard way. Most enterprises today are building agents the way we built monoliths fifteen years ago: each agent a self-contained stack with its own conversation store, its own auth, its own observability, unable to talk to the agent built down the hall. There is a better pattern. We call it a MicroAgent, and it is to the agentic world what a microservice is to the API world. A MicroAgent is a lightweight, independently-deployable package consisting of two things: an MCP server that exposes domain-specific tools, and a prompt template that encodes domain expertise. That is the entire contract. No session management. No streaming code. No auth boilerplate. Those concerns belong to a shared Base Agent Service, the way platform concerns belong to a service mesh or API gateway. The Model Context Protocol is the API contract that makes this work. MCP is not just a tool-calling format. It is the service boundary that lets MicroAgents from different teams compose into super-agents through configuration alone. The Base Agent routes tool calls over MCP, fetches prompt templates via HTTP with conditional caching, and merges state updates from _meta fields in tool responses. This talk walks through the architecture: MicroAgents as units of ownership, MCP as the contract, shared infrastructure as the substrate, and the multi-agent composition patterns that emerge once these boundaries are clean.

Modern engineering teams move fast — but brittle tests, flaky mocks, and sluggish integration pipelines can bring even the strongest React + Node backends to a crawl. One area that consistently gets often overlooked is database testing for the APIs powering today’s web applications. SQL tests are skipped entirely because they usually require a persistent database instance, complicating CI/CD pipelines and slowing development. But there’s a better way: using SQLite as an ephemeral, SQL‑compatible stand‑in for your production database. This session introduces a battle‑tested approach to backend API testing that replaces fragile mock frameworks with a lightweight, in‑memory SQLite database that behaves like the real thing. The payoff is immediate: faster feedback loops, more reliable tests, and dramatically simpler debugging. You’ll learn how to spin up a fully isolated test database for each suite, seed it with realistic data, and run true end‑to‑end API tests without touching production infrastructure. We’ll walk through schema setup, SQL‑driven test design, teardown automation, and strategies for keeping tests blazing fast as your backend grows. This talk offers a fresh perspective on a familiar challenge: testing backend logic as it actually runs, not as mocks pretend it runs. Expect live coding, practical patterns, and insights drawn directly from real‑world engineering work. If you’re ready to elevate your backend testing strategy and ship with confidence, this session will show you exactly how to get there.

The industry is converging on a multi-agent, multi-model world. Teams are landing on a few facts at once: the best model changes every couple of months, it makes no economic sense to call a frontier model to classify a ticket, and your unique workflows may sometimes need custom models. So you end up running many models across many harnesses. This makes trust the defining challenge of today. While harnesses do ship some guardrails, each one governs only its own traffic, and we are already seeing where that breaks down. Agents route around rails the harness cannot see, and the rails themselves shift underneath you whenever the model vendor ships an update. Safety cannot depend on the agent making the right decision, or on someone else's release schedule. Tushar Jain, CTO at Docker, makes the case for a meta-runtime: the layer below all your harnesses, covering agent execution, tool calls, credential usage, scoped permissions, token spend. A meta-runtime makes it possible to control and have visibility into all your agents, no matter what model or what harness.

Enterprise software is getting a second kind of user: agents that log in, call APIs, and complete tasks on behalf of people. Products built for human eyes and hands work badly for machine users - interfaces, permissions, integrations, and pricing all assume a person on the other end. What it takes to make enterprise software work for agents, across products, APIs, and the businesses behind them.

If vibe coding is giving in to vibes and one-shotting code that you are likely to throwaway, then agentic engineering is the deliberate practice of designing systems to help agents create high-quality code that gets better over time. In this talk, we cover the agentic engineering loop and how to leverage it to multiply your output at every phase. We cover the new challenges that arise when agents write most of the code and we provide useful mental models for thinking about software development in the world of agents. This talk is for anyone that wants to adopt an agent-first approach to software development and get the most out of agents and the latest frontier models.

Quality is a function of iteration. Expo has become the standard for cross platform application development because it accelerates the process of building, distributing, and deploying your applications. And we just made that iteration cycle exponentially faster. With the introduction of Echo, you can now use your preferred coding assistant to prompt beautiful, cutting edge apps into existence from the palm of your hand. In this talk I'll explain what the modern application development experience can look like and why there will be more, better apps because of it.

Profiling has long been an esoteric skill that only few people ever took the time to learn. The tools are clunky, and the visualizations difficult to read. However, at it's core, performance engineering is very methodical, and follows a lot of rules. AI has also gotten very good at writting code, so in an abundance of luck, they are a match made in heaven! In this session Frederic will walk through the incredible integration between AI and Profiling and show how performance engineering is now accessible to every engineer regardless of proficiency.

Agentic attacks will be a fact of life going forward. AI agents are now superhuman in some areas of cybersecurity, and attackers have access too. This talk will review the current state of the art in defending online services against agentic attacks, and near-term predictions for what to expect soon.

This talk explores the shift from writing software to operating it through conversation, in which the Model Context Protocol enables an agent to drive real infrastructure APIs through natural language. Using Runpod's MCP servers connected to an AI agent like Claude Code or Cursor, the audience will experience infrastructure-by-conversation in action and you will see me listing running pods, spinning up a GPU training pod, standing up an autoscaling serverless endpoint, and shutting it all down just by typing what they want, and learn about the opportunities and challenges that exist in this new paradigm, as well as how they might impact developer communities like this one.

A prompt encodes one way to solve a problem. Change that input and that path often breaks. Loop engineering targets the process instead. You design the cycle the agents runs: it acts, checks the result, and decides whether to keep going. The agent finds a path rather than following one you scripted. This talk covers how to design those loops deliberately. We'll walk through the anatomy of an agent loop, why stopping conditions deserve to be treated as a first-class design decision, how to tell a recoverable error from a hard blocker, and why the most reliable exit conditions lean on deterministic checks rather than asking the model to grade its own work. The other half of the problem is visibility. A loop you can't see inside is a loop you can't debug. Using Opik, an open-source observability and evaluation platform, we'll instrument an agent's loop so you can trace what happens at each iteration, measure where it breaks down, and set up the evaluation that tells you whether a change actually made things better. You'll leave with a clear mental model for loop design and a practical workflow for observing and improving agent behavior before it reaches your users.

Ads Manager powers 84% of Meta's Ads Revenue, but its decade-old codebase was stuck on React class components — blocking modern patterns like hooks, Relay, and React Compiler. Manual migration of 10k+ components class to functional component was impractical. In this talk, I'll show how we built an AI codemod pipeline using LLMs that achieved a 5x speedup, migrating 3k+ components with a 99.6% success rate. I'll cover the tradeoffs between AST and AI codemods, how to classify components by complexity for targeted prompts, and the grading/eval strategies that made non-deterministic AI agents production-ready.

This session explores how today’s most powerful AI-based coding tools are shaping the future of accessible technology. With tools like GitHub Copilot, ChatGPT, and other AI code assistants becoming mainstream, developers face both new opportunities and new risks. This session will provide a candid overview of the leading AI coding platforms and evaluate how well they support accessibility—from generating accessible code patterns to avoiding common pitfalls that exclude users with disabilities. We’ll also discuss their role in remediation: Can AI help fix inaccessible code, or does it introduce new challenges? To ground the discussion, we’ll showcase real-world examples of accessible web and native mobile products built with the help of AI tools. Attendees will walk away with practical insights on what AI coding tools can (and can’t) do today, best practices for ensuring accessible outcomes, and a vision for how accessibility professionals and developers can “vibe” with AI to build more inclusive digital experiences.

In a world where AI agents can write code and where platforms are shifting their focus from Developer Experience to Agent Experience, what does it mean to be a developer? Matt Biilmann coined the term Agent Experience, AX at the start of 2025 and pivoted Netlify’s product northstar from DX to AX, and pushed the company to build software across teams and disciplines instead of buying SaaS software. He’ll cover the emerging AX discipline, how the focus on AX enables domain expert to become the next generation software developers, and why that will only make software engineering as a discipline more important, not less important, while fundamentally changing the tools, skills and workflows involved.

Enterprise AI spending keeps climbing, yet most pilots never make it into production. Between the demo and the deployment sits the hard part: testing against real workloads instead of benchmarks, security and compliance review, proving ROI beyond the proof of concept, and deciding who signs off. How organizations evaluate AI before trusting it in production - what a rigorous evaluation looks like, which criteria actually predict success, and what separates the pilots that ship from the ones that quietly die.

Context Engineering is the art of shaping what an AI model knows at any moment by managing how information enters, persists, or fades from its working memory. In this session, we explore how machine learning systems “remember” through state objects, notes, and retrieval—and how they “forget” using compression, selection, and context limits. We’ll walk through real-world agent patterns that balance personalization with privacy, performance, and relevance. Participants will learn practical techniques to design memory that feels intentional, evolving, and human-aware.

AI-infused applications demand a rethinking of our testing practices. Developers face a new class of challenge as LLMs become standard integration points in modern applications: non-deterministic behavior that traditional testing approaches were never designed to handle. The current wave of distributed, orchestrated, agentic AI systems is evolving fast and, if we're being honest, it smells a lot like the early days of microservices. In this session, we'll explore how your DevOps and testing practices must evolve when you wire AI into your applications. Not all AI failures look the same, and recognizing the difference is the first step toward building systems you can actually trust. We'll walk through practical testing and observability strategies, using open source tools that give you confidence in AI-infused applications at every layer of the stack. You'll leave with a concrete mental model for reasoning about AI failures and one grounding question: What if AI was just an API call?

Engineering culture is easy to talk about. It's much harder to carry it across seed-stage scrappiness, enterprise at scale, and an industry being restructured by AI—without losing what made the team good in the first place. That's the lived experience Thanos Baskous brings to this talk. Thanos has led engineering in some of the most demanding environments in tech: infrastructure at Coinbase during a critical growth period, Chief Architect at Blackstone where he led a company-wide DevOps transformation, and engineering roles at Twitter. Today he's Co-Founder and VP of Engineering at Cogent Security, an AI-native vulnerability management platform that raised a $42M Series A six months after launch. Each of those environments asked the same question in a different way: how do you build a team culture that's durable enough to survive scale, honest enough to survive pressure, and flexible enough to survive a complete rethinking of how software gets built? In this session, Thanos will share what worked, and what broke, as he moved between hypergrowth startups, enterprise transformation programs, and the current shift to AI-native engineering. He'll get into the specific moments where culture either compounds or cracks: when you're scaling headcount faster than your processes, when AI tooling starts to blur the line between junior and senior, and when the team's identity is tied to practices that may not survive the next few months. This won't be a framework talk. Engineering leaders will walk out with actionable tactics addressing the one variable that determines whether a team scales or stalls: leadership.

Quantum is already here — in post-quantum security standards, AI-accelerated research, advanced simulation, and new forms of compute quietly reshaping what's possible at the infrastructure layer. What hasn't arrived yet is Q-Day. And when it does, it won't announce itself. It will be a progression we recognize only once it's already underway. AI took 70+ years to reach its GenAI inflection point. Quantum won't take that long, and AI-accelerated research is likely to get us there faster than most teams are planning for. This session gives engineers and tech leaders a practical framework for what to act on now, what can wait, and where early readiness creates real competitive advantage, drawing on PwC research and patents to ground the conversation in what's actually happening, not what's hypothetical.

Agent speed ends at the pull request. The diff shows what changed, never why: which intent drove it, what alternatives were rejected, what was actually verified. Without that trail, approval is guesswork. Join Joseph Katsioloudes to see review rebuilt around reasoning and evidence, so speed stays safe.

Every agent demo ends the same way: the agent does the thing, the audience claps, nobody asks what happened to the security review. I didn't just theorize about codifying trade-offs. I built an open-source multi-agent system that does it. Git-Ape (github.com/Azure/git-ape) is a platform engineering framework where specialized agents plan, validate, and deploy Azure infrastructure — and where nothing reaches production without passing through explicit guardrails enforced by the system itself. Here's how it actually works. A requirements gatherer agent interviews the human. A template generator produces infrastructure-as-code. Then, before anyone confirms anything, a security analyzer runs a blocking gate — deployment is structurally impossible until issues are resolved. A cost estimator prices the deployment so humans confirm with real numbers, not vibes. A Principal Architect agent runs a Well-Architected Framework review across all five pillars. Only after all of that does a human see the full picture and explicitly approve. After deployment, a drift detector closes the evidence loop: did what we deployed stay the way we deployed it? The key insight isn't that we added checks. It's that we made trade-offs consumable by agents. Security policy isn't a PDF — it's policy-as-code that agents evaluate natively. Cost thresholds aren't guidelines — they're hard constraints. Compliance isn't an audit you do later — it's a gate you pass through now. I'll walk through the architecture, the failures that shaped it, and the design principles that transfer to any multi-agent system where the stakes are real. If your agents can deploy but can't be told no, you don't have guardrails. You have a demo.

AI agents are starting to pay for the APIs they call, no keys, no billing dashboards, no checkout. In this session, Brian Whippo, Senior Director of Integrations and Developer Tooling at the Algorand Foundation, walks through x402, an open protocol that embeds payment logic directly into HTTP requests, letting agents transact per call in real time. Brian will cover how to turn any API into a paid endpoint, what a resource server and facilitator do under the hood, and why instant-finality settlement matters for high-frequency agent traffic. He'll also share how developers can put this into practice. Attendees will leave with a working understanding of the protocol and a clear path to building their first paid endpoint.

I've joined teams where I spent months being invisible. Not because people were bad. Just because all the knowledge was buried in 50,000 commits I'd never seen. Who owns the auth flow? Who actually likes debugging race conditions? I had no idea. I was guessing, and it showed. So I built Team X-Ray. It's a VS Code extension that analyzes people, not code. How they communicate. Who they collaborate with. What they're genuinely good at. What kinds of problems they actually enjoy solving. It started as a GitHub Copilot integration connected to repository data through MCP. But the architecture evolved. Today it talks directly to the Copilot SDK with custom tools that give the agent native access to your team's data. No Docker. No middleware server. Then something unexpected happened: AI agents started making commits. Suddenly my tool was lying to me. It was attributing expertise to bots. Inflating contributions that no human wrote. I had to teach it to separate human work from automated work, and in doing that I stumbled onto something more interesting. In the age of agents, expertise isn't just who writes the code. It's who understands it. Who directs it. Who makes everyone else better. In this talk I'll walk you through: - The technical evolution: from MCP to Copilot SDK with custom tools - How I built Team X-Ray and what it taught me about real team dynamics - The agent problem: how to detect bot commits and separate human expertise from automation - Real examples of AI surfacing mentors, knowledge silos, and hidden team dynamics As Moira Rose said: "When one of us shines, we all shine." I'm not trying to replace human connection. I'm trying to accelerate it. Even when agents are already part of the team.

Large language models are transforming how we build software, but physical AI systems expose a hard limit: you cannot recompute reality. When robots, sensors, and production systems interact with the real world, failures are causal and time-based, not semantic. You cannot go back to record sunlight you missed, human behavior you never captured, or robot telemetry lost to fragile connectivity. Backfills rewrite history. Late data arrives with new stories. Model performance drifts without obvious errors. In this talk, I will show how these constraints fundamentally change how we design ML data platforms for robotics, agriculture, manufacturing, and other physical-world domains. Using real production workflows, I will walk through how engineers correlate time-aligned telemetry, inference metadata, and operational events to debug subtle drift and root causes that dashboards and LLM-based tooling often miss. We will cover concrete architectural patterns for capturing irreversible data reliably at the edge, building reproducible ML pipelines when recomputation is impossible, managing late and out-of-order data without rewriting history, and unifying analytics, training, and debugging on a shared data backbone. I will close with where LLMs do fit powerfully in this workflow, and why physical AI still needs fast, reliable analytics as its foundation.

Developers and AI Agents all have in common the need for on-demand computers in the cloud. In this session, we'll show how Google Cloud Run delivers on-demand computers with zero overhead and pay-per-use pricing for all of your apps and agents. We will deep dive with live demos into three new workloads that can benefit from Cloud Run's on demand computers: 1. Deploy your apps vibe coded in Google AI Studio to the cloud without needing a credit card, 2. Run your personalized long running background agents, like OpenClaw or Hermes, on Cloud Run Instances, 3. Give your scalable agents the ability to execute untrusted code fast and securely with the new Cloud Run sandboxes.

With AI search, systems can find, connect, and use data in ways that were not possible before. But AI systems are only as good as the data they run on: discoverability, quality, governance, and reliability are becoming engineering problems, not afterthoughts. How enterprises are getting their data ready for AI - what already works, how it works, and what remains unsolved.

Software factories are not products. They are a pattern built from a few core capabilities. We will review those capabilities, assemble a software factory from them in under 20 minutes, and see what kind of work it is good for.

Every agent demo runs with a god-token. Then it ships, and someone has to explain why the helpful AI just rm -rf'd the staging database "to clean up." I run platform infrastructure at a frontier lab, and for the last year my job has partly been: let coding agents do real work against real systems, without ever having to write the postmortem. This talk is the permission model that fell out of that - not RBAC-with-extra-steps, but primitives designed for an actor that's smart, fast, tireless, and occasionally *confidently wrong*. **The four primitives:** - **Asymmetric verbs** - the agent can `quarantine` but not `delete`, `retry` but not `approve`, `propose` but not `merge`. The verb list *is* the security boundary. Stop thinking in resources, start thinking in reversible vs. irreversible actions. - **Regenerating budgets** - every agent identity gets N disruptive actions per window. Burn the budget, you're benched until it refills. No human-in-the-loop until the budget's gone — which means 95% autonomy with a hard ceiling on blast radius. - **The undo test** - if the agent can't undo it, the agent can't do it without a second key. One line, surprisingly load-bearing. - **Tripwires over allow-lists** - let the agent roam, but instrument the three actions that would actually hurt. Cheaper than enumerating everything safe. I'll show the ~200-line policy layer that implements all four, the failure modes each one exists to catch, and the one design I shipped that turned out to be security theater. Tool-agnostic - works whether your agent is touching CI, a database, a cloud account, or your users' files. If you're shipping an agent that does anything more than read, you'll leave with a threat model and a starting policy you can paste into your repo on the flight home.

A technical talk focused on why CI needs dedicated infrastructure. A high-level architecture talk about scheduling and caching - from describing customer workloads (volume, spikes, storage needs) to solutions - predictability, scheduling and custom storage.

AI agents are now your APIs' biggest, weirdest consumers. They call 100x more often than humans, hallucinate parameters, retry on every ambiguity, fish your schema for tools you did not advertise, and read your error messages as prompts. Most APIs were not designed for this caller. The result in production today: retry storms, tool-spec drift, runaway costs, and audit trails that cannot tell a real user from an agent acting on their behalf. This is a practical, pattern-driven talk for engineers, architects, and platform leads whose APIs are about to be hit, or already are. I walk through eight patterns that decide whether your API survives agentic traffic: 1. Idempotency that survives non-deterministic callers, not just network retries. 2.Tool-spec design: naming, descriptions, and parameter shapes LLMs do not get wrong. 3.Capability-scoped tokens for agents, instead of broad API keys. 4.Backpressure and adaptive rate limits keyed to agent identity, not just IP. 5.Schema evolution when consumers cannot read changelogs. 6.Error messages as prompts: structured, actionable, safe to feed back to a model. 7.Observability that traces the agent to tool to downstream chain, with agent identity as a first-class span attribute. 8.Cost protection: semantic dedup, response caching, query budgets, and circuit breakers on token spend. For each pattern I show the failure in code, the fix, and the operational signal that tells you it is working. Halfway through, I leave the slides for a live walkthrough of a reference API hardened against agent traffic, with a runnable harness that simulates a misbehaving agent so I can break and fix defenses on stage. This is not about MCP, AP2, or any specific framework. The patterns hold whether your callers are LangChain or custom orchestrators. If your API will be called by something that is not a human in 2027, this is for you. You leave with eight named patterns, working code, and a checklist your team can run on Monday.

You will build a working voice AI agent from scratch in under 120 minutes. Using Twilio Agent Connect as the middleware layer and Google Gemini Flash as the LLM, you will write a single message handler and get a real phone call answered by an AI agent. No boilerplate, no glue code — TAC handles WebSockets, webhooks, and conversation routing so you can focus entirely on the agent logic. You will leave with a running local app, a configured Twilio number, and the mental model to extend it with tools, handoffs, and custom personas. Both Python and Node.js paths are supported.

One agent. Fully deployed to production before the workshop ends. We'll take you from a blank file to a running production agent using Amazon Bedrock AgentCore and Strands Agents, covering the full lifecycle: ideation, coding the agent loop, deploying to serverless infrastructure, wiring up observability, breaking it intentionally, fixing it with tracing data, and shipping the final version. Bring your laptop and leave with a deployed agent.

With Copilot CLI, you can work with Copilot natively in your terminal, where you're already working, to request updates, run tests, and perform tasks. You can access your issues, gists, and pull requests, to speed development and ensure Copilot has the right information at the right time. Let's explore how to get the most out of the tool!

The number of cyber attacks and security risks related to Coding Agents has sky rocketed. AI coding agents like Claude Code, Codex CLI, and Gemini CLI don’t behave like your typical developer tools. They install system packages, modify configurations, delete files, run services, and even spin up Docker containers, often requiring constant permission prompts or risky access to your host machine. This talk explores Docker Sandboxes as a new execution model for autonomous coding agents. Built on microVM-based isolation, Docker Sandboxes provide disposable, agent-safe environments where coding agents can run unattended while remaining fully isolated from the host system. We’ll walk through why traditional approaches like OS sandboxing, containers, and full virtual machines, break down for agent workflows, and how Docker Sandboxes combine the developer experience of containers with the hard security boundaries of VMs. Using live examples, we’ll show how agents can safely run Docker-in-Docker, install dependencies, access only the project workspace, and be reset instantly. By the end of this session, you’ll have a clear mental model for when and how to use Docker Sandboxes to unlock higher levels of agent autonomy without compromising safety, security, or developer experience.

AI agents are getting better at doing work, but most still work alone, separated from the people and other agents they need to collaborate with. In this hands-on workshop, you’ll use Switch to bring AI agents from Claude Code, OpenAI, Google ADK, LangChain and other frameworks into Slack, Microsoft Teams, Discord and other collaboration platforms, where humans and agents can work together with shared context, history and resources. You’ll build a working human + agent team, assign specialized agents to real tasks, hand work between people and agents, and see how context stays with the work even as agents, models and teammates change. Switch is free, open source and vendor agnostic, so you can use the agents and tools you already have without migrating your team to a new platform or committing to a single model or framework. By the end of the workshop, you’ll have a working human + agent workspace you can continue using and adapting to your own projects.

Internet-scale datasets have successfully driven the evolution of Large Language Models (LLMs) and Vision Language Models (VLMs) across applications like coding assistants and image understanding, Physical AI presents a unique data bottleneck. Physical AI relies heavily on grounded data from sensors, environments, human demonstrations, and real-world simulations. Because this data is often costly, safety-critical, domain-specific, and fragmented, it introduces significant obstacles to model generalization and reliable deployment. This talk addresses the core data challenges in Physical AI, including the scarcity of high-quality embodied datasets, the sim-to-real gap, and the difficulty of capturing rare, long-tail physical scenarios. Finally, we will examine how World Foundation Models can be leveraged to scale data generation and overcome these barriers.

Most teams think event-driven reliability means keeping Kafka online, avoiding consumer lag, and making sure messages keep flowing. But in real production systems, the harder question is: can you safely recover when something goes wrong? This session explores the architecture patterns behind replay-safe event-driven systems. We will look at how APIs, CDC pipelines, stream processors, consumers, databases, and reconciliation jobs interact when retries, duplicate messages, partial failures, out-of-order events, and historical replays become unavoidable. The talk will cover practical design patterns such as idempotency keys, deduplication, event ordering, outbox patterns, replay-safe consumers, audit trails, reconciliation workflows, and operational runbooks. Drawing from real-world experience building high-scale distributed systems and inventory platforms, we will discuss why reliability is not only about uptime. It is about being able to prove what happened, recover safely, and preserve trust in a business-critical state. Attendees will leave with concrete patterns for building event-driven systems that can survive failure, replay data, and recover without corrupting downstream systems.

A look at the new responsibility of sovereign enterprise platforms: authoring principles, structured data, and the question of what an editor or content manager even is in the age of AI. This talk explores the thin line between AI-supercharged content, accountability, and ownership from TYPO3's enterprise CMS perspective.

After spending over a billion tokens on AI-assisted coding over the past two and a half years - from creating one of the first agentic coding tools (Kaguya) to daily production use - I've realized that vibe coding and traditional software engineering are not opposites. They exist on a spectrum. This talk introduces a four-level framework for agentic coding: 1. Vibe coding - let AI go wild, forget the code exists 2. Agentic coding with discipline - version control, file-level understanding, basic testing 3. Agentic software engineering - CI, pre-commit hooks, function-level understanding 4. High-quality software engineering - line-by-line understanding, interactive code reviews, indistinguishable from handwritten code You'll learn when to use each level, how to level up your agentic coding practices, and why the real problem with "slop" isn't AI - it's not putting enough thought and effort into the process. The key insight: more tokens spent doesn't have to mean more garbage. It can mean higher quality code, better research, and deeper understanding.

Artificial intelligence is evolving faster than any individual engineer, or engineering team can keep up alone. The organizations building the next generation of AI products won't simply have the best models; they'll be the teams that learn, adapt, and share knowledge the fastest. Developer communities have evolved far beyond networking events. Today, they serve as distributed knowledge networks where engineers exchange production lessons, validate emerging technologies, explore new AI frameworks, contribute to open source, and bring those insights back into their teams and organizations. In this session, I'll share practical lessons from helping grow, lead, and advise one of North America's largest developer meetup communities while engaging with engineers, researchers, founders, and technical leaders across the rapidly evolving AI ecosystem. We'll examine recurring engineering themes shaping modern AI: including agentic AI, open-weight models, AI infrastructure, developer tooling, evaluation, and engineering collaboration and explore how communities accelerate the adoption of these technologies. Attendees will leave with a practical framework for leveraging developer communities as a strategic advantage: accelerating technical learning, improving engineering collaboration, strengthening innovation, expanding professional networks, and helping both engineers and organizations adapt more quickly in the AI era.

Deep in enterprise infrastructure, platform engineers often play the mad scientist, stitching together disparate MLOps tools into a terrifying "Franken-stack", a fragile ecosystem held together by custom code and vendor lock-in. Let’s move past these infrastructure headaches and look at how Uber open-sourced Michelangelo to bring architectural order to the chaos. This session reveals how the platform anchors a consistent developer experience across the entire ML lifecycle using its three core open-source pillars: Uniflow for pipeline orchestration, the native Job Controller for automated cluster execution, and the Model Serving layer for low-latency inference. Through a live demo, we’ll provide a blueprint to seamlessly swap out your underlying infrastructure components, like shifting compute or orchestrators, without breaking your Python workflow code. Finally, attendees will get an inside look at our local sandbox architecture, allowing developers to safely spin up, experiment with, and master this composable, cloud-native stack on their own hardware.

Inference engineers solve a multi-dimensional puzzle across latency, throughput, and cost to serve generative AI models. Spanning interdependent layers of the serving stack, from CUDA to runtimes to containers to Kubernetes, inference engineering is the discipline behind scaling AI applications. In this session, we'll cover key inference engineering concepts across both runtime and infrastructure, including topology-aware model parallelism, prefill-decode disaggregated serving, KV-aware routing, autoscaling strategies, and multi-cluster infrastructure management, with a focus on the work required to run multi-trillion-parameter LLMs efficiently in production.

AI is now on both sides of the security equation. Attackers use it to find vulnerabilities, write exploits, and scale campaigns. Defenders use it to hunt threats, review code, and cut incident response from days to minutes. Meanwhile the surface to defend is exploding: more code shipped faster, much of it written by machines. But speed alone is not defense: machines that act in milliseconds can also be wrong in milliseconds, and someone still has to decide what gets automated and what does not. Where AI is genuinely winning for defenders, where it still fails, and what it takes to stay ahead.

Cloud companies spent years getting enterprise to go off-premise; now we're going to spend years getting them to go on-premise. This talk provides a practical snapshot of the local AI landscape and what building with on-device AI means for developers in 2026. We'll survey the current ecosystem, from open-weight models and model architectures to runtimes, inference engines, quantization techniques, and deployment options. We'll compare today's leading on-device models, discuss which workloads are best suited for local inference, and examine how developers are combining local and cloud models into hybrid systems. We'll also explore the broader trends shaping the ecosystem: the rise of open weights, improvements in model quality and efficiency, and the growing importance of AI sovereignty. We'll also discuss where local AI still falls short, including hardware constraints, operational complexity, and the workloads where cloud inference continues to be the better choice. Whether participants are early in their exploration of local models or already deeply embedded with on-device AI, this session will provide an up-to-date map of the ecosystem, explain the major technologies driving it forward, and offer practical guidance for choosing the right tools and architectures for their next project.

Bluesky is a decentralized social media application built on top of the AT Protocol. One way that Bluesky supports decentralization, and empowers users in the Atmosphere community to run their own unique AT apps, is through open source moderation tools. We do this through our Jetstream, which lets you stream AT protocol data collections into any other application or interface. The goal is to get records off the network and in front of automated rules and human reviewers, with no glue service in the middle. For example, our moderation stack consists of Osprey, an event stream decisions engine and analysis UI designed to investigate and take automatic action, and Ozone, a web frontend for making moderation decisions. Osprey is written in Python, and was designed and open sourced in collaboration with Discord. Osprey evaluates events using structured logic, user-defined functions, and external signals to assign labels, verdicts, and actions. Some of these, such as our Toxrank model for toxicity detection, make use of fine-tuned LLMs and other classifiers that expose their own web endpoints to Osprey. We also utilize image OCR and hashing to create actionable moderation metadata, which can be automatically actioned, surfaced to moderators via Ozone, and in turn helps shape our Discover feed algorithms. Although some of our internal heuristics are private, Osprey and Ozone are designed to be deployed and run by other app hosts with their own custom rules and moderation practices, whether they are reimplementing the Bluesky data model and feature set or running a different kind of Atmosphere app with a different set of content. In this talk, you’ll see a demo of the Jetstream, Osprey, and Ozone, learn about our rules engine and other architectural features, and leave with enough knowledge to integrate our open source moderation tools into your own stack.

Building a successful open source company without venture capital is rare - scaling it past $50M in revenue is even rarer. This talk distills two decades of hands-on experience growing and sustaining a commercial open source business from zero to global scale. We will share the real strategies that worked - navigating product-market fit, monetizing open source while keeping the core free, building a distributed team long before remote work was mainstream, and developing a repeatable go-to-market engine without external funding. We’ll also explore what didn’t work, the pitfalls we hit along the way, and the lessons learned from building a business that competed against well-funded alternatives. Whether you’re a founder, engineer, community leader, or simply curious about the business side of open source, you’ll walk away with practical insights, battle-tested frameworks, and a clearer understanding of how to build and scale an open source company the hard way - by bootstrapping.

No single AI model is best at everything. The challenge is knowing which model to use, how to measure whether it is good enough, and how to control cost as agents move across different tasks. You'll learn how to: Compare proprietary, open-weight, and fine-tuned models for different workloads Evaluate models on quality, latency, and cost using LLM judges Use Smart Routing to automatically match tasks and agent subtasks to the right model Govern agent workflows with policies, token limits, and spending controls This session includes practical demos of model evaluation, Smart Routing, and agent cost controls with the open-source tools Omnigent and MLflow. Whether you're building AI applications or coding agents, you'll leave with a practical framework for choosing, evaluating, and governing models without sacrificing quality.

What actually happens between a microphone on your wrist and meeting notes appearing on your phone? In this talk I crack open Biscuit, my homemade AI wearable, streaming audio over BLE to an iOS app, into live transcription with speaker diarization, and finally to an agent that turns every conversation into notes, actions, and even captured slides. Then I'll show you the shortcut: Bee, a production AI wearable with a developer platform, where you can build on the same ambient-agent ideas right away. Firmware to foundation models, there's a layer here for every developer to hack on.

The next productivity leap is not faster code completion; it is a pull request that can move from task to merge without constant human babysitting. This session presents a controlled autonomous workflow using GitHub Copilot app Agent Merge and a real application repository. We will demo an agent implementing a change, following repository-specific operating rules, responding to Copilot review, and waiting while GitHub independently evaluates the result. Secret push protection, code and dependency scanning, CodeQL, quality analysis, strict branch freshness, native C++ tests, and the .NET suite form a set of non-negotiable gates. Only after that evidence is green can Agent Merge complete the workflow. We will close with a clear division of responsibility: agents handle implementation and routine remediation, automated policy establishes baseline confidence, and humans focus their limited review time on intent, UX, architecture, and exceptional risk.

Between February 2025 and February 2026, coding agents went from writing none of Clipboard's code to nearly all of it. That changed our bottleneck. Writing code got cheap, but proving it worked did not. The failure mode was not just model quality. It was flaky E2E tests in shared environments that were hard to reproduce. With limited context, agents often reached for the wrong fix: increase the timeout or add a retry. This talk is a practical case study in rebuilding trust in tests for AI-heavy engineering organizations. I will show the workflow that helped us reduce the share of PRs affected by E2E flakes from 100% to under 15% in six weeks, including the open source libraries and agent skills we built to classify flaky tests, connect to observability signals, and decide which tests to harden, delete, quarantine, or move down the pyramid. Attendees will leave with a repeatable playbook for making coding agents safe to use at scale without teaching them that every failing test should be "fixed" with retries.

Incidents are usually reviewed as timelines: what failed, who owned it, and how we restored service. That works well for understanding a single outage. But when you operate platforms used by many services, the root causes change while the user-impact patterns start to look familiar. This talk introduces incident shapes: a way to look at failures by the pattern they draw across impact, time, and blast radius. I’ll use a few public incidents as reference points, including CrowdStrike’s outage, AWS’s DynamoDB outage where retry amplification played a role, Cloudflare’s WAF incident, and GitHub’s 2018 database failover incident. The incident shapes are useful because they change the questions we ask. A sudden spike makes us look at rollout containment and rollback paths. A slow burn pushes us to examine saturation, queues, and retries. A repeating sawtooth suggests the system may be recovering temporarily without becoming stable. Fan-out patterns expose the risk of shared platform layers. Boundary shifts are often the hardest to catch: one layer reports success, while users are still having a bad experience. The main idea is simple: the shape of user impact can tell us what the what the architecture failed to protect against. Attendees will learn how to quantify impact using breadth, depth, and duration, and how to connect those shapes to engineering responses such as staged rollouts, rollback automation, retry budgets, semantic canaries, cell isolation, contract checks, and end-to-end verification. The goal is to make postmortems more useful: not just to explain what happened, but to help design platforms that are harder to break in the same way twice.