Confirmed sessions.

Every agent query chains multiple LLM calls with retries. We measured the actual carbon cost of our agent fleet and it was shocking. This session covers the uncomfortable truth about agent energy economics, why observability multiplies inference spend, and the framework for deciding if an agent's business value justifies its environmental footprint.

I built a system that ships software with no human in the loop and no one reading the code. Here's how it works, and why it isn't slop. Intent comes in as an issue. An autonomous pipeline moves it through the stages a careful engineer would: design, tests first, build, review, merge. No human reviews the diff. What makes it safe isn't better code generation, it's everything wrapped around it. I'll walk the scaffolding: how tests and standards become the spec, so "working" is defined before any code exists; how quality is enforced structurally, not by a reviewer's attention; how it reviews itself adversarially, since a fluent machine convinces even when wrong; and the hard limits that bound a bad run. Plus the night it failed anyway. The takeaway: when code is nearly free, the engineering moves out of the typing and into the structure that decides what ships. That's the part you actually build.

What do you do when you have 733 production data pipelines tied to a deprecated operator and a timeline that would take a team of engineers over a year to complete manually? I built an AI agent to do it for you. In this talk, I will walk through how I designed an autonomous AI agent framework at Meta using Claude Code, Codex, and internal LLM tooling to handle code generation, validation, and deployment of production pipelines at scale. I will share how I defined validation criteria and rollback safeguards that allowed agents to ship pipelines unattended safely, compressing a 12+ month manual effort into 2 months. Key takeaways: How to architect an agent loop for code migration covering generation, validation, deployment, and rollback What breaks when you let agents run unattended and how to design safeguards that actually hold How to write repo level standards that govern AI agent behavior across an engineering team

Every software team faces pressure to ship faster without breaking things. When your company has real security concerns and skeptical leadership, "just turn on an AI coding tool" isn't a strategy. This session walks through a structured, phased pilot of OpenAI Codex focused on generating missing unit tests. Eight weeks in, cycle time on test writing dropped 19% median. You'll see how we built the ROI case for skeptical leadership, addressed security and compliance requirements before developers touched the tool, and why unit tests were the right first use case for managing risk. We'll cover how we designed pilot phases to generate visible evidence of responsible governance: documented guardrails, weekly retrospectives, and team-developed prompting best practices. Attendees leave with a reusable framework whether you're a developer wondering if AI tools are worth it, a manager building the internal case, or a technical leader navigating governance without killing the initiative.

Most AI applications begin with tightly coupled tools and quickly grow into complex agentic systems that are difficult to scale, maintain, and evolve. The Model Context Protocol (MCP) introduces a standard contract between AI applications and external capabilities, but understanding where MCP fits and where it doesn't is equally important. In this session, I'll share lessons from building production MCP servers and agentic platforms, explain how to decide whether your use case needs an MCP server, an agent, or both, and demonstrate how a well-designed MCP server enables reusable, discoverable, and composable AI capabilities. Through architecture patterns, practical trade-offs, and a live demo, attendees will leave with a clear mental model for designing scalable AI systems and making informed implementation decisions instead of simply adopting MCP because it's new.

For most companies, it’s standard operating procedure to test, measure, and A/B test things like user experiences, pricing strategies, and recommendation engines. But in the world of agentic AI, that discipline often gets ignored. But “agents deployed” isn’t the goal. The goal is to deploy agents that you actually trust in production. The reality is that systems built on AI aren’t static; they evolve. Teams are left struggling to tell whether their agents are improving or slowly degrading over time. In this talk, we explore a different approach in which agents are treated like products, and experimentation, refinement, and optimization are the norm rather than the exception. By applying the principles of A/B testing, organizations can compare agent behaviors, validate improvements, and detect regressions before they impact their customers. This gives teams the ability to base decisions on concrete evidence rather than leaving them to debate a prompt's efficacy based on intuition.

Despite significant investment, many enterprises struggle to move beyond isolated AI experiments. While promising pilots emerge, they rarely scale into meaningful business outcomes. The common response: Invest in better tools. Hire more talent. Try a new model. But the real constraint lies elsewhere. AI isn’t a magic bullet. It’s a force multiplier. And in most organizations, it’s amplifying the very conditions that are already holding them back. Fragmented data. Tightly coupled architectures. Delivery models that reward activity instead of outcomes. Even the best AI initiatives stall before reaching production. To get more value out of AI, you have to address what's missing around it. In this session, we’ll explore how leading organizations are aligning business priorities, data and delivery systems so AI can move beyond experimentation and become a reliable driver of value. By the end of the talk, you’ll know what it takes to make AI work in the real world of complex organizations.

Your AI agent has access to your database, your APIs, and your users' data. But would you give a new hire admin credentials on day one? We do this with AI agents constantly Guide dog training programs solved this problem decades ago. A guide dog doesn't get to navigate traffic until it's mastered basic commands. It doesn't work unsupervised until it's proven reliable across thousands of scenarios. And critically, it's trained in "intelligent disobedience" - knowing when to refuse a direct command because following it would cause harm I'll introduce the Progressive Trust Framework - a practical approach to AI agent deployment. You'll learn how to implement graduated permission systems where agents earn expanded access through demonstrated reliability. We'll explore the "3D's" testing methodology (Distance, Duration, Distraction) for validating agent behaviour before promotion. And we'll tackle the hardest problem: training agents that refuse harmful requests without becoming paranoid

When we transformed our data analytics and strategy consulting firm into an AI-driven business, we expected technology to change. What we didn't expect was that AI would expose bottlenecks that had nothing to do with technology. Roles and expectations changed. Workflows changed. Decision rights changed. Quality control changed. In this candid retrospective, I'll share what surprised us, where we failed, and which ideas we abandoned. I'll also share the five-phase framework that emerged from the experience and now helps organizations move from scattered adoption to intentional capability, giving leaders a practical way to understand where AI can create value, on what time horizon, and how to align those opportunities with their goals, strategy, and operating model. Attendees will leave with practical ways to identify bottlenecks, avoid common pitfalls, and understand why some organizations are capturing outsized value from AI while others are simply accumulating tools and experiments.

The next wave of AI development will not be defined by better autocomplete or another layer of chat interfaces. It will be defined by agentic systems that can plan, execute, inspect their own work, call tools safely, collaborate with humans, and carry state across real workflows. This talk looks at where AI development is headed over the next 12-24 months: from single-purpose copilots to coordinated agent systems embedded in delivery pipelines, operations, product experiences, and internal platforms. We’ll separate near-term reality from conference-room science fiction, covering the patterns that are already starting to work. It will also cover real world examples from within Meijer and other organizations and how they're looking at the future. The winners will not be the teams that “add AI” everywhere. They’ll be the teams that redesign software work around trustworthy delegation, measurable outcomes, and systems that know when to act, when to ask, and when to stop.

AI usage is climbing fast, and most teams have no idea what it's costing them or where the waste is. The reflex is to treat efficiency as the model vendor's problem. That worked when an AI feature was a single API call. It doesn't work now that we're composing platforms, MCP servers, RAG backends, and agentic pipelines we own. This talk reframes AI cost as a behavioral problem, not a vendor problem. We'll walk concrete, measurable techniques: model routing, right-sizing context, caching and batching, closing the capability-overhang gap, and agentic decomposition as a savings multiplier, plus the metrics to know whether any of it works. This session is for software architects, developers, and technical leaders who want to rein in AI spend without sacrificing quality. You'll leave able to spot where your pipelines waste tokens, apply specific techniques to cut that waste, and measure whether it worked.