Talks

One team's path to trusting AI generated code

Ankit Jain, Aviator

Once AI writes most of the code, a team should stop reviewing diffs and instead capture intent, decisions and evidence, owning the rules that verify the code rather than the code itself.

The True Cost of AI Coding

Scott Tolinski, Syntax

AI coding's compulsive pull and the decisions it demands are wearing developers out, and the remedy is habits and limits, not more tools.

What It Takes to Run a Company on Agent Swarms

Karan Vaidya, Composio

Running agent swarms across a company means giving each one scoped access to every app it needs and a firewall on what goes in and what it does, because attackers already use agents.

The new job of the data team is providing context to AI

George Fraser, Fivetran

The data stack built for business intelligence is now the context layer for AI, so data teams should connect agents to modeled warehouse data rather than wiring them to every source system.

Building a Shared AI Assistant: The Platform Challenges Beyond MCP

Utkarsh Shrivastava, Netflix

Connecting company data to a shared AI assistant is now cheap; the platform's real job is deciding which source answers, who owns that answer, and how hard to gate by stakes, with evals in CI and company context as the lasting investment.

Building World-class Agentic GTM: Learnings from Monaco for Monaco

Mihail Eric, Monaco

A vertical AI company is a shared harness (data, an agent workspace with memory, expert-guided workflows and evaluation) plus domain nuance, and it wins by putting its best domain experts inside the product and tracing everything, because correctness is whatever those experts say it is.

MC Intro

Corey Quinn, The Duckbill Group

What Will You Build When AI Is 10x Faster?

Natalie Serrino, Gimlet Labs

Faster inference is not a luxury: at ten times the speed, agents move from async background work onto the critical path and the bottleneck shifts to tool calls, so builders should design now for a much faster token.

cloudflare is a neolab

Michelle Chen, Cloudflare

Cloudflare became a model lab because small, fast System One models (Clef for decisions, Clairic for extraction) were the missing piece that fit its edge network and agent-cloud primitives, taking routine work off large LLMs.

All Code Is Slop (Except Mine)

Lauren Tan, SpaceXSI (xAI)

Agent-written code can improve in quality at hundreds of PRs a day only if every correction is encoded into the codebase as a deterministic check and review shifts to verification artifacts; automating a sloppy loop just produces more slop.

I deleted 90% of my harness (And It Got Better)

Philipp Schmid, Google DeepMind

Each model generation absorbs tools the last harness had to provide, so rebuild the harness from scratch every release: delete what the model now does itself, often down to one bash tool, and keep only what it can't do through a computer.

Heal Your Agents, Don't Just Grade Them

Khasimul Asif Mohammad, Splunk · Sudhir Tonse, Splunk

Evaluating agents is not enough: like an immune system, an agent platform should continuously detect failures across all sessions, diagnose them against a taxonomy, prescribe a fix, and remember it so the failure does not recur.

How to build agents over your own data

Aamir Shakir, Mixedbread

Agents over company data should search one index prepared ahead of time, with access rules attached, not query every source live through one connector per tool, because the bottleneck is context, not intelligence.

The Software Factory That Needs Zero FDEs

Raz Berman Gold, Overcut

Overcut argues that an enterprise software factory should not need forward-deployed engineers: it plugs into the tools and agents you already run, composes specialized governed agents into SDLC workflows with human gates, and improves itself through scored retrospective memories.

I love you so jevving much

Diogo Almeida, TypeSafe AI

Today's AI is too good to be true at assistance and too bad to be useful at automation because RLHF optimized it to please the human checking it; training for the right task, reliability, makes model calls a fourth logic gate inside ordinary software.

Your Judge Is Hallucinating Too

Brian Kennedy, ZoomInfo

Don't trust an LLM judge until you've measured it: run a second check in shadow mode and look where the two disagree.

Autocomplete for Actions: System One from the UI to the DB

Scott Roberts, Workday

A decision model fast and cheap enough to call everywhere replaces both LLM agent loops and retrieval stacks: it picks the right UI card on every keystroke and runs as a function inside a SQL query on every row.

What it takes to set intelligence free

Fabian Hedin, Lovable

Because Lovable's output is a business, not code, letting an agent work for ten hours needed a runtime that survives deploys, computers that start and fork in milliseconds, and two verification loops, the outer one fed by business metrics Lovable owns.

How to build an agent that builds the culture

Zach Bruggeman, Ramp

A single shared coding agent with every session public by default changes engineering culture: good practice spreads without training, and the session becomes the evidence that lets reviewers trust a change.

Software Factories: Escape from Trash Mountain

Steve Yegge, Independent

A year of software factories shows fuel is the hard limit and currently subsidized, agents behave like staff who need managing and pruning, and the more agents you run the more humans you need, so spend the fuel on experiences.

2026 in LLMs

Simon Willison, Independent

This year models crossed from reliable coding agents to 'Fable class', solving any well-defined goal by brute force when given the tools, even making a game fun; the work doesn't get easier, the easy part goes, so the answer is more ambition.

A New Age of Software Engineering

Walden Yan, Cognition

Cognition grew merged PRs 40x on 2.7x headcount by rebuilding how it works around agents: small pods that own everything, agents that test themselves in local VMs and prove fixes with videos, and long-running jobs instead of tasks, so a team's real limit is its ambition.

Talk But Verify: human-in-the-loop for agents that actually matter

Michael Liendo, Auth0

How much human-in-the-loop an agent needs depends on the stakes, so give agents scoped, short-lived, revocable credentials, step up permissions when they need more, require out-of-band approval (CIBA) for high-stakes actions, and never hand them your card.

Let the Agent Cook: From APIs to Answers

Arsalan Bashir, Sentry

To build agents that investigate data on their own, consolidate tools by use case and push deterministic complexity into them, stop pre-chewing context the model can now handle itself, and always give the agent a cheap way to check its own work.

Exploring Claude’s frontier

Lance Martin, Anthropic

Claude's frontier is self-organisation: a thousand Fable 5.2 agents given only git and a SQL database built their own coordination to formalise Fermat's Last Theorem, and stronger models write, read and, through dreaming, consolidate memory into better representations.

Jarred Sumner, Founder of Bun, Anthropic / Bun

Jarred Sumner, Anthropic

Building an ahead-of-time compiler for Bun to cut Claude Code's memory usage and startup latency required five rewrites over a month, succeeding because pre-existing JavaScript/WebKit test suites, differential JIT-versus-AOT execution, and long-lived subagents made large-scale agent-written code verifiable—provided the human continuously nudges models with leading questions so they do not settle for timid improvements.

The first Grounded Decision Model

Devin Gupta, Parallel

Grounding decision models with live web search from a large proprietary index solves uncalibrated overconfidence in ungrounded LLMs, delivering higher accuracy, verifiable citations, sub-second latency, and one-dollar-per-thousand-request pricing.

Judgement is the Last Job

Ishaan Dey, Google DeepMind

As AI models scale in intelligence and make building software nearly instantaneous, teams must rebuild past workflow assumptions, give users extensible platforms for ambition, and protect human judgment as the decisive differentiator.

Brownfield Factories

Justin McCarthy, Diffusion

Software factories fail when applied to open-ended greenfield discovery, but excel on brownfield systems where existing customers and runtime signals already define the promises to maintain continuously in the background. Once a brownfield factory simplifies over time and runs autonomously, teams must build a companion demand factory to expand within their brand envelope rather than spilling excess software.

Post-Training Gemini 4 for Real Engineering Work

Melvin Johnson, Google DeepMind

Post-training Gemini 4 (Carbon and Hydrogen) for multi-day software engineering requires continuously sourcing non-saturated hard tasks, replacing binary test checks with rubric-based and sandbox-hardened grading that penalizes cheating, grounding completion claims in trajectory actions to reduce fabrication, and feeding failures from internal dogfooding at Google into rapid weekly training iterations.

A Company Built Around the Agent

Quinn Slack, Amp

Agents render traditional software org charts, enterprise sales checklists, and third-party SaaS tools obsolete by enabling tiny, high-equity teams to ship continuously, run closed-loop customer bug fixes, and build custom internal software from scratch.

12-Factor-Factories: Design Patterns for Agentic Coding

Dexter Horthy, HumanLayer

Effective agentic software factories are built on timeless engineering practices—balancing automated forward pressure and rigorous back pressure, planning according to expected pain, and preserving human judgment—rather than unreviewed output. Because generation cost is approaching zero while review cost stays constant, teams must actively fight compounding AI slop and retain ownership over system understanding and verification.

Thariq Shihipar, Independent

Thariq Shihipar, Independent

Rather than acting as an alien intelligence that forces developers into a single narrow interface like Bash or React, improving models form a broad 'smooth interior' of capabilities that enables a software Renaissance—provided builders pair agentic engines with human-readable specs to stay in creative control.

Something to Celebrate

swyx, AI Engineer

Closing the conference, the organizer celebrates major community reach—nearly 100,000 livestream viewers and one million YouTube subscribers—while recognizing key behind-the-scenes team members and outlining steady flagship growth plus international partnerships.