All sessions and workshops curated by leading AI/ML practitioners

This talk shares lessons from building a self-recovering browser agent for regulated healthcare workflows, where we moved from a single-agent prototype to a multi-step system with optimized inputs, memory, evals, sandboxes, and deterministic code where possible. I’ll walk through how we used production failures to build a faster evaluation and prompt optimization loop, and when to move beyond harness engineering to increasing model capability via post-training.

Large language model (LLM) agents can now draft executable business logic — compliance rules, audit checks, detection heuristics — orders of magnitude faster than human engineers. In regulated domains, however, no such logic ships without a human domain expert’s sign-off. We identify a subtle and, in our experience, pervasive failure mode in this human-in-the-loop pattern: review/serving skew, in which the evidence a domain expert reviews is generated by a re-implementation of the candidate logic (a survey script, a notebook, a prompt-level approximation) rather than by the production engine that will ultimately execute it. When the two implementations diverge — and they reliably do — expert approval validates the wrong behavior. We present a discipline that eliminates this failure mode by construction: candidate rules are drafted directly into the production repository in an inactive-but-runnable state, all review evidence is generated by the production execution path, refinement edits the production artifact itself, and activation is reduced to a one-line data change. We describe the discipline in the context of a deployed multi-agent system that authors, validates, and ships declarative compliance rules for automated audit of collision-repair insurance estimates, evaluated against a corpus of approximately 497,000 production documents. The system couples eight specialized LLM agents with deterministic safety rails — golden-fixture regression, an activation allowlist, single-rule change isolation, and corpus-governance constraints — and drives refinement through a bounded, measurable convergence loop against expert false-positive verdicts. We formalize the discipline as five principles, catalog the anti-patterns it forbids, report operational experience from sixteen production rules, and argue that the pattern transfers directly to clinical decision support, financial transaction monitoring, legal document review, and content moderation.

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.

This session examines how a traditionally static enterprise agent workflow was redesigned around AI-driven adaptation. In most enterprise settings, agent behavior is defined through fixed prompts, rules, and workflows that apply broadly across users and tenants. We redesigned that model into an adaptive agent architecture built around explicit policy layers, feedback loops, and governed personalization. Structurally, this changed the system from one-time configuration to continuous learning: policies were separated from model reasoning, policy scope was organized across global, tenant, and user levels, and agent behavior was connected to both explicit and implicit feedback signals that could influence future decisions.

The session will focus on what changed in the system architecture and operating model to support this shift. It will cover how policy-driven personalization was introduced, how feedback became part of the runtime and improvement loop, and how adaptation was managed without losing enterprise control. It will also discuss the practical challenges that emerged when moving from static agents to adaptive ones, including handling conflicting user and tenant needs, keeping personalization aligned with core guardrails, and making behavior changes observable and manageable in production.

Attendees will walk away with a practical understanding of how to redesign enterprise agent workflows around adaptive AI capabilities. They will learn the core concepts behind Personalized Experiential Learning, the structural changes needed to support policy-based adaptation, and the key lessons and best practices for making adaptive agents workable in real enterprise environments. They should leave better equipped to think about how to introduce governed personalization, feedback-driven improvement, and policy evolution into their own AI agent systems.