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.

Enterprises buy LLM inference through three structurally different pricing models: credit-based subscriptions, pay-per-token APIs, and self-hosted GPU capacity, with little guidance on which to use at a given volume or what signals it's time to switch. This talk introduces the Efficiency Curve: cost per token under the cheapest procurement mode at each volume, and its crossover points. Using a July-2026 pricing snapshot across three model quality tiers, I show a counter-intuitive finding: the subscription-to-API crossover often never economically materializes; a credit plan's idealized per-token rate can undercut every API price at scale, so the real boundary is a terms-of-service seat limit, not economics. The self-hosting crossover, by contrast, is a genuine price crossover, landing between roughly 360-899M tokens/month depending on tier, and it shifts with output-token share. I walk through the derivation and share a monitoring framework that ties each metric to the procurement decision it should inform, drawn from running AI infrastructure inside a regulated bank.

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 10k+ 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.

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

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.

Through a demo of AhaCreator’s brand and creator interfaces, Susan shows how AI advances collaborations from brief to content delivery. Examples include a customer exceeding US$500,000 in collaboration spend in a single month and selected trend-driven campaigns moving from idea to publication in three to five days. The session explores how responsibilities are divided between AI and people, and how actual prices, response times, and delivery records inform future creator selection and partnerships.