Teams often give an agent a service credential, add a human approval step, and call the workflow governed. That design breaks down when the agent can revise payloads, retry writes, chain tools, or act across systems with different permission models. The result is an accountability gap: the organization can see that a service account acted, but not necessarily who authorized the business intent, which payload was approved, whether a retry duplicated work, or what changed between proposal and execution.

This session presents a production control model for agent workflows that make consequential writes. It shows how to separate the business-intent identity from the concrete operation; classify tools by impact; issue short-lived, least-privilege credentials only after validation; bind human approval to a canonical payload hash and policy version; execute through controlled services with idempotency keys; and reconcile external state before declaring success. It also covers the evidence record needed to answer four operational questions: who requested the action, what the agent proposed, what policy and human approved, and what the downstream system actually did.

The talk focuses on failure modes that appear after the demo works: stale approvals, overbroad agent permissions, duplicate writes after retries, silent policy changes, and actions whose outcome is unknown. Attendees will leave with a lifecycle they can map to their own platform, concrete interfaces between model output and deterministic controls, and an audit schema that supports incident response, compliance review, and day-to-day operations without turning every agent into a bespoke security project.

In large enterprises, work-intake is where strategy quietly goes to die. Requests arrive through multiple channels, context is incomplete, ownership is fuzzy, and dependencies stay invisible until they explode in the sprint. Leaders often reach for AI to “summarize everything,” but that first wave of copilots created a new problem: answers that sound confident while drifting away from reality—eroding trust, triggering governance pushback, and creating more churn than clarity.

This session is a practitioner blueprint for Intelligent PDLC: how to introduce AI into intake and planning in a way that teams can actually trust. Instead of focusing on model theory, we focus on the operating system around AI—how work gets structured, how ambiguity is handled, how evidence is captured, and how humans stay in the loop without slowing everything down.

You’ll learn patterns that consistently work in high-stakes environments: clarifying intent before generation, enforcing “evidence-first” responses, separating facts from recommendations, routing work to the right owners, mapping dependencies early, and defining escalation paths when risk or uncertainty is detected. We’ll also cover how to introduce these changes into existing rituals (triage, quarterly planning, roadmap reviews) so adoption sticks.

There’s a gap between researcher-crafted evaluation frameworks that capture model performance and benchmarks versus how end users actually use AI products. This gap is being exploited in ways that render traditional reward models useless.

Modern enterprise infrastructure environments generate massive volumes of operational telemetry, alerts, deployment events, and troubleshooting data, yet incident response workflows remain highly manual for many SRE teams. Engineers frequently spend valuable time correlating alerts, validating deployment health, searching fragmented documentation, and identifying root causes during high-pressure production incidents.

This session explores practical approaches for integrating AI-assisted operational workflows into Kubernetes-based enterprise environments to improve incident response efficiency and reduce operational toil. Drawing from real-world SRE experience supporting high-availability distributed systems in the fintech industry, the session examines how AI-assisted knowledge retrieval, alert correlation, deployment validation, and operational automation can improve reliability engineering workflows without introducing unrealistic “fully autonomous” operational assumptions.

We’ll discuss architectural tradeoffs, operational constraints, observability challenges, rollout validation workflows, and lessons learned while integrating AI-assisted tooling into production reliability processes. Attendees will leave with practical strategies for improving operational visibility, accelerating troubleshooting, reducing repetitive manual workflows, and building more scalable SRE practices for modern distributed systems.

To support complex autonomous tasks like model optimization and software engineering, we redesigned our AI infrastructure by shifting from stateless, request-response paradigms toward a model of managed, long-running execution. Structurally, this involved moving away from ad-hoc scripts toward a unified agentic harness where every session is treated as a durable, managed workflow. We implemented a decoupled sidecar architecture that effectively insulates core infrastructure from the unpredictable execution paths of autonomous agents, ensuring that identity, security, and network egress are managed through a hardened proxy rather than the agent itself

Attendees will walk away knowing how to architect a secure execution harness for autonomous agents, implement asynchronous human intervention models, and manage the lifecycle of persistent agentic sessions in high-scale production environments.

Drawing from hands-on work with off the shelf tools and custom AI tools, we will showcase how to move from “isolated pilots” to an Agentic Command Center. We will explore:

Secure Infrastructure: How to set up a “single pane of glass” that provides centralized governance and observability across diverse enterprise agents.

Practical Agentic Governance: A deep dive into the “Secured Agent Sharing” framework, demonstrating how teams can safely publish, discover, and reuse specialized agents without compromising data perimeter security.

Attendees will leave with a practical roadmap for transition from “Agent Sprawl” to a governed, scalable AI ecosystem.

Modern commerce platforms don’t fail because of missing features, they fail at the seams.

A product is created in Catalog, but pricing is incomplete. Promotions don’t qualify. Tax blocks specific regions. Localization lags. The system says “”launched,”” but the business knows it isn’t. These aren’t edge cases, they are the steady state of distributed commerce.

This session replaces traditional workflow orchestration with a multi-agent, swarm-based execution model powered by LLMs and agentic AI, coordinating Pricing, Catalog, Promotions, Tax, and Compliance in real time.

Agent Roles. Planner Agents decompose onboarding goals into executable plans using ReAct-style tool-aware reasoning and function calling. Domain Agents for Pricing, Catalog, and Compliance execute directly against APIs, Pricing Runtime, Offer Systems, Billing Preview, Tax engines. Validator Agents enforce policy rules, regional compliance, and pricing integrity at every step. A Coordinator Agent maintains shared state and resolves cross-domain conflicts through blackboard-pattern memory.

Execution Model. Agents subscribe to domain events, SKU created, price missing, policy violation, via streaming infrastructure. LLM-backed planners generate dynamic execution graphs, not fixed DAGs. Each agent invokes APIs as tools, binding service calls to reasoning steps. Coordination flows through a shared state store and event-driven updates, enabling adaptive planning under partial data, cross-service dependency resolution, and parallel execution with conflict detection.

Failure Handling. No blind retries. LLM-guided compensations roll back partial pricing, recompute discounts, and re-trigger downstream syncs based on causal analysis. No opaque errors. Every decision produces a chain-of-thought trace with tool invocation logs and reasoning outputs. No brittle state. Recovery is idempotent and event-sourced.

Onboarding Flow. Catalog Agents handle onboarding for products by ensuring the product definition is created, and the Pricing agent ensures SKUs are priced. Promotion Agents conduct market checks, provide qualified promotions and their onboarding, and resolve discounts using a rule-based and LLM-hybrid evaluation.

Compliance Agents validate regulatory constraints per geography. Localization Agents assess market-readiness signals, and product merchandising is localized accordingly. The Coordinator drives convergence toward “sellable state”.

Engineering Stack. Kafka-backed event contracts for agent triggers. Function-calling LLM agents with API abstraction layers. Vector DB plus state store for context propagation. Human-in-the-loop decision gates only at high-risk boundaries. Immutable execution logs tracing every action and compensation. Observability is built around decision reasoning, not just service health.

Takeaway. A working blueprint for LLM-powered agent swarms that handle uncertainty across distributed commerce, recover through intelligent compensation, and ensure products ship globally, not just deploy.
“

Deploying LLMs in regulated industries requires a fundamental rethinking of how ML systems are designed, validated, and governed. In this session, I’ll walk through the structural changes needed when building LLM pipelines that must satisfy regulatory frameworks like SR 11-7 — covering orchestration architecture, observability infrastructure, model risk controls, and documentation standards that go far beyond typical MLOps playbooks.
Attendees will walk away with:

A practical framework for evaluating LLM readiness for regulated production environments
Concrete MLOps patterns for auditability, explainability, and version control in compliance-driven settings
A checklist of the most common failure modes when deploying LLMs in regulated industries — and how to avoid them