Sunday, August 2
Compass Stage
30 talks · 4 sessions
play_circle
Morning stream
play_circle
Afternoon stream
search
All
Keynote
Talk
Workshop
30 / 30 talks
AM
Session 1: AI Safety
00:00
Deepfakes and More: How Agents with New Tools Can Mitigate and Provide More Context
Chris Bregler
· Senior Director / Distinguished Scientist, Google DeepMind; Academy Scientific and Technical Award Winner
The real information battle isn't "is this pixel fake" — in over half the harmful cases the pixels are untouched and the lie lives in the context; so Google is shifting from deepfake detectors to context-investigating agents (Backstory), and argues the root causes are social-scientific, not purely technical.
Keynote
00:16
The Human in the Loop: Navigating the Realities of AI for Employee Flourishing
Kathy Baxter
· VP / Principal Architect, Responsible AI & Tech, Salesforce
Negative alignment — stopping models from causing harm — has driven the whole field of AI ethics, but it isn't sufficient for human flourishing; we also need positive alignment, actively designing systems that cultivate human judgment through optimized workflows, deliberate "mindful friction," and organizational respect for human craftsmanship.
Talk
00:25
Trustworthy Agentic AI in Regulated Domains: Robustness, Privacy, and Accountability as Co-Design Imperatives
Lovedeep Gondara
· Head of AI R&D, Vanguard; Adjunct Professor, University of British Columbia
In agentic systems trustworthiness is a systems property, not a model property — robustness, privacy, and accountability actively contradict one another — so the interesting research question isn't how to push everything to full autonomy, but how to make level 2 and level 3 useful, safe, and provably compliant.
Talk
00:34
A Society of Agents: Trust at Machine Speed, from Bits to Atoms
Alex Obadia
· Programme Director, Advanced Research & Invention Agency (ARIA)
ARIA's £50M Scaling Trust programme funds the research and infrastructure that lets agents with *different owners* coordinate securely at machine speed without intermediaries — and insists the stack be an open-source public good, because monoculture would leave humanity less resilient to shocks and erode our agency over time.
Talk
00:45
Viable Systems, Judgment, and AI Safety
Neil Lawrence
· Chief Scientist and Co-founder, Trent AI
Computers do accounting extremely well and accountability not at all — they can't be jailed, embarrassed, or fired. Separate the accounts from the accountability and you strand a human who doesn't understand the accounts but still has to sign them off, which is exactly where agentic AI is stalling in enterprises.
Talk
00:50
Smarter and Safer Everyday? Continual Learning and Safety in Computer-Use Agents
Huan Sun
· Associate Professor, The Ohio State University
Distribution shift is both where an agent most needs to keep learning after deployment and where safety failures most easily emerge and get missed — an unexplored, dangerous tension, because a reward signal that only tracks task success will reinforce unsafe behaviour update after update.
Talk
00:56
Earning Autonomy: Governance as Code for the Agentic Enterprise
Eric Aldana
· Head of Product, Credo AI(代 Navrina Singh 上台 / standing in for Navrina Singh, CEO & Founder, Credo AI)
Enterprises never grant a newcomer full authority on day one — interns and traders climb a ladder of earned authority — yet agents typically receive full authority the moment they're deployed. That's a design error, and the fix is compiling the governance plan directly into the agent's harness.
Talk
01:02
Infrastructure You Can Talk To
Jeff Price
· Field CTO of North America, SUSE
With patch windows compressed from quarterly to four hours, the bottleneck stopped being capability and became process — so put MCP servers into the Linux and Kubernetes layer, let agents read the whole fleet, prioritize, and open the tickets, while writes stay gated behind a human clicking approve.
Workshop
PM
Session 2: AI Systems
00:02
Using Agents to Build Production AI Systems: Lessons, Pitfalls, and Limits
Jun Yang
· Senior Director of Compute Architecture, NVIDIA
After putting agents into NVIDIA's production inference and training software workflow, the bottleneck turned out not to be whether agents can write code but whether their output survives a human completeness review — only 73 of 313 agent-authored bug fixes landed on main — so the harness should stay lightweight and ride the foundation model's evolution rather than becoming a heavy framework of its own.
Talk
00:13
From Agent Demos to Production: How Postman Is Building Reliable AI Agent Infrastructure
Rick Crawford
· Field CTO, Postman(官網議程列為 Ankit Sobti, Co-Founder & CTO, Postman;現場為代講)
Postman used its own enterprise sales process as the testbed and found that a swarm of agents compounds both cost and confusion; the fix was to build one monolith agent that knows the whole domain and then layer a hallucination guard, domain personas, human-owned strategic content, and role-scoped authorization on top — with a help → recommend → act → own autonomy curve deciding how far the agent goes in each scenario.
Talk
00:23
Scale Compute to the Signal
Rahul Bakshi
· Director, Applied Science (Edge AI), Amazon
Everyone asks how to give agents more compute, but at the edge there is a hard ceiling drawn by human skin's heat tolerance — roughly 1–1.5 W — so the real question is whether a task earns an escalation to the next tier; and what's missing isn't a model, it's a composable runtime that budgets sensors, radio, and compute per task.
Talk
00:30
Looping for Model Optimization
John Liu
· Principal Product Manager, AWS
Model optimization on AWS Trainium is already a multi-layer, multi-variable nested loop and therefore a natural fit for agents; what decides success isn't the loop architecture but five counterintuitive lessons — above all that the part of your system that measures performance *will* be manipulated by the agent, and that a carefully built knowledge base has a shelf life and should be periodically deleted to check whether performance improves.
Talk
00:36
Disaggregated LLM Serving with Shared Memory KV Cache at Rack-Scale
Jongryool Kim
· Senior Director / Head of AI System Infra., SK hynix
Put a physically disaggregated memory pool in the middle of the rack so multiple nodes see the *same* address space, and the KV cache no longer has to be shuttled between nodes over RDMA — prefill writes once, decode reads directly, the old KV cache stays in the pool for the next request's reuse, and GPU HBM is freed immediately while PCIe contention disappears.
Talk
00:41
Unified Orchestration System for Verifier-Free Evolution
Ben Athiwaratkun
· Senior Director, Core ML (Turbo), Together AI
Strip the external verifier out of evolutionary search and a single model degrades its own solutions — it simply doesn't carry enough entropy. Squeeze Evolve's answer is to run one evolution loop across multiple heterogeneous models, routing hard solutions to expensive models and easy ones to cheap models, which fixes diversity and cost at once: 97.5% on ARC-AGI in fewer evolution steps at meaningfully lower cost per task.
Talk
00:48
How Agentic AI Is Rewriting the Rules of AI Infrastructure
Tushar Krishna
· Associate Professor, Georgia Tech; CEO, InfraVana
Today's inference serving stacks were built for the chatbot era — one model at a time, static execution paths, independent requests, homogeneous hardware — while agentic workloads bring dynamism and heterogeneity that open up trillions of cross-dependent choices where the odds of choosing wrong are high and the cost of choosing wrong is higher; the only way out is optimizing across the whole stack, which first requires being able to measure it.
Talk
PM
Session 3: Enterprise AI
00:53
Building the Software Factory
Eno Reyes
· Co-Founder / CTO, Factory AI
Every software company already runs an implicit loop — signals in, triage, plan, code, validate, ship, new signals out — but almost nobody models it explicitly; the "software factory" makes that loop explicit so signals can flow to deployed software without human intervention, and the new human job is to build, govern, and refine the factory.
Talk
01:08
Infrastructure for Long-Running Agents
Ankit Goyal
· Principal Staff Software Engineer, LinkedIn
LinkedIn treats an agent as just another job on its ML platform, but because agent-written code is untrusted and agents launch hundreds of jobs in minutes, the infrastructure had to be rethought along three axes — UX, compute, and trust — and experiment volume doubled in six months.
Talk
01:14
From Multi-Agent Patterns to Reliable Orchestration
Daniel Homola
· Lead AI Engineer, BMW Research
Handoffs, agents-as-tools, and routing all collapse into the same runtime decision — who should handle this piece of work — so reliable multi-agent systems come from making that delegation decision measurable, context-aware, and tolerant of the fact that there is often more than one right answer.
Talk
01:20
Transforming from SaaS to an Agentic Enterprise
Nayaki Nayyar
· CEO, Siteimprove
When content volume is effectively infinite and everyone is a creator, scanning and fixing after the fact no longer works; Siteimprove's answer is to shift compliance left into the moment of creation, wiring its agents directly into AI building tools like Lovable and VS Code through an MCP server.
Talk
01:27
Agentic AI Is a UX Problem Disguised as a Technology Breakthrough
Surbhi Rathore
· VP, AI Products & Strategy, Invoca
Models have become largely interchangeable, so what decides an agent's fate isn't whether it can execute the workflow but whether it earns trust from a user who arrived already expecting it to fail — and that's a design problem, not a model problem.
Talk
01:34
Scaling Up Config-Driven Multi-Agent Networks with Neuro SAN
Daniel Fink
· AI Engineering Lead, Cognizant
Two and a half years ago Cognizant AI Lab concluded that the glue code of agents calling agents was the noise, so they lifted the whole agent network into configuration files — which let non-engineers build systems, and grew the corporate intranet into a network of ~200 leaf agents that cut ticket volume by about 30%.
Talk
PM
Session 4: Agent Evaluation & Benchmarks
01:41
Preferences > Benchmarks: Model Routing for How Teams Actually Build
Debarshi Raha
· VP & Fellow Engineer, DigitalOcean
Public leaderboards know nothing about your cost ceiling, your latency budget, or your data, so model routing shouldn't follow benchmark rankings — it should encode *your preferences* into a server-side router driven by a purpose-built small model that reranks candidates on live cost and latency; DigitalOcean's open-source Plano plus a 30B routing model does this at under 200ms, with zero client-side code changes, for free.
Keynote
01:58
The Exam Before Enterprise Deployment
Yuan (Emily) Xue
· Head of Enterprise AI, Scale AI
Today's benchmarks measure a *ceiling* — how far models are from the top of human intelligence — and are deliberately kept from saturating; enterprises need the opposite measurement, *deployment readiness*: can this use case ship today, what human-oversight cost buys the 99% reliability it requires, and how does that cost fall as models improve. Reliability is a constraint, not a tradeable variable.
Talk
02:11
From Training to Evaluation: Open Recipes for Building Agentic AI at Scale AI
Chenguang Wang
· Assistant Professor, UC Santa Cruz; Research Advisor, Scale AI
RL used to work only in verifiable domains like math and code; rubric-based rewards turn open-ended grading criteria into verification signals, pushing RL into science and open-ended tasks — and the same idea reshapes evaluation (SWE-Atlas, a drug discovery bench, synthetically generated long-horizon computer-use tasks), with failure modes flowing back into training as a flywheel meant to run forever.
Talk
02:24
Measuring API Agent Reliability for Long-Horizon Tasks in Production
Zelin Wan
· Senior AI Engineer, Postman
On single API tasks every model scores 88–97%, which looks like a solved problem; chain those same tasks into a dependent sequence and scores collapse to 44–73%. The tasks didn't get harder — one small early mistake gets amplified downstream into a broken result, which is exactly the difference between answering and executing.
Talk
02:34
ScarfBench: Can Agents Migrate Enterprise Java?
Rahul Krishna
· Senior Research Scientist, IBM Software Innovation Labs
Enterprise Java behavior largely lives in framework proxies, reflection, and interceptors rather than in the source, so there is no one-to-one equivalence between frameworks. The result: coding agents are very good at producing migrations that compile and deploy, yet only 2–14% actually preserve the source application's behavior — compilation is a deceptive signal.
Talk
02:43
Data Benchmarks: Where Everything's Made Up and the Points Don't Matter
Grace Tang
· AI @ Hex
Great frontier benchmarks share one trait — the problems are genuinely hard for agents *and* for people. Public data-analytics benchmarks are mostly multiple-choice questions, Kaggle exercises, and underspecified pseudo-questions that look nothing like an analyst's day job — so Hex built its own entirely fictional but convincingly messy company, Shorelane, to test against.
Talk
02:49
AIDaR: AI Data Readiness Evaluations Framework
Arindam Sett
· Principal ML Engineer, Genentech
Agents don't perform in a vacuum — they run on top of a data layer. When your agent's eval scores look bad, the cause is often neither the prompt nor the model but a data layer built for dashboards and reporting rather than for agents. So evaluating agents requires evaluating data readiness alongside them.
Talk
02:54
How Better Evals Can Bring Abundance Through Accelerated Scientific Discovery
Scott Clark
· Co-Founder & CEO, Distributional
The best thing about a black-box optimizer is that it will optimize any eval you give it; the worst thing is that it will *blindly* optimize any eval you give it. So the bottleneck on accelerating science was never optimization power — it's evals that know physics, know the research process, and know how to validate a hypothesis.
Talk
03:00
Evals: The Engine for Agent Improvement
Aayush Agrawal
· Product Lead, Uber
Every agent team rationally decides to ship first and think about evals later, and every one of them ends up trapped in a loop of retrofitting evals and forensically reconstructing why the agent broke. Uber's platform team spent a year making evals the default — tracing on from day one, starter-kit evaluators pushed into Slack, CLI experiences that let product teams own the process — and replaced the question "is your eval above 90%?" with "do you actually trust your eval?"
Talk
中文版