Confirmed sessions.

As AI transforms business operations and drives economic growth, a critical question remains unanswered: How do we ensure its benefits are shared equitably while minimizing harm? This session will challenge leaders to expand their perspective beyond conventional AI metrics like efficiency gains, cost savings, and productivity, to include social impact as a vital measure of success. Participants will learn why conventional responsible AI principles, while important, fall short without frameworks that meaningfully center communities, lived experience, and long-term outcomes. The session will provide practical strategies for leaders to address these shortcomings, specifically integrating social impact considerations into AI strategy and project success metrics. Attendees will leave equipped with tools and recommendations to build AI strategies that strive to benefit everyone.

We'll dig into Burea of Labor Statistics, National Bureau of Economic Research and other data to explore the bull and bear cases across industries ranging from law, medicine, software and finance. We'll also look at AI as a strain of Digital Taylorism and AI's role in the erosion of seniority pipeline.

The common logic of AI adoption says we must ease people in: start with autocomplete, move to copy-paste chat, and eventually graduate to autonomous agents. We assume people are afraid, or that baseline tools are "good enough." But this rigid progression gets it backward. Borrowing a proven page from Mob Programming navigation, what happens when we invert the conversation? Instead of forcing a slow climb up a ladder, we hand over a full agentic harness on day one. We start at the highest level of capability, allowing the human to explore, self-select their comfort zone, and safely pull back by asking questions. Backed by the real-world case of a non-coder successfully navigating a cloud-backed agentic framework from scratch, this session explores how providing high-leverage tools creates true labor equity. You’ll leave with a practical framework for building psychological safety, honoring human dignity, and letting individuals choose exactly where they want to land.

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.

We built podcast transcription, AI show-note generation, hybrid semantic search, and an "ask the catalog anything" RAG flow on Rails — without sending a byte (or a cent) to OpenAI. Whisperx for transcription, llama3.1:8b for generation, nomic-embed-text for embeddings, all behind a private network as shared Kamal accessories. I'll show the field-by-field prompts that coax structured JSON from open-source models, the LLM-as-judge eval loop that catches bad outputs before users see them, the streaming-via-Turbo-Streams UX that makes batch inference feel instant, and the citation-grounded RAG demo we ship to production. You'll leave with a working architecture for AI on Rails without an OpenAI bill — and the feedback loops to keep it honest.

In our continuous effort as engineers to find the fastest and most effective solution, it's tempting to assume the latest multimodal LLM with a well-crafted prompt can solve almost anything. So how come the technology that often blows our minds can fail on seemingly basic tasks, and how can we extend its limits? In this talk, I'll present a case study of building "The Evaluator," a production system for image-text matching, and show how a deceptively simple binary question ‘does this sentence match this image?’ resisted our best single-prompt solutions even with the largest models. Through systematic experimentation, we found that task decomposition dramatically outperformed monolithic approaches: by breaking the matching problem into specialized sub-tasks - entity matching, semantic alignment, visual interest, and temporal alignment - and orchestrating multiple models into a single pipeline, we achieved significant gains in both accuracy and operational efficiency.

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.

This practitioner session shares lessons from 300+ AI-assisted development sessions, 19k+ messages, 3k+ commits, and 30+ repositories. The core finding: AI agents became reliable only when we taught them the same engineering discipline we teach humans — clean code, SOLID, TDD, micro-commits, small classes, review expectations, and fast feedback loops. We’ll show how vague prompts failed, why binary HARD BLOCK rules worked, and how version-controlled AI skills turned human coaching practices into reusable guardrails. We’ll also cover context handoffs, independent verification, and cost-tiered model use: stronger models for planning and Haiku for bounded coding once standards and checks were in place. Attendees will leave with concrete patterns they can try immediately: converting vague expectations into AI skills, replacing soft prompts with HARD BLOCK rules, separating coding from verification, and using stronger models for planning while cheaper models handle bounded work.

Generative AI is spreading through organizations faster than any technology in recent memory. Employees are experimenting, executives are investing, and new use cases emerge daily. But while adopting AI is easy, integrating it into the way your organization makes decisions, manages risk, and creates value is much harder. Drawing on more than a decade advising executive teams on digital transformation, Dave Todaro explores why organizations struggle to adopt disruptive technologies—and how AI is exposing those challenges faster than ever. Attendees will learn a practical framework for aligning leadership, enabling responsible experimentation, and creating the conditions for AI to deliver lasting business value. Key takeaways • Why AI adoption is primarily a leadership challenge. • Guardrails that accelerate rather than slow innovation. • A practical framework for scaling AI responsibly.

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.

Most product orgs were not designed for speed. They were designed around the assumption that shipping software is slow, expensive, and risky—and nearly every layer of the org chart exists to manage that slowness. Program managers synchronize work split across team boundaries. Specialist functions run their own backlogs and SLAs. Product leadership plans in quarters - the natural rhythm of slow work. AI-driven delivery breaks these assumptions. When a team ships in a day what used to take six weeks, the coordination meeting takes longer than the work it was meant to coordinate. The specialist intake queue becomes the bottleneck. The annual roadmap is wrong by the second week. This talk makes the argument that most orgs are avoiding: if we're serious about what AI does to delivery speed, we have to be equally serious about what it does to everything surrounding delivery. Drawing on my experience helping orgs make the shift, I'll lay out the shape of the new product org.

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.

Enterprise AI is moving beyond pilots, but many organizations still struggle to turn experiments into systems that deliver measurable value. This session shares lessons learned from deploying six enterprise AI systems across RAG, autonomous agents, intelligent document processing, cloud optimization, and security automation supporting 270 data centers and 10,000 customers. Attendees will learn how tiered model routing reduced inference costs by 74% while maintaining 94% response accuracy, how intelligent document processing achieved a 35:1 ROI, and how autonomous remediation workflows reduced triage workloads by 67% while resolving more than 35,000 vulnerabilities. The session also covers governance guardrails, AI FinOps, observability, and ROI measurement. Attendees will leave with proven patterns for scaling enterprise AI responsibly and delivering measurable outcomes in production.!

Organizations understand AI’s potential, but many initiatives stall before delivering meaningful operational impact. The problem is rarely the model alone. More often, AI struggles to scale because data is fragmented across legacy systems, governance is added too late, and decision processes lack the explainability and human oversight required in regulated environments. This session explores a practical framework for deploying human-governed agentic AI workflows on top of existing systems. Rather than waiting for large-scale modernization, the approach focuses on making data AI-ready, orchestrating governed agentic workflows, and embedding human oversight directly into decision loops. Attendees will learn how organizations can move beyond pilots by designing for trust from the start; combining explainability, auditability, and human-in-the-loop control to enable safe, scalable AI adoption in high-stakes environments.

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.