Full program

As agents take on longer and more complex tasks, sustaining performance becomes a central engineering challenge. Drawing on Step 5 Preview, StepFun’s latest flagship foundation model, and Step Code, its open-source agent harness, this talk explores how models and harnesses work together to help agents stay on track and deliver reliable results in real-world applications.

Early 2026 we built the Dark Factory to ship OpenClaw the larget open source agent platform in China and the world, parallel agents running overnight, thousands of commits, pure throughput. It scaled until the output stopped matching what we actually wanted. The bottleneck was intent. Agents produced volume without a durable reason to do any of it. I walk though the city of systems "Lobsterville" we are building at OpenClaw to build OpenClaw. From meat proxies to multiplayer steering and the fundamentals of intent handoff and intent engineering to build the future of AI with agents in a collaborative way.

How can useful AI run directly on phones, PCs and other personal devices rather than depending on the cloud? This talk explores memory bottlenecks in on-device models, using early expert routing and flash streaming to reduce the resident memory footprint. It also covers combining millisecond-scale local decisions with larger on-device models, with examples from headphones, robots and smart glasses.

Teams are reaching for Kubernetes to run agent sandboxes, and it's the wrong tool. Kubernetes is built to keep things alive and hold them in a steady state. A sandbox is born, forked, and killed before any of that machinery catches up. The mismatch compounds because the sandbox keeps gaining requirements without shedding any. In eighteen months it went from a fast code-snippet runner, to a stateful box for long-running agents, to ten thousand ephemeral environments that fork for RL rollouts and die in under a second. It has to be all of those at once, a contradiction set no orchestrator was designed to hold. The cost shows up the moment you measure it. We ran the same 50-action bug-fix trajectory across five stacks and got a 12x spread: 12.9s on the fastest, 161.5s on the slowest. The gap isn't compute, it's lifecycle overhead per action. We name every stack and explain the mechanism behind each number.

Most teams add AI tools to an old workflow. At Manus, we rebuilt our workflow around agents. We keep all our repositories, team rules, and agent skills in one shared workspace, called Manus mono. Mono connects to almost every service in the company, so an agent can write code, run tests, check logs, work with databases, and ship to production from one place. Because of this, anyone in the company can open a PR. Engineers, product managers, designers, and operations staff all fix the bugs they find. On top of this, every task in our team is visible to everyone. This decouples a task from the person who started it. When a task needs information, you send the link to the person who knows, and the task continues after they answer. When a colleague is away, someone else can take over. Open tasks also give us data on how people actually work with AI. In this talk, I share how we built this way of working, what went wrong, and how it changed the way our team collaborates.

Power open-source personal agents with Exa’s live web search, Places, weather, and research through a single API.

An agent that runs twenty steps doesn't issue one retrieval — it issues dozens, and it writes about as much as it reads. The trace it leaves behind is write-heavy, time-ordered, and queried at three granularities: step, span, trajectory. That's the same shape as an RL rollout store. Not similar to — the same. The model labs hit this two years earlier under different names: semantic dedup, decontamination, hard-negative mining. Agent memory and training data are converging on one set of operators — operational writes and analytical scans over the same data, with no ETL in between. That convergence is why we took Milvus from a vector database to a Vector Lakebase. This talk walks through the workloads that forced the shift, and what the architecture looks like underneath.

The LLM gateway has become a critical piece of infrastructure at Optiver. Engineers, researchers and agents rely on it daily for a variety of tasks, from analysing large volumes of market news and research to running automated workflows. When the gateway goes down, the impact is expensive and quickly noticed. Keeping LLM traffic running reliably across multiple regions and providers has been challenging, with many of the failures outside our control. In this talk, we share our experience building and scaling a multi-region LLM gateway. We walk through the key design decisions behind protocol translation, scaling, provider failover, observability and multi-region high availability, as well as the tradeoffs and footguns we encountered along the way.

AI builders keep asking for capabilities that stretch a database beyond its original boundaries: one database per agent, memory across sessions and state that survives disposable sandboxes. This talk follows the production needs that drove those changes, and the resulting choices around isolation, consistency, recovery and observability.

Every NVIDIA GPU generation since Hopper ships TMA, a dedicated engine that copies whole tiles into shared memory while the cores keep computing. Turn it on for every `torch.compile` kernel and SiLU on GB200 gets 1.8x slower. This talk builds the mental model that explains why: when a kernel is memory-bound, what an async copy needs in order to pay off, and the hardware rules that quietly change your tiling. Then it shows how Inductor can stop guessing and instead race TMA and non-TMA versions of each kernel on first launch, the way it already does for GEMMs, without making compile time worse. You leave knowing which of your kernels TMA can speed up, which it can't, and how to tell from a profile in a minute.

RL post-training for coding and agentic models turns every rollout into a sandbox: a fresh environment with a task image, a few commands, a reward, and teardown. A single training run can need Millions of these per hour across thousands of distinct images, with starts arriving in bursts of hundreds and lifetimes measured in seconds. This talk highlights what we learned running 1M sandboxes using an open-source harness on top of Kubernetes called Substrate, and all the various technological innovations in the stack - warm pooling, image acceleration, low latency scalable storage,microVMs, gVisor, golden snapshot and more. We cover the complete stack orchestration layers that make this work in state of the art Al labs including benchmarks and latency assessment.

AI is systematically absorbing the technical core of game development. Code generation tools now produce gameplay scripts, shaders, and engine plugins from natural-language prompts, while AI pair-programmers handle debugging, refactoring, and unit tests autonomously. Procedural content pipelines driven by generative models build entire levels, NPC behaviors, and quest logic without manual scripting. Automated QA bots playtest builds around the clock, flagging bugs faster than human testers. Even optimization — memory profiling, performance tuning, cross-platform porting — is increasingly delegated to AI agents. The developer's role shifts from writing code to reviewing, orchestrating, and validating machine output. This paper examines which engineering tasks AI has already displaced and what expertise remains irreplaceably human.

Yubo shares how to use YouMind to build a Personal Agent for personal growth.

Every team picking a model right now is reading someone else's leaderboard. We stopped, and the reason was an accident of how we shipped. Harvey released its cloud agent platform to our own engineers before we shipped long-horizon agents to lawyers. Internally it has now driven 7,000+ merged pull requests across our repositories. That internal deployment was not just a safety net — it became the eval set. Once you have thousands of real agent runs on your own workload, you can measure a model against the work you actually do, instead of trusting a public benchmark that was never scored on your tasks. That measurement is what makes it rational to move to an open model, or to fine-tune one, rather than simply hoping it holds up. This talk covers the infrastructure that made that possible, and the four places it broke first: - Durable runs: what happens to a long-horizon agent when the worker dies mid-task, and what we built so the run survives it. - Per-user agent identity: we started on a shared service account and lost the ability to attribute what an agent did. Retrofitting identity was expensive. - Information boundaries: enforcing ethical walls and leaving a reviewable approval trail when an agent acts on a user's behalf. - Context engineering: the case where adding context back made agents measurably worse — a result no external benchmark would ever have surfaced for us. I will show the failures next to the wins, with real numbers and the denominators included, and demo the platform live. Every pattern here is architecture and engineering method, not a product walkthrough.

Getting your first AI application into production is hard; you hear that at every AI conference. But what happens when you're managing your 50th, 100th, or 500th agent? At enterprise scale, the challenges fundamentally change. It's no longer just about building agents that work. It's about managing hundreds of agents across teams, business processes, and systems while maintaining reliability, governance, visibility, and control. Who owns each agent? How do you monitor quality and performance? How do you prevent duplicated efforts, manage shared knowledge, and ensure that an expanding AI workforce remains trustworthy? Drawing on real-world enterprise deployments on Dify's AI Agent Management Platform, Andy Wang will explore what happens after AI agents successfully reach production. Topics such as the architectural decisions, operational challenges, and organizational lessons that rarely come up in conversations about pilots, but become impossible to ignore once you approach scale. The next frontier of enterprise AI isn't about how fast you build your first agent. It's about how effectively you manage your next 500.

AI agents are moving beyond reasoning and generation toward taking real-world actions on behalf of users. This shift requires a new infrastructure layer for identity, authorization, trust, credentials, and execution. Drawing on Visa’s work on Visa Intelligent Commerce (VIC), this session explores how these primitives are being designed for autonomous agents — how an agent proves who it is, demonstrates user intent, accesses credentials securely, and interacts with external systems safely. We’ll discuss the emerging infrastructure stack needed to move agents from assistants to trusted actors in the real world.

As one of the founding Android engineers on Instagram Edits, this talk shares my first-hand lessons from making Instagram Edits on Android agentic. Agentic coding has dramatically accelerated development output, but human verification cannot scale at the same rate. We built agentic verification to close that gap. Today, our agents run 2,000+ verification workflows per week across agentic QA, developer feedback loops, stress testing, and debugging. I’ll share how we made a complex mobile app discoverable, controllable, and verifiable by agents, and how that enables a broader agentic mobile development loop that improves both developer velocity and product quality.

An LLM is a non-deterministic token machine. A production UI has to be reliable, consistent, and fast every time. Generative UI lives in the gap between those two facts, and that gap is usually treated as a frontend problem when it is really an infrastructure problem. This talk is the engineering story of closing that gap. We started where most teams start: ask the model for JSON, validate it against a schema, and render the tree. It demos well, but breaks down in production. Deeply nested JSON streams slowly, malformed structures appear under load, half-finished objects cannot render, and the output drifts from the design system. I’ll show the reliability layer we built in OpenUI to fix this: a compact, line-oriented language that models emit more reliably than nested JSON; streaming with forward-reference hoisting so each line can render as it arrives; and validation that drops invalid fragments instead of crashing the interface. The result is near-zero malformed output, up to 3x faster rendering, and 67% fewer tokens than JSON in public, re-runnable benchmarks. I’ll also cover the tradeoffs, including where schema-validated JSON and native protocols still make sense.

Turn thousands of your company’s merge requests into benchmarks to improve your coding agent harness.

Most enterprise AI agent failures don't look like model failures. The model is fine. It just doesn't know which of four revenue tables finance actually uses, who owns it, whether last night's pipeline ran, or that one column was deprecated in March. That knowledge exists inside the organization - scattered across technical schemas, pipeline telemetry, business definitions, and org charts - and almost none of it reaches the agent. This talk is about assembling those four kinds of metadata into a single, model-agnostic context layer that agents can query, and what it actually takes to do that inside a large enterprise. I'll cover the architecture briefly, then spend most of the time on the parts that are harder than the architecture: deciding what context is trustworthy enough to serve, keeping it fresh, exposing it to agents over MCP, and the organizational work of getting teams to maintain context they never see themselves using.

Over the past year we modernized ATLAS end to end, backend and frontend alike: the cohort design workbench the OHDSI medical research network has run for over a decade. The Java backend moved from Java 8 to Java 21 and Spring Boot 3: some 1,600 files, with a net 65,000 lines removed. The frontend is a ground-up rewrite in Vue 3 and TypeScript: 110k lines of source, gated on every pull request by coverage-enforced unit suites and an end-to-end fidelity check against the entire OHDSI Phenotype Library, running publicly at atlas-preview.ohdsi.org/atlas. The large majority of that code was written by coding agents, far more change than anyone could have read line by line. The platform and the verification harness are open source under the OHDSI GitHub org, end to end. On the frontend rewrite I directed, reviewed, and accepted every change. When acceptance cannot mean reading every line, verification has to live somewhere else. The harness became the first reviewer, and I will show what it is made of: specs as the unit of delegation, the legacy implementation as a behavioral oracle, E2E suites and type gates as the merge criterion, and screenshot-driven iteration in place of pixel opinions. I will walk one real feature end to end and show the failure modes the harness caught, the ones it did not, and what I would gate differently today. This talk is for engineers and leads who need to deliver more than their team can hand-write. You will leave knowing how to structure specs so agents can execute them, which verification gates can replace line review and which cannot, and how to tell whether your project fits this model (rewrites with a reference implementation) or does not. Live instance: atlas-preview.ohdsi.org/atlas. All code: github.com/OHDSI/Atlas3.

* Semantic Layer as Infrastructure for Data Agents * Apache Ossie: Starting from Metric Interchange * From Specification to Implementation * What Makes a Semantic Layer AI-Native? * Ontology on Top of Semantic Models * Datus + Dosi: Building Semantic Layers and Ontologies from Enterprise Context * An Open Semantic Layer for the Agentic Data Stack

Your website is your worst salesperson—static, unresponsive, and abandoning 78% of potential customers. For 25 years we’ve called it “optimization,” yet all we do is swap Button A for Button B or craft a few account‑level pages, praying for a 2 % bump. Each tweak burns weeks of design and dev time while visitors bail in seconds, conversions stall, and acquisition costs keep rising. Modern traffic is rushing through a testing process built for dial‑up days, and the leak grows every day. Your website could function as your top sales performer—qualifying leads, demonstrating value, getting marketing insights, and closing deals 24/7 without any human intervention. You’ll learn why webpages are bleeding visitors, what turns a site into Web 4.0 Agent—adaptive video, live voice, and on‑screen digital humans working in sync and showing your product. How to bolt those layers on with simple APIs instead of a rebuild, the design moves that hook eight‑second attention spans, the conversion lifts early adopters are already logging, and a clear six‑step pilot plan to bring one high‑value page into this future and then scale it across your entire site.

The Little Prince: Across the Stars is a 3D story game built by one person with AI. This talk follows the project from adapting a familiar story into explorable scenes, through iterating on code, 3D assets and visual polish, to its public launch. Sac shares what worked, what did not, and what the process means for people creating with AI.