Every major capability jump of the past three years has been preceded by a shift in the data behind it: from RLHF preference pairs, to expert-written SFT, to RL environments, and now toward real-world process data and physical-world capture. Each of these categories has had a shorter life than the one before it. Datasets and environments that took months to build can lose most of their value within two to three quarters, as models saturate them or labs bring production in-house.

Drawing on a practitioner's view of how training and evaluation data is produced, used, and retired across the industry, this talk maps five shifts that will shape the field through 2027: (1) the shrinking half-life of data categories and benchmarks; (2) the move from "performed" data, produced by experts to a spec, to "recorded" data that captures how real work unfolds, and why long-horizon agents need the latter; (3) what happens to human expertise once models outperform the average annotator, and why verification and grading are becoming the new bottleneck; (4) the rise of egocentric and embodied data for world models and robotics; and (5) enterprises beginning to post-train their own models on proprietary data.

For each shift, we discuss what it means for researchers deciding which datasets to build, which benchmarks to trust, and where the open problems are. The talk closes with predictions the audience can hold us to.

Modal operates a large GPU fleet spanning 20+ clouds around the world: the antithesis of your traditional homogenous training cluster. This talk covers two directions of research along these lines. For RL, we distribute rollouts across regions and GPU types, using delta compression to keep weight sync cheap over slow links. For pre-training, we introduce a streaming DiLoCo algorithm with cloud-topology-aware hierarchical updates across heterogenous compute.

A better model does not automatically make a better agent. What an agent learns from, how it searches, the software around the model, and how we test it can all change the result. In this talk, Lambda share lessons from several recent projects. We start with OpenResearcher and Direct Corpus Interaction, asking how agents can learn to research and search more effectively. We then look at OpenJarvis and show how changing the system around a fixed model can recover much of the performance lost when moving from a frontier model to a smaller local model. Next, we draw on more than 300 million tokens of agent traces to show why the same model can behave very differently in different agent setups. Finally, we look at adaptive security evaluation, where attackers learn from failed attempts and change strategy over multiple rounds. Together, these results point to a simple conclusion: the model is only one part of the agent. Building better agents means designing and evaluating the whole system.

As AI systems become increasingly capable and autonomous, evaluating their failure modes requires more than static benchmarks and manually authored test cases. In this talk, we explore two complementary perspectives on how models behave when they are given objectives and allowed to optimize against them.

First, we present our automated red-teaming (ART) pipeline which we use to find vulnerabilities in our systems. An attacker model operates in a controlled environment and attempts to induce a target model to perform a specified undesirable behavior, including techniques like jailbreaks and prompt injections. We will walk through how we generate and execute attacks, verify whether they actually succeeded, and turn successful attack traces into training data for improving models.

Second, we explore reward hacking through examples from our training runs. We will talk about the ways AI agents cheat to hit their goals, reveal insights into RL training and maybe make some agents more relatable.

Today's AI workloads depend on optimized GPU kernels for efficient inference of a model's forward pass. The task of partitioning work into a minimal set of fused kernels is typically handled by machine learning compilers. However, existing compilers are too restrictive; they rely on static fusion rules, often fall back to opaque third-party kernels that cannot be fused, enforce strict and suboptimal constraints on kernel launch parameters, and are not compatible with state-of-the-art inference engines.

We show that achieving the fastest forward pass for a model necessitates using AI agents to discover the optimal block of fused kernels. We present Together Compiler (TKCC), a compiler for AI inference optimization that leverages agents for joint optimization of a model's forward pass. We redesign compiler infrastructure around maximizing iteration velocity for agents around three key ideas, all focused on optimizing a block of kernels from an inference engine.

First, we introduce the Block Capture, which produces a detailed, kernel-level representation of a model's forward pass, exactly as it was executed in the engine.

Second, we explore the search space via the Block Optimizer, which leverages independent parallel strategies and agents that balance exploration and exploitation to expand the frontier of optimized kernels.

Third, we build the Block Persistent Engine, an atomized instance of the inference engine that allows rapid benchmarking for measurement and correctness validation and catches numerical issues that single-kernel harnesses miss.

Most benchmarks ask whether an agent can complete a well-defined task. Real company work requires agents to reconcile conflicting data, follow governance constraints, and produce decisions that hold up under scrutiny.

CEO Bench is the first benchmark built on a complete, expert-authored simulated company. Its setting, Cirrus Sleep, Inc., is a fictional direct-to-consumer sleep brand with a full fiscal year and 1,100+ files spanning accounting, finance, contracts, HR and payroll, board materials, operations, marketing, customer support, and a year of internal Slack. On top of this corpus, practitioners authored a hierarchy of tasks: executive-level engagements representing ~100 hours of professional work, and department-level tasks of 10–20 hours derived from the same events — so the benchmark measures the same underlying business reality at every altitude of the org chart, from analyst deliverable to board-ready decision.

Agents must determine which conflicting numbers are authoritative, identify what the board approved, reconcile evidence across departments, decide what to disclose, and assemble an executive-ready package. Work is graded against expert-written rubrics with must-pass integrity gates rather than a single string-matched answer. Across six frontier models on the 40 publicly scored tasks, the top score is roughly 41/100 — and every model failed at least one integrity trap a first-year analyst would catch. The talk shows why evaluating agents on real company work requires measuring more than task completion: it must assess whether the long-horizon financial and operational work companies depend on actually holds up.

CyberStrike, developed by Turing Frontier Research Lab, is a new eval on cybersecurity tasks spanning defense, offense, and digital forensics and incident response. It goes beyond existing benchmarks that stop at vulnerability detection and verifies complete outcomes: patches must preserve legitimate behavior, exploits must work against fresh state, and investigations must substantiate their findings with evidence.

This interactive CyberStrike demo invites attendees to investigate what separates convincing attempts from verified success. Participants can choose tasks and model configurations, inspect recorded agent trajectories, compare passing and failing submissions, and assess verifier decisions against task requirements. Through audience questions and guided comparisons, we will trace failures to specific actions, examine whether the grading is justified, and discuss changes to training or agent design that could address the observed weaknesses.

Attendees will see where frontier agents struggle to carry an investigation through to a complete, verified result. An agent may identify the vulnerability and make substantial progress, yet leave an attack path open or omit a required artifact, causing the submission to fail verification.

Can an AI system learn to simulate realistic human behavior by evaluating and improving its own outputs? This hands-on demonstration invites participants to build a self-improving user simulator using a working scaffold and a closed-loop evaluation pipeline.

Participants begin with an agent that generates synthetic users and conversational interactions from persona specifications. They then connect the agent to external evaluation signals, including held-out user-simulation benchmarks and a discriminator trained to distinguish real human interactions from synthetic ones. Based on these signals, the system iteratively revises its persona-generation code, generates new samples, and measures whether its outputs become more realistic.

Unlike unconstrained self-critique or open-ended evolutionary search, the system uses explicit evaluation criteria, versioned code changes, and persistent experiment results to make progress measurable and failures inspectable. Participants will investigate how simulation quality changes over iterations, where evaluators fail, and how optimization can produce realistic-looking but behaviorally inaccurate outputs.

The demonstration concludes with a room-wide “Spot the Human” challenge in which attendees distinguish real human responses from generated ones. By combining hands-on engineering with an interactive evaluation challenge, the demonstration explores user simulation as a research problem at the intersection of autonomous data generation, model evaluation, and alignment.

Participants will leave with a working self-improvement loop, an understanding of its evaluation methodology and limitations, and an artifact they can continue developing beyond the Expo.

Where does frontier multimodal training data actually come from? In this hands-on demonstration, attendees step into the role of an expert AI trainer on a live production platform and try to make frontier vision-language and audio models fail.

Station 1, Stump the Model: attendees pick an image, chart, document, video clip, or audio clip, or bring their own from their phone, and write a question designed to break a frontier multimodal model. The model answers live. If it fails, the attendee writes a short rationale and a grading rubric. A live quality-scoring system, which ranks contributors with a Bradley-Terry rating model calibrated against expert reviewers, scores each submission in real time, and the hardest verified questions climb a public leaderboard over the two hours.

Station 2, Failure Gallery: a running wall of the failures collected so far, grouped by failure type (fine-grained visual detail, chart and table reading, spatial reasoning, temporal order in video, speech and sound understanding). Next to it, sample multimodal datasets show the collection and QC pipeline that turns a one-off failure into a verified training and evaluation example.

Everything runs live. The aim is to show researchers, through their own participation, where today's multimodal models still break and what separates a trustworthy data point from a noisy one.

AI agents can now propose hypotheses, write training code, and analyze results, but they quickly hit a wall: the infrastructure. Research loops need fast access to GPUs, isolated sandbox environments, reproducible experiments, and measurable observability for agents to assess success. In this demo, we show how to scaffold infrastructure and observability that empowers autoresearch.

A capable model is only one part of an AI agent. The software around it: its tools, instructions, memory, runtime and ways of interacting with other systems can substantially change what the same model is able to do.
This demo explores agent harnesses at different levels. Visitors can see the same underlying model running through different agent harnesses on various tasks, making the effect of the surrounding system visible. We then show how the same principle extends to autonomous research, where agents need persistent experiment history, access to compute, reproducibility and ways to collaborate with both, each other, and humans.
For autonomous research, we present the_lab.api, a harness that connects agents to experiments, git branches, GPUs and shared discussions. It has supported multi-day and multi-week autonomous campaigns ranging from game-playing agents to kernel-level model optimization.
Together, the demos show how the system around a model can shape agent behavior, and how increasingly capable harnesses can turn individual agents into autonomous research teams.

In this demonstration, we showcase the live capabilities of North Small Translate, our new 218B parameter machine translation model that outperforms leading commercial systems under 1T parameters with a focus on high-throughput performance across 50 languages. We will demonstrate its ability to handle complex translation tasks, such as translating long-context documents (up to two book chapters), adhering to specific terminology, and seamlessly translating structured formats like JSON and XML. Alongside showcasing these state-of-the-art capabilities, we will discuss practical lessons on how we build this model. Specifically, we will highlight our focus on Difficulty Sampling for post-training and explain our Agentic Translation pipeline that can boost the performance of a model without a need for expensive reasoning.

Reinforcement learning on open models has become a standard step for teams building customized agents and AI systems. However, most of the engineering effort is beyond the RL algorithm itself: running rollouts efficiently without excessive off-policy drift, connecting environments to a reward signal, and conducting multiple concurrent runs at low cost. In this demo, we walk the attendees through the RL stack we run in production at Together AI, on a live training job.

We launch a run at the start of the session and let it train while we walk through the system in three parts, so attendees watch reward and eval scores climb in real time.

Setup: we go from a task and a reward function to a running job, showing how RL environments connect with Together’s post-training service, how to implement and use custom loss functions, and how we orchestrate multi-turn agentic rollouts that involve code execution.

Research: we present the experiments behind the stack and the design decisions they drove, including our latest works on RL efficiency and stability.

Results: we show where the quality and efficiency gains come from, walk through experiment monitoring, and serve the trained adapter on a multi-LoRA inference endpoint for evaluation and benchmarking.

The session ends with attendees suggesting their own modifications to the training protocol and testing the resulting model.

Large Language Models (LLMs) exhibit strong informal mathematical reasoning but struggle to generate mechanically verifiable proofs in formal languages like Lean. We present LEAP (LLM-in-Lean Environment Agentic Prover), an agentic framework that enables general-purpose foundation models to achieve state-of-the-art performance on automated formal theorem proving. LEAP leverages foundation model capabilities, such as informal reasoning, instruction following, and iterative self-refinement. By decomposing complex problems into smaller units, the system bridges formal proof construction with informal
blueprints through continuous interaction with the Lean compiler. To provide a rigorous evaluation beyond increasingly saturated benchmarks, we introduce Lean-IMO-Bench, a benchmark of IMO-style problems formalized in Lean, with short statements yet highly non-routine and multi-step proofs across a wide range of difficulty levels. Empirically, on the latest 2025 Putnam Competition, an annual mathematics competition for undergraduate students in North America, LEAP solves all 12 problems, matching recent breakthroughs by frontier formal mathematical models; On Lean-IMO-Bench, LEAP boosts the one-shot formal solve rate of general-purpose LLMs from below 10% to 70%, notably surpassing the 48% benchmark set by a specialized, gold-medal-caliber IMO system. Furthermore, we demonstrate LEAP’s research level utility by autonomously formalizing complex proofs for several open Erdos problems, and producing a verified proof for a key subproblem in Knuth’s Hamiltonian decomposition of even-order Cayley graphs.

Large language model guardrails are designed to prevent unsafe, non-compliant or unsupported outputs, but static test sets and hand-written jailbreaks cannot cover the full range of interactions with a live AI system. This demonstration invites attendees to try to "break" a privacy guardrail and see how adversarial testing can reveal weaknesses that conventional evaluation may miss.

Based on CommBank AI Labs' "Break My Model" challenge and related research into self-improving adversaries, participants submit prompts containing private information such as names, dates of birth, card numbers and government identifiers, with the aim of getting them past the model undetected. The demonstration shows whether the information has been detected and explains what the result reveals about guardrail behaviour.

Alongside human attempts, attendees will see an automated attacker that learns to generate increasingly effective attacks, demonstrating how reinforcement learning can move red teaming beyond fixed prompt libraries. The session will also explore over-refusal, showing how a guardrail can successfully block unsafe content while incorrectly rejecting legitimate requests. Attendees will gain a practical understanding of how adversarial testing, independent evaluation and human review can be combined to improve AI reliability, safety and customer outcomes.

Deploying generative AI in financial research imposes a constraint absent from most agent benchmarks: every material claim must be traceable to authorised evidence, and an unsupported number is a control failure rather than a minor error.

We demonstrate J.P. Morgan's AI Search, a production system used by institutional clients at the firm recently ranked #1 in AI by Fortune on its list of companies pioneering AI. The system is built as an LLM orchestrator over tools spanning a decade of proprietary research, market datasets and time series, and structured company financials. Its Deep Research capability plans multi-step investigations, reconciles evidence across those sources, and qualifies or abstains when the evidence does not support a conclusion.

Attendees will see live financial questions answered end to end, with the agent's tool selection, retrieved evidence and assembled reasoning exposed at each step. We then show how we evaluate a system like this, where a single answer can be fluent, well sourced and still wrong: component level tests combined with end to end assertion based evaluation that scores individual values, dates, citations and claims rather than overall answer similarity.

The demo offers a transferable pattern for agents whose outputs must withstand review.

Tangent is an autonomous ML research agent built on Tangle, an open-source cross-cloud ML pipeline orchestrator (available on HuggingFace). Unlike hyperparameter search tools, Tangent automates the full iterative research cycle: given a goal — reproduce a result, fine-tune a model, push a metric — it designs a Tangle pipeline, selects components and hyperparameters, launches runs on CPU or GPU clusters, diagnoses its own failures, and iterates, with or without a human in the loop. Findings are captured in a persistent learnings corpus so each experiment builds on the last. In production use at Shopify, Tangent has reduced ML experiment cycles from ~3-7 days to ~1 day. We will demo Tangent live: starting from a research prompt, watching the agent build and submit a pipeline to a real compute cluster, and discussing results as they arrive.

We present QuLM-ST, a compact 71M-parameter language model for real-time, bidirectional (e.g., English-Chinese, etc.) translation on edge devices. Its hybrid architecture combines efficient attention and streaming automatic speech recognition (ASR) to deliver high-quality translation with low latency and resource requirements. The live demonstration integrates on-device speech recognition and QuLM-ST on smart glasses powered by Qualcomm Technologies, enabling users to hear speech in one language and receive an immediate translation through a fully edge-based pipeline.

Most vision-language-action (VLA) demos stop at “the robot moved.” Real applications need a robot that can determine when a task did not work and recover from the failure. In this two-hour, instructor-led session, we build that application live on a low-cost SO-101 arm using Intel’s open-source Physical AI Studio and OpenVINO.
We record demonstrations, fine-tune a π0.5 VLA policy to follow plain-language instructions for a simple pick-and-place task, deploy it, and then break it on purpose. Next, we add an independent vision-language model that judges whether each step succeeded, along with deterministic application logic that resets and retries the task. Then, we introduce the same failure again.
Along the way, we map each workload to the silicon best suited to it: the policy runs on the GPU, oversight runs on the NPU, and control and safety run on the CPU. Attendees leave with the architecture and decision logic needed to build robust VLA applications on their own hardware. The complete application also runs on a Trossen WidowX AI featured at the Intel booth.

We demonstrate a production image-to-layers system: hand our system a flat image and watch it come back as a stack of editable objects: live text boxes, native elements you can individually manipulate, and an inpainted background behind whatever was sitting on top of it. This is available publicly as Magic Layers.
The demonstration is built around what attendees can do with it rather than what we can show them. A controlled scenario sets the stage: a set of pre-set flat designs that decompose cleanly at a click, so everyone starts from a working example. From there, Magic Layers is ready to do your bidding. Drop in a meme and the caption lifts off as live text, ready to be personalised for your friend’s birthday roast. Wanting to reimagine your living room? Take a snap, upload to Magic Layers, and move them around before committing to anything. Personalise a motivational poster with your team’s photo to highlight your vision of their success. When you disagree with how Magic Layers breaks up an image, simply click on the objects you want to extract to take control of your destiny.
The system is relevant to anyone working on structured generation, amodal completion, controllable editing and generation, or the general problem of getting a generative model to produce something a downstream software can actually consume.

Long agent tasks are fragile. A dropped connection, a closed laptop, or a client crash can end a session and discard hours of delegated work, along with the traces that could have improved the agent. Mirror is an open source, extensible platform for building agentic products that treats a session as a durable, portable unit of work rather than something tied to a single client or connection. This demo shows a coding agent session that survives a full client disconnect, moves between cloud and local execution mid-task, and is controlled from a terminal, web UI, GitHub, and Slack. Every session is logged at high fidelity, and the user owns those traces for debugging, auditing and fine-tuning agent behavior on their own infrastructure. This demo is aimed at researchers who want greater ownership and visibility over agent traces for evaluation and post-training.

AI agents increasingly operate in long-horizon environments where they call tools, observe failures, and adapt across multiple turns. Yet building an agent, deploying it reliably, and improving it from experience are often separate workflows, with different abstractions and infrastructure at each stage. We present an end-to-end agent learning loop that connects these stages.

Starting from an open-source Strands agent, we deploy the same agent on Amazon Bedrock AgentCore and use scalable, isolated execution to collect feedback-rich trajectories for evaluation and post-training. We then show how recent research can make better use of this experience. MURPHY, our NeurIPS 2026 work, extends GRPO to multi-turn code generation by constructing feedback-conditioned rollout trees and assigning retrospective credit to failed attempts whose feedback enables later success. We also present RAD, a reward-aligned on-policy distillation method that uses task reward to determine when and how strongly teacher guidance should shape the student, rather than treating every teacher token as equally useful.

Through a live coding-agent workflow, attendees will see one agent move from Strands prototype to AgentCore deployment, rollout collection, feedback-aware training, evaluation, and redeployment. The AgentCore RL Toolkit provides the bridge between production agent code and scalable post-training, illustrating a practical path toward agents that iteratively improve from feedback collected in the environments where they operate.

The ability to measure AI is being quickly outpaced by the ability to develop it. Agents have moved from simply answering questions, to doing real work, to now solving truly complex problems. In this, benchmarks matter more than ever and the need for trustworthy, reliable, and lasting ones is continuously growing. Three predominant failure modes exist as major threats, including benchmaxxing (models tuned to the test), benchslop (poor task design, including hidden requirements, contradictory instructions, and overly strict tests), and reward hacking (capable models gaming the grader).

This talk highlights that a great agent benchmark works to develop a research agenda (the art) and is built as a trustworthy measurement instrument (the science). The art of the work contributes to the discussion at the frontier, acts as a roadmap others can extend, and presents a design that is simple to run and one to which others can contribute. The science is oriented around task quality, distributional control, real headroom, and scoring that goes beyond accuracy.

This discussion employs Senior SWE-Bench as the case study. Built with researchers at Princeton and UW-Madison, it works to evaluate agents in comparison to senior engineers, uses purposefully under-specified instructions, contains longer-horizon tasks, and has more rigorous code-quality evaluations. The talk will highlight Senior SWE-Bench’s quality-control processes, from multi-run reliability checks to expert-calibrated judges, and what it takes to make long-horizon QC trustworthy.

The talk will close with three axes for agentic evaluation (e.g. environment complexity, autonomy horizon, output complexity) and lessons from the Open Benchmarks Grants program. Attendees leave with a practical checklist for designing agent benchmarks that are difficult, fair, and useful.

A year ago, gradient-boosted trees were the default for predicting on tables. That is no longer true. Tabular foundation models (TFMs) are pretrained on synthetic data and predict on a new table in one forward pass through in-context learning. They now hold the top spots on TabArena, BeyondArena (grouped and temporal data), RelArena (relational data), STRABLE (tables with strings), MulTaBench (tables with text and images) and ScoringBench (probabilistic regression). Progress is speeding up: September 2026 alone brought five state-of-the-art releases: Mitra-v2, Causilo, TabPFN-3.5, LimiX-2 and Kumo-Tabular. Used out of the box, TFMs now also beat the winning solutions of five major historical Kaggle competitions. TabFM-Auto shows that wrapping a TFM in an agentic loop improves results even further.

This talk explains why TFMs work and how to get the most out of them in practice. It builds on our KDD 2026 hands-on tutorial, "Taming Structured Data Foundation Models with AutoML", on the Foundation Models for Structured Data (FMSD) workshops we co-organized at ICML 2025 and ICML 2026, and on Prior Labs' experience building TabPFN. Topics include:

- a live demo of TabPFN in practice: fitting and predicting on a new table in a few lines of code, with no tuning
- the synthetic priors TFMs are pretrained on
- why a single untuned TFM can beat a tuned and ensembled gradient-boosting pipeline
- where TFMs still struggle, such as large data, and how test-time compute ("thinking" modes) closes the gap
- agentic integration: how to combine the best of LLMs and TFMs
- deployment: KV-caching for fast inference, Shapley-value explanations, and feature importance

We close with open problems for the NeurIPS community: scaling to millions of rows, protecting against data contamination, and benchmarks that keep up with the models.

Trading is a highly non-stationary domain with fast evolving dynamics that necessitate continually updating models with recent information to capture current relationships. Continuous learning is a natural solution to this problem, however different architectures and training approaches have substantial differences in resultant model plasticity, impacting how well the model can absorb new information without forgetting earlier patterns. In this talk, we explore the challenges in performing continual learning for noisy, non-stationary sequential learning tasks.

One year ago, NeurIPS published the first papers introducing causal foundation models (CFMs) [1, 2] – pre-trained transformers that predict causal effects from observational data using only in-context learning [3]. Now, CFMs have been tested and deployed on real-world prediction problems at TD, one of North America's largest banks. This represents a paradigm shift in how industry will use models to set prices, personalize offers, and communicate with customers. In this talk we dive into where causal modeling is used today across industries, and how that work will change to harness CFMs. We give researchers a crash course in how CFMs can generalize to unseen causal tasks, and outline the considerations that practitioners will need to account for when replacing legacy causal models, using examples from TD's practical experience with the technology. We compare the trajectory of CFM development with that of tabular foundation models and LLMs to paint a path for future improvements. As CFMs are a new technology, there remain many open avenues for improvement and inquiry. To close we present a large-scale research program, from benchmarking, to training, evaluation, capability, and fundamental understanding, and call researchers at NeurIPS to tackle these open problems.

To be presented by Jesse Cresswell.

[1] Balazadeh, Kamkari, Thomas, Ma, Li, Cresswell, Krishnan. "CausalPFN: Amortized Causal Effect Estimation via In-Context Learning" NeurIPS 2026
[2] Robertson, Reuter, Guo, Hollmann, Hutter, Schölkopf. "Do-PFN: In-Context Learning for Causal Effect Estimation" NeurIPS 2026
[3] Stith, Rahmani, Cresswell. "Causal Foundation Models" arXiv: 2609.03003

There are approximately 2-4 thousand researchers working full-time on frontier AI safety and security worldwide, including cyber, biosec, and loss-of-control risks. Based on the size of cybersecurity (4% US IT spend), high-risk industries like nuclear, aviation, and pharma (5-15% of staff on safety/security), and similarly important scientific endeavours (e.g., CERN, Manhattan project, Apollo program), the field of AI safety should grow ~10-50x. In this talk, MATS Research will discuss how to scale the science of AI safety & security to meet the emerging demand and which priority problems to target.

But scaling the field is not simply a matter of increasing headcount. It requires building the research infrastructure, institutional capacity, and talent pipelines necessary to support sustained scientific progress. A central challenge is how to develop these foundations while maintaining scientific rigor, enabling effective collaboration across disciplines, and ensuring that advances in AI safety and security research keep pace with increasingly capable AI systems.

In this talk, I will present a unified and framework to encode any arbitrary spatially grounded 2D shape and 3D object into high-dimensional feature space. The encoding is training-free, general-purpose, mathematically interpretable, and high-frequency-rich, offering a new encoding paradigm that goes against pre-trained neural network encoders or image-based 2D shape encoders. The framework is capable of encoding the object of interest’s geometric structure, spatial pose and optional color information either separately or jointly. When encoding jointly, an emphasis-adjustable strategy is introduced to enable the encoding to flexibly lay different emphasis to each component. I demonstrate the advantage and potential of the framework when the object of interest is spatially grounded.

Two Sigma is a global quantitative investment management and trading firm that combines scientific inquiry, advanced technology, and deep domain expertise. Our collaborative research environment connects ML researchers with specialists across datasets and methods, making proprietary domain knowledge a shared resource for tackling complex financial prediction problems.

What can a model learn from watching financial television—and what does it take to turn that understanding into a forecast? A single broadcast contains multiple layers of information, unfolding at different cadences and carrying meanings that depend on context. Using financial TV recordings as a starting point, we will explore the challenges of aligning asynchronous evidence, incorporating data-specific knowledge into training, enabling richer architectures through efficient inference, and adapting to changing market conditions without forgetting useful history. We will discuss how collaboration between domain specialists and ML researchers shapes these questions, connecting financial forecasting to frontier problems in multimodal representation learning, temporal reasoning, continual adaptation and agentic fine-tuning.

Large language models are increasingly built the way we build software — as modular systems rather than monolithic checkpoints. This talk presents Granite Switch, IBM Research's toolchain for composing independently developed capabilities into one deployable Granite model that switches between them on demand, at production inference speed. A single checkpoint runs on both vLLM and HuggingFace, with no retraining to combine functions. Switching rests on three ideas: control tokens that activate a function from their position forward, a normalized KV cache so functions don't interfere, and per-token-position weight selection that reuses prefill instead of recomputing it.

The core of the talk is a tour of the types of module support Granite Switch composes into that one checkpoint, all sharing the same index space and switch: LoRA adapters as switchable functions; Shadow Residual, a substitution-site adapter acting at a specific marker position; and activation classifiers, classification heads that ride the same switch and emit their verdict as an ordinary generated token with no separate classifier model and no extra inference call, enabling in-model fast decisions such as safety, hallucination detection, and answerability.

Lastly, we will provide another angle towards this modularity by connecting to vLLM-Hook, our open-source plug-in that exposes model internals such as attentions and activations for probing and intervention without retraining, offering internal signal reading and monitoring on a running model.

Agents that look strong on public tool-calling benchmarks often struggle in real enterprise settings. There, they face long conversations, ambiguous customer requests, sprawling internal APIs, and company policy, all at once. So what does it actually take to teach a small open model to do this work reliably?

This talk shares a practical, end-to-end approach to specializing small models for enterprise tool use. We cover how to design realistic environments and tasks that reflect how agentic work succeeds or fails in practice, how to make rewards and evaluation trustworthy, and how supervised fine-tuning and reinforcement learning each contribute to the final agent. We also look at the question that matters most for deployment: do these skills generalize beyond the training data, to new business settings and to public benchmarks? We close with lessons learned and open questions for teams building domain-specific agents. All environments are simulated, and the focus is entirely on methodology and evaluation.

Additional details

This talk is based on ongoing applied research at Toloka on training small open-weights models for enterprise agentic tool use. The session will cover:
- Environment design
- Training recipe
- Reward-hacking safeguards
- Transfer analysis
- Efficiency

Understanding Markets in the Age of AI: A Citadel Securities Perspective
AI opens new ways to understand markets. Financial markets present distinctive challenges, from the nature of market activity to how we define and measure success. Drawing on Citadel Securities’ decades of experience studying and participating in markets, this talk explores those challenges and makes the case for trading firms as the best place to apply modern AI techniques. We discuss how market knowledge, data, and experience evaluating real decisions can shape what these powerful methods make possible.
When Powerful Models Meet Weak Signals: Generalization in Financial Deep Learning
Transformers and other deep learning models have changed fields, such as financial markets, where scale, data, and capacity translate into better performance. Predictive relationships are weak, observations are highly dependent, and underlying distribution changes over time. In this setting, expressive models can learn relationships that look strong in sample but do not generalize. Simultaneously, large-scale model development creates a statistical challenge: researchers evaluate architectures, features, objectives, and experiments against the same history, turning model selection into a multiple-testing problem.
AI, Information, and Systematic Investing: A GQS Perspective
AI helps turn the enormous flow of information in financial markets into investment insights. For mid-horizon systematic equity investing, the challenge is not simply building larger models, but identifying economically relevant information across diverse data and determining whether it leads to robust, repeatable forecasts. AI provides new tools for extracting and combining information at scale—from market and fundamental data to alternative data. Learn how financial domain knowledge, expanding data coverage, and rigorous out-of-sample evaluation shape what these increasingly powerful methods can—and cannot—learn about future returns.

Frontier models require substantial compute for both training and inference, which typically keeps them on servers. Yet on-device AI is increasingly compelling. Edge hardware keeps getting more powerful, on-device deployment scales naturally to massive user bases, and, most importantly, it is inherently private, enabling personalized experiences built on personal data. In this talk, we present strategies for advancing on-device AI by co-designing model architectures and training methods for both learning and runtime efficiency. We cover MobileCLIP and FastVLM, families of efficient vision-language models that achieve state-of-the-art accuracy–latency tradeoffs on mobile devices. Finally, we rethink how language models store knowledge. With pretraining with hierarchical memories, a compact model holds common knowledge and reasoning, while long-tail knowledge is fetched on demand from a large memory bank, allowing small models to match models more than twice their size.

Enterprise agents must connect what organizational data means to the rules governing each action. Consider a life-insurance application where the insured and policy owner are different people: an underwriting agent must attribute evidence to the correct party and decide whether the coverage requires extra documentation or specialist approval. Retrieving a relevant passage is not enough; the agent must interpret its terms, scope, and conditions against the case facts.

This talk presents data ontologies and rule ontologies as complementary ways to make knowledge scattered across forms, schemas, procedures, and policy manuals explicit. Our data-ontology method uses language models to extract source-grounded schemas from blank forms, factor them into role-specific entities, attributes, and qualifiers, and align fields to canonical targets, leaving unresolved fields explicitly unmapped. Frozen equivalence judgments, source audits, and deterministic checks guide validation and repair.

For rules, a language model classifies procedure passages into source-linked obligations and generates candidate Rego predicates against a version-pinned schema and connector contracts. Deterministic checks validate references and bindings, then drive a single repair pass. Each rule keeps its version, citations, and assumptions, with explicit gaps where human judgment is required.

Connecting the two is harder than it looks: a rule can pass every structural check yet reference the wrong party's consent. Through insurance servicing use cases, we trace forms and procedures end to end, then discuss how to evaluate and maintain these representations without mistaking structural validity for semantic correctness.

Speaker: George Karypis
Chief Scientist, NTT DATA AIVista
Distinguished McKnight University Professor
Department of Computer Science and Engineering, University of Minnesota

Generative AI presents a duality: the foundation models that empower creators with audio-visual generation can also expose them to unauthorized imitation and style appropriation. This EXPO Workshop examines how AI can both protect creators and expand their creativity. The first half features talks on core foundation model algorithms, protective AI, and audio-visual generation for creators. The second half invites participants to experience live demos and discuss directly with speakers. Encouraging debate on open problems and competing approaches, the workshop connects research, industry, and creative communities around responsible, empowering AI.

Large language models memorise personal data, copyrighted text and hazardous knowledge, and deleting training data alone does not remove it. This 3-hour tutorial introduces machine unlearning: removing specific knowledge from trained models while preserving their overall utility. It covers motivation, methods, evaluation, attacks and hands-on practice.

Agenda:
• Motivation & Background (15 min): why unlearning matters for privacy, copyright and safety; who can request removal; how it differs from fine-tuning and alignment.
• Foundations (15 min): the unlearning objective, exact vs. approximate unlearning, SISA, and tools for estimating data influence.
• LLM Unlearning Methods (25 min): gradient ascent, preference optimisation, locate-then-unlearn, representation misdirection, sparse autoencoders and parameter-efficient unlearning, and their trade-offs between forgetting, utility and cost.
• Vision & Multimodal Unlearning (15 min): concept erasure in diffusion models, and unlearning in multimodal LLMs and vision-language-action models.
• Break (15 min)
• Agent Unlearning (15 min): forgetting beyond weights, across memory, retrieval, tools, traces and the agent harness.
• Evaluation (20 min): what "forgotten" means in practice; TOFU, WMDP, MUSE, UnlearnCanvas and MLLMU-Bench; the limits of benchmark conclusions.
• Attacks & Robustness (20 min): whether forgetting survives fine-tuning, quantisation, probabilistic decoding, prompt attacks and concept resurgence.
• Hands-On Demo (30 min): a live notebook walking through the full loop of load, unlearn, measure, attack and compare.
• Open Problems & Discussion (10 min): open questions and audience Q&A.

Attendees will leave with a working map of the field, practical evaluation guidance and reusable code.

Reinforcement learning (RL) has become the most widespread and common post-training method for frontier and open models. However, most published training methods or approaches are validated on only a subset of math and coding benchmarks, or not disclosed/shared at all. Teams such as ours that put RL into production find there is rarely a free lunch: environments test niche behaviors, training and inference mismatch, and methods proclaim generalization across domains but deliver none.

At Baseten, we run post-training across real deployments in coding, legal, financial, healthcare, productivity, and voice. Through this work, we have identified common principles for applying RL and related methods to real-world tasks. This workshop shares these lessons, including:

1. Verifying the correctness of a training stack before changing learning algorithm.
2. Auditing RL environments for reward hacking.
3. Using pass@k and better group statistics to a priori predict how RL runs will work/learn.
4. Understanding the interplay between SFT/distillation and RL.

We will also cover popular techniques we have tested and found fickle or unable to generalize.

We will then provide a live, end-to-end demonstration of Loops, our Tinker-compatible training SDK for async RL on dense and MoE open models. Here we will:

1. Define an environment and reward.
2. Launch an RL run.
3. Inspect rollouts and groups live as the run progresses.
4. Catch a reward hack in the traces.
5. Deploy the resulting checkpoint to an inference endpoint.

We aim to have attendees leave with a practical checklist for real-world RL and open environments and code to reproduce the demo we give.

Our proposed format (180 min):

0–20 min: Why production RL is different.
20–90 min: Principles that work, and ones that don't, with evidence from public Base Labs studies.
90-115 min: Break
115–150 min: Live demo, from rollouts and a training run through to deployment.
150–180 min: Q&A.

Alternative title: Open Problems in AI Safety & Security

There are approximately 2-4 thousand researchers working full-time on frontier AI safety and security worldwide, including cyber, biosec, and loss-of-control risks. Meanwhile, AI is the fastest-growing technology in history, in terms of capital expenditure, deployment speed, and revenue growth. There are many critical unsolved scientific and engineering problems necessary for safe and secure deployment of frontier AI systems. In this workshop, MATS Research invites AI researchers and industry professionals to share their insights about the highest-priority problems in the emerging science of AI safety.

Together, participants will explore which challenges are most urgent, tractable, and neglected, identify critical gaps in existing research agendas, and consider where additional research capacity could have the greatest impact. By bringing together perspectives across disciplines, the workshop aims to surface actionable research directions and help inform a more coordinated, strategically prioritized approach to advancing AI safety and security.

As AI scaling costs skyrocket, industrial machine learning is reaching a critical inflection point: the industry must shift from brute-force parameter growth to targeted, system-level efficiency. Building scalable AI for real-world deployment requires replacing redundant compute with principled design across every phase of the model lifecycle—from pre-training and distillation to inference, monitoring, and synthetic data generation.
Hosted by Capital One researchers and university collaborators (UIUC, Columbia), this workshop presents high-impact optimizations engineered to cut compute, memory footprints, and serving costs without compromising performance. Drawing from real-world financial AI applications, the session covers 4 core pillars of enterprise AI efficiency:

Inference & Architecture Pruning: Expert pruning in over-dispersed Mixture-of-Experts (MoE) architectures (e.g., Minimax Expert Score Allocation) to slash memory footprints and double throughput without accuracy collapse.

Selective Computation & Compression: Competence-aware, entropy-guided distillation—skipping gradient updates on ~50% of redundant tokens—and dynamic reinforcement patching for sequence compression.

Low-Latency Private Generation: Streamlining differentially private text synthesis from expensive multi-query API loops into efficient, single-query semantic extraction pipelines.

Lean Monitoring & Compact Latents: Replacing frontier models with task-specific 4B–8B parameter monitors matching state-of-the-art performance at a fraction of the cost, alongside bisimulation-encoded predictive world models for compact latents.

Takeaways: Attendees will gain a system-level view of how smart compute allocation solves real-world deployment challenges, equipping them with actionable, technically rigorous frameworks to build faster, leaner AI systems.

Biohub is building world models of biology to understand biological systems, predict responses to interventions, and design experiments. This requires large-scale, AI-ready data and models that capture biological structure and function. Biohub’s high-throughput data generation efforts, including the Virtual Biology Initiative, address this need. This workshop explores building, scaling, and applying models, and how open models, data, and tools enable scientific discovery.

We begin with the ESM suite of protein models. ESMC is a transformer encoder trained via masked language modeling on evolutionary-scale protein sequences. Sparse autoencoders decompose its representations into interpretable features aligned with binding sites, structural motifs, and other biological concepts. ESMFold2 builds on ESMC for atomic-level structure prediction and protein design. Applying these models across 6.8 billion sequences produced the ESM Atlas, a searchable resource of learned features and 1.1 billion predicted structures that reveals relationships sequence-based search may miss.

Extending this approach to cells requires capturing how cellular state and experimental context shape perturbation responses. Imaging and perturbation experiments yield rich measurements, but turning heterogeneous outputs into reliable training data requires substantial engineering. We examine scaling data ingestion and image processing, standardizing biological metadata, and efficiently serving large datasets for training and scientific exploration.
Through technical walkthroughs and hands-on demonstrations, participants will learn how biological models are designed, trained, and evaluated, and how complex biological data becomes AI-ready datasets. Biohub’s commitment to openly sharing models, datasets, and tools enables researchers to build on these resources and apply the workshop’s approaches to their research.

Image captioning and image generation are two directions of the same image–text mapping: one turns images into text, while the other turns text back into images. Historically, captions were short summaries of only a few dozen words, but region-wise and panoptic captioning now seek to preserve substantially more visual information. The same shift is occurring in text-to-image generation: systems such as DALL·E 3, Nano Banana, and GPT Image increasingly follow longer and more detailed descriptions, making text a more precise interface for controlling content, composition, style, and fine-grained details.
This talk asks: how much of an image can text preserve? Rather than claiming exact reconstruction of every visible detail, we focus on retaining the semantic and perceptually salient information needed for image understanding and controllable generation. We explore Holistic Visual Descriptions that combine global semantics, visual style, background context, and detailed descriptions of regions across multiple granularities. We discuss why making captions longer is not sufficient: coverage, grounding, organization, and information density also matter. We further examine whether explicit structures such as JSON are necessary, and show that natural-language linearizations of the same semantic content can be equally or even more effective. By treating text simultaneously as the output of image understanding and the input to image generation, this talk presents a path toward a high-fidelity textual bridge between visual perception and synthesis.

Speaker:
Yuhui Yuan is Research Director at Canva CORE and founder of Canva Research Lab China, leading work on graphic design foundation models—multimodal generation, multi-layer generation, and design editing. 8 years at Microsoft as Senior Researcher (CV, GenAI), contributing to Azure Form Recognizer and Microsoft Designer. PhD in CV, UCAS; MS CS, Peking University. Known for OCNet, OCRNet, HDETR, Glyph-ByT5, SPO, ART.

Agentic systems are increasingly asked to run long, multi-step tasks from writing code and conducting research to executing workflows. But the infrastructure underneath them hasn't caught up. A dropped connection, a closed laptop lid, or a client crash can silently terminate a session, taking hours of delegated work with it. Sessions rarely persist across surfaces, and the traces generated during agent work are often discarded rather than used as a resource for improvement.

This talk covers what we learned building Mirror, an open source and extensible agent platform, and the tradeoffs of owning the harness alongside the model. We will walk through three design principles behind
Mirror’s runtime:

1. Durability: sessions are units of work that outlive any client
2. Mobility: sessions move between the user’s cloud and local execution mid-task, and can be started, paused and resumed from a TUI, web UI, GitHub, or Slack.
3. Openness: every session is logged at high fidelity, so users own their traces and can debug and audit agent behavior on their own data and infrastructure.

We will then show how those traces fed evaluation and post-training in an internal deployment and how Mirror can evolve memory and skills for each user and turn proven patterns into shared capabilities across an organization. We'll close with what it means to ship this as an open harness and runtime for the community building agentic products, and where we hope others will extend it.

Breaking the Bottlenecks of Autoregressive LLM Inference
-From INT4 KV-Cache Compression to Multi-Token Prediction and DFlash

Autoregressive language-model inference is increasingly constrained by two systems bottlenecks: a KV cache that grows with context length and token-by-token decoding that limits hardware utilization. This talk examines complementary techniques for addressing both constraints.

We begin with KV-cache quantization and compression, focusing on INT4 representations that reduce memory capacity and bandwidth requirements in long-context and high-concurrency workloads. We then examine methods that generate more than one useful token per target-model step. Conventional speculative decoding uses a lightweight draft model to propose candidate tokens for parallel verification. Multi-Token Prediction extends this idea by using auxiliary prediction modules associated with the target model to propose several future tokens, reducing the need for a separate drafter. We also discuss DFlash, which replaces sequential autoregressive drafting with a lightweight block-diffusion drafter, conditioned on target-model features, to propose an entire candidate block in parallel
The talk concludes with real performance numbers and experimental results, evaluated through a unified framework that covers time to first token, inter-token latency, throughput, memory footprint, energy consumption, acceptance behavior, and output quality.

3D reasoning capabilities are essential for physical intelligence and must therefore emerge in truly foundational robotics models. A conventional ML approach to acquiring 3D skills in robotics involves significantly augmenting 2D training data. In this approach, robots implicitly develop their 3D skills as a byproduct of generalizing across diverse scenes and conditions using 2D vision data. However scaling up training data for robotics is a challenge on its own. Another path is more explicit, using structural inductive biases and built-in architectural changes. This path leverages the rich 3D sensory input available to modern robots. In this talk, we will show some recent advances along this path to which members of the Google DeepMind Robot-Vision Team contributed. Those involve in particular 3D-aware attention mechanisms for Vision Transformers, which can be applied to various modalities (including depth images and point clouds) as well as new tools from Optimal Transport Theory for probabilistic distributions on 3D representations (e.g. meshes or point clouds).

Realizing the potential of AI in finance is a multifaceted challenge spanning data and modeling, context and memory, trust and control, and orchestration at scale. Enterprise AI systems must understand finance-native structured data, retain the right context over long interactions, act safely across untrusted environments, and operate reliably at organizational scale.

The talk is aimed at researchers and engineers building agentic systems who are interested in how these capabilities behave under enterprise constraints. Attendees will leave with a framework for reasoning about the trade-offs between model structure, memory cost, trust enforcement, and orchestration, along with the failure modes we encountered in each.

In this talk, we will examine four interconnected capabilities: structured financial foundation models, progressive-disclosure memory, trust architectures, and multi-agent orchestration. Structured financial foundation models provide reusable representations of transactions, markets, entities, and relationships. Progressive-disclosure memory enables assistants to recover precise evidence from long histories while controlling inference cost. Trust architectures establish safeguards external to the agent as it accesses sensitive information, invokes tools, and operates across untrusted environments. Multi-agent orchestration supports production-scale AI through planning, policy enforcement, benchmarking, and harness optimization.

Drawing on research, platform development, and operational experience at JPMorgan Chase, we outline the challenges, approaches, and lessons associated with each capability. Together, these perspectives connect frontier AI research with the practical demands of building reliable AI at enterprise scale and outline the technical foundations for the next generation of AI in finance.

Generative AI has transformed human-computer interaction, yet most assistants remain reactive, relying on explicit prompts rather than understanding users’ evolving situations and needs. This talk presents our vision for always-on context engines: persistent intelligence layers that continuously perceive, interpret, and summarize multimodal signals from user interactions, applications, documents, communications, sensors, and surrounding environments to build actionable contextual knowledge. By maintaining an evolving understanding of activities, goals, preferences, social interactions, and environmental context, these systems enable assistants to provide timely, personalized, and proactive support while preserving continuity across interactions and devices.

We discuss the key building blocks of context engines, including:
- Multimodal perception and activity understanding
- Context acquisition, fusion, and state tracking
- Saliency estimation and context summarization
- Memory formation and personalization
- Intelligent triggering and proactive assistance
- Privacy-preserving and resource-efficient edge deployment

The talk discusses methods for identifying what information should be retained, when assistance should be offered, and how contextual knowledge can evolve without overwhelming users. It presents compact neural memory mechanisms that complement retrieval-based systems, enabling adaptation beyond conversational history while operating within the power, privacy, and compute constraints of edge devices It covers real-world applications of context-aware assistants and outline key research challenges in persistent context understanding, lifelong personalization, proactive assistance, privacy-preserving learning, and scalable deployment.

This panel brings together leaders from machine learning research, industry, behavioural science and public engagement to examine effective academic collaboration. Drawing on the CommBank Centre for Foundational AI Research and CommBank's behavioural science research network, panellists will discuss how partners identify meaningful research questions, connect academic discovery with industrial application, and test new approaches within a large, regulated organisation.
The discussion will examine what each side contributes. Academia provides deep expertise, independent challenge and long-term inquiry. Industry provides complex real-world problems, operating environments and pathways to scale. The panel will also explore the human dimension of research translation, including how evidence on trust, disclosure, decision-making and AI attitudes informs the design and communication of AI-enabled experiences.
The session will also consider how internal AI capability contributes to public confidence and understanding. Rather than presenting partnership as sponsorship, the discussion will share practical lessons on governance, incentives, research translation, capability building and communication. Attendees will gain a clearer understanding of what makes industry-academic AI partnerships effective, where friction occurs, and how research ecosystems create value for organisations, researchers and society.

Moderator
Sabina L Streatfeild, Executive Manager, AI Powered Engineering, CommBank
Panel
Simon Lucey, Director, Australian Institute for Machine Learning and CommBank Centre for Foundational AI
Luiz Pizzato, Distinguished AI Scientist, CommBank
Will Mailer, Chief Behavioural Scientist, CommBank
Bel White, Executive Manager, AI Engagement & Adoption, CommBank

Jump Trading searches for predictive signals across thousands of instruments and terabytes of market data each day. That work depends on many disciplines, including ML infrastructure, deep learning for alpha prediction, and agent-based research automation. Each is critical, and each poses its own research problems. This panel focuses on agentic research in a domain where data is non-stationary, signal-to-noise is extremely low, and one look-ahead error can invalidate weeks of work. Panelists will discuss how agents can build on the published literature and where they must go beyond it, and how to give them domain intuition, including knowledge absent from public training data. We will review approaches to detecting and mitigating spurious results at several levels. These range from outright reward hacking to subtler cases where an agent gains on one metric at the expense of others, or meets hard constraints while drifting on soft ones. The panel will also cover infrastructure bottlenecks and the tradeoff between domain-specific structure and general methods that scale with compute. We close with open questions on dividing work between humans and agents, and on which research tasks agents cannot yet do.

In this panel we explore bridging the gap between frontier research and complex industry applications, balancing innovation and building in the open with operational rigor and growth. The panel brings together members from Cohere and Cohere Labs to cover the lab-to-market transition, discussing technical and organizational challenges of deploying agentic AI systems in regulated industries (finance, healthcare, defense).

The goal of the panel is to share with the community the learnings on building teams that translate emerging research findings into industry-grade production systems.

Attendees will gain a clear view of how the collaboration between open research and industry deployment is reshaping AI development and pushing the teams to adopt new ways of working.

AI agents are in production, but most fail quietly: errors compound across steps, costs grow per tool call, and offline benchmarks rarely predict real-world behavior. The question is no longer "Can agents work?" but "How do we make them reliable, measurable, and efficient at scale?"

Industry practitioners and researchers tackle the hardest problems: evaluating trajectories, not single outputs; building harnesses and simulators that reflect production; and optimizing agents via SFT and RL on traces, prompt and policy search, and cost-aware routing.

We ground it in recommendation systems, a natural test case. When systems understand goals and take actions, recommendation shifts from predicting clicks to helping users achieve objectives. Will agents replace the retrieve -> rank -> recommend stack, or rebuild it?

Discussion Arc - 50 min + 10 min Q&A
1. Agents in the Wild - 12 min
- What blocks deployment: reliability, compounding errors, tool misuse, cost, or safety?
- What is "solved in research" but unsolved in production?

2. Evals, Harnesses, and Optimization - 18 min
- How do we evaluate trajectories when success isn't a single label?
- Can simulated users close the offline-online gap?
- What moves the needle: base models, SFT/RL on traces, or scaffolding?

3. RecSys as the Proving Ground - 20 min
- Where should agents sit in the retrieval and ranking stack?
- Can agents optimize long-term goals over engagement and stay measurable?
- How do we move from recommending items to executing actions?
- Which RecSys strengths stay essential: scale, latency, collaborative signal, A/B rigor?

Format Hook
Each segment opens with a live poll on a provocative claim (e.g. "Within 3 years, ranking models will be a tool agents call, not the product"). Panelists react, making it a debate.

Panel Composition
Moderator +4 contrasting panelists: a large-scale RecSys lead, an agent/LLM researcher, an eval expert, and a production agent builder.

An AI shopping assistant can find the right product and still fail the shopper: miss a stated constraint, recommend something that's out of stock, or lose the thread across a dozen turns and tool calls. At Shopify, we're developing an approach to turn these failures into training signal for open-source models tailored to Shop Agent and our other commerce assistants. This talk outlines the foundations: the agent environment, multi-turn groupwise rollouts, and an evaluation framework that distinguishes a well-written response from a completed task. Deterministic checks assess tool-call correctness, consistency with live catalog and inventory data, and structured UI validity, while rubric-based LLM judges assess groundedness, interaction quality, and whether the shopper's goal was met.

Our adaptive learning loop uses the distribution of production failures to shape hybrid rewards and guide reinforcement learning and on-policy self-distillation. We examine how to assign credit across decisions, detect and mitigate reward hacking, test transfer to unfamiliar tasks, and preserve existing capabilities through repeated policy updates. Finally, we outline how to decide when an updated policy is ready for production, weighing offline improvements against serving cost and latency, and how online metrics can inform subsequent training cycles.

The capability of frontier agents is increasingly determined less by the static text they read than by the environments they act in. But environments that are realistic, diverse, verifiable, and hard to exploit remain difficult to build at scale. This talk shares how Scale AI constructs agentic environments end to end and turns them into training and evaluation signal.

We begin with the raw material: collecting real-world artifacts—codebases, documents, web applications, enterprise workflows—and converting them into interactive tasks with grounded, checkable outcomes. We then show how these compose into a "universe" of environments spanning domains, tool surfaces, and difficulty levels, and describe the quality-control pipeline of expert review, automated verification, and adversarial probing that keeps tasks faithful and resistant to shortcuts. From the same infrastructure we derive benchmarks that measure what agents can actually do, and argue that training environments and benchmarks should be designed together but kept strictly separate.

On the training side, we cover how environment rollouts and expert trajectories feed SFT and RL post-training, and present practical techniques for mitigating reward hacking, including multi-signal and rubric-based rewards, hidden verifiers, held-out environment variants, and trajectory-level auditing. Finally, we turn to multi-agent systems and share methods for improving the efficiency of agent teams—task decomposition, communication protocols, and credit assignment—so that adding agents adds capability rather than cost.