Talks
725 talks in 2026
AI Engineer NYC 2026
How to Actually Tokenmaxx and Save Millions
I Spent Two Years Building the Median
Paving the Road to Production: Governed Enterprise AI Agents
Rebuilding CI for AI-Scale Commit Volume
The Cost of Accessibility in AI
Your AI Isn't the Problem. Your Infrastructure Is.
Deploying AI Inside a Bank Is Not an Engineering Problem
Every Building Is a Balance Sheet: Spatial Memory for Real-World Assets
I Believe Everything My Agents Tell Me: Three Levels of Review
Judge a Transaction by the Company It Keeps
The Agent Works. Does Anyone Trust It?
Tokens Are the Cheap Part
What Technical Due Diligence Finds When the Deck Says "70% Automated"
Agents in Orbit: Workflows, Not Autopilot
Build a Research Agent with Claude Managed Agents (Part 2 of 4)
Building AIE: Open Q&A and Feedback Session
Claude Managed Agents Q&A: Evals, CI/CD and Multi-Tenancy (Part 4 of 4)
Just-in-Time Ontologies: What Cheap Intelligence Means for Data
Please... Enough with the Sloppy, One-Shot SaaS Replacements
Scheduled Agents, Dreaming and Q&A: Claude Managed Agents (Part 3 of 4)
The Next Trillion Internet Users Still Don't Have an Identity
We Let Our Financial Planners Write the Agents
Your Agent Is a Lethal Trifecta (And What to Do About It)
An AI Future Without the Lock-In
Beyond RAG: Build a Relational Context Engine from Scratch
Building AI Agents with Real-Time Web Data
Latency Is a Budget. Humanlike Is the Goal.
Parsing the Epstein Files for JMail
RAG Needs a Map: Using GraphRAG to Retrieve Connected Context
Turning My Obsidian Vault Into a Local AI Engineer
AI Agents Don't Read Your Policy Docs. They Hit Your APIs
Beyond RAG: A Relational Context Engine That Cuts Token Burn
From 15% to 90% GPU Utilization: Fix the Data Pipeline, Not the Model
From Your Laptop to the Pipeline: Scaling Custom Agents with GitHub Copilot
How MiniMax M3 Was Built: Sparse Attention and Native Multimodality
Small Models, Big Results: Training a Finance Agent for Under $500
The Lethal Trifecta Is Already on Your Laptops
Zero Cold Starts: Serverless AI Agents on Akamai Functions
AI Writes More PRs. Who Validates Them?
Building on the Codex Harness
Designing CLIs for Agents, Not Humans
From Context to Memory: Your Agents Need a Real Memory Layer
Generation Is Cheap, Review Is Expensive: How to Stop Shipping AI Slop
Stop Prompting
Why 80% Reliability Isn't Good Enough
Why Your Company Needs a Context Graph (and How to Build It)
Brains vs Hands: How to Run AI Agents Safely in Production
Giving AI Agents Memory That Learns
How a Remote Company Builds AI Fluency
Let Anyone at Your Company Ship Internal Apps with AI
Turning Agent Memory Into Skills That Work
We Mapped 115 Microservices for Our Coding Agents
Why Bigger Context Windows Won't Save Your Agent
Why We Deleted Our MCP Server and Rebuilt It
Your AI Agent Has No Nervous System
AI Hackers Are Faster Than Your Pen Test
Every AI Company Is Accidentally Building a Bank
From 36% to 100%: How Self-Improving Agents Write Their Own Skills
Grep or Embeddings? Agentic Search Over Company Documents
Redesigning How Software Gets Built With AI Agents
The Software Factory: From Bug Report to Production Code
Why AI Agents Should Have Their Own Sandbox
Why Your AI Agents Can't Talk to Each Other (Yet)
Advanced Workshop: Mastering AI Observability
Cooking with Codex
Harness Engineering: How to Build a Software Factory
How AI Agents Pay: Checkout in ChatGPT and Google AI Mode
How Many Credentials Should Your AI Agent Have? Zero.
Is Speculative Decoding Worth It? Profiling vLLM on NVIDIA Blackwell
Move Fast and Don't Break Things: Scaling Databases for the AI Era
The 6 Pillars of an Agentic Harness for Production
The Self-Improving OSS Agent Stack
What Is an Inference Engine, Anyway?
Why Building an Eval Platform Is Harder Than It Looks
Build the Right Thing: Product Engineering (Part 1)
Build the Right Thing: Product Engineering (Part 2)
Evals in AI: A Deep Dive
From Raw Documents to AI-Ready Data
From Vibes to Production: Evaluating and Shipping AI Agents That Work 201
From Vibes to Production: Evaluating and Shipping AI Agents That Work 101
How I Learned to Stop Worrying and Love the Sandbox
Research to Reality with Google DeepMind
The Transcript Looked Fine. The Call Wasn't.
Your LLM Judge Is a Confident Liar: Building Better Verifiers
Agents That Write Their Own Tools at Runtime
AI Coding Agents Are Breaking Big Codebases
Dashboards Are Dead
Keyword Search Is Dying. Is Your Catalog Ready for AI Agents?
Stop Fine-Tuning to Fix Retrieval Problems
The Human Is an Async API
We Built an AI Support Agent That Resolves 80% of Tickets
An Interaction Is All You Need
GPU Died. Training Didn't: Self-Healing Training at Scale
How VS Code Went from Monthly to Weekly Releases with AI
I Built a Personal AI Agent on a Raspberry Pi
What Makes Open Models Fast in Production
YOLO Mode, Safely: MicroVM Sandboxes for Any Agent
Your LLM App Returned 200 OK. It Was Still Wrong.
Lessons from Generating 12 Trillion Synthetic Tokens
Stop Rationing Tokens: Let the Harness Pick the Model
Stop Renting Your AI's Memory
The 5 Levels of Self-Driving Production
Why 99% Accurate Browser Agents Still Fail
Why AI Didn't Actually Make You Ship Faster
Your Coding Agent Is 6 Months Out of Date
The Chief AI Officer: Scientist, Architect, Coach
The Death of the Code Review: What the Data Actually Says
The State of AI in Software Development: Data from 400+ Orgs
Your Agents Are in Solitary Confinement: Why MCP & A2A Aren't Enough
AI-Generated Code Is Already Competing With Human Code
Get Out of the Model's Way
GLM-5.2: Open Weights, Near-Frontier Intelligence
How Software Factories Improve Themselves
I Turned Coding Agents Into a Strategy Game
No, That's Not a Software Factory
Orchestras, Not Factories: How the Fastest Builders Work
Scale the Judgment, Not the Model
Software Engineering Is Becoming Factory Engineering
What It Actually Takes to Build a Software Factory
Autoresearch Made Our Models 3x Faster
Beating RL With Reflection: GEPA and Optimize Anything
How We Built an Agent That Improves Itself
Long-Horizon Agents Need Experiments, Not Just Prompts
We Let Claude Code and Codex Race Human Researchers
Distill the LLM, Don't Serve It: Search & Personalization at DoorDash
Teaching LLMs to Speak Spotify
Why LLM Recommenders Will Be AI's Biggest Consumer App
I Gave an AI a Body
One Operator, Many Drones: Inside Skydio's Autonomy Stack
Opening Keynotes: Mistral, Langfuse & Sizzy
Physical AI's Next Bottleneck Is Finding the Right Video
From VLM/VLAs to Embodied Agents
You're Not Thinking Big Enough: Rebuilding Food Systems with AI Agents
The Dark Arts of Skill Engineering
Are LLM Performance Benchmarks Reliable?
Large clusters for small models
Operating Distributed Inference Systems at Scale
Routing LLM Inference in Production: From Engine Signals to Policy
The Frontier AI Inference Cloud for Agents
Two Bugs That Hid in Plain Sight: A vLLM Debugging Detective Story
Vertical Mobility: Inference from MVP to Trillion-Parameter Workloads
Weight Folding, CUDA Streams, and the Bug That Made My Model Speak Backwards
What's New in Inference Engineering
Total Recall: Agent Memory and Harness Engineering
Homa: The End of TCP for AI Clusters
Connect AI to Billions of Legal Documents
If We Want Them to Do Knowledge Work, Design Them as Knowledge Agents
Pinecone 2.0
Rebuilding the Web for Agents
Stop Chunking Like It's 2022
The Search Engine for the Agentic Web
The Unreasonable Effectiveness of BM25 for Agentic Search
Where RL Will Take Search
Your Agreements Are a Database You Can't Query
5 Voice Agent Failure Modes You'll Hit in Week One
A Linguistic Map for Voice Agents
Act, Confirm, or Stop? Smarter Behavior for AI Assistants, Wearables and Robots
I Monitored Crime Audio. Voice Agents Scare Me More.
Realtime Voice Agents with Frontier Intelligence
Speech-to-Speech Model Research at Google DeepMind
Tolan: Voice-First AI Companion
Voice Agents Can Just Do Things
Your Voice Agent is Just a Walkie Talkie
Agents Without Code: Skills, YAML, and Filesystems Replaced Python
Every step you take, every call you make: the reliable agent stack
Harness Engineering: Building the Production Cage for Powerful Domain Agents
How We Solved Agent Building
Loophole: Adversarial Agents To Stress Test Your Morality
No Memory, No Harness: Why the Database Is the Last Line of Defense
Tokens Should Have Jobs
We let an AI agent execute Bash and lived to talk about it
Design at the Speed of Adjectives
Generative UI... in Python?
Mousepower: agents that can't be measured, can't be managed
One Designer + AI. Hundreds of Deliverables.
The Design-Code Roundtrip That Isn't
The Spatial Harness: Bringing Agents to the Canvas
Training Taste
500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents
ACP: The Universal Remote Control for AI Agents
Build-Time vs. Run-Time: Why Dev Tools Fail in Production
How long can your skills be before your agent forgets what you told it?
It's Tokens All The Way Down: How RLMs are Different
MCP Apps: Give the Model Data, Give the User a UI
Your Agents Lack Context: Here's How to Fix "You're Absolutely Right!"
Deep dive on LLM Inference at Scale
Why AI Agents Need Million-Token Context
Agents' Next Frontier: Agent-to-Agent and Network Effects
Everyone Gets A Software Company
From Coding to Knowledge Work Agents
Tethered: Our Agents Are Us
Your Company Brain Will Leak Secrets: How We Stopped It for Big Banks
Agent Spending Without Controls
Beyond the Lethal Trifecta: Agentic Commerce on the Open Internet
Multimodal Collaborative Agents for Next-Gen Commerce
Teaching agents to pay
The End of the Static Screen: Architecting Intent-Driven UX
When AI Agents Pay and Sellers Monetize: Building x402 Apps on AWS
Why Your AI Agent Needs a Wallet: USDC and Nanopayments
x402 Isn't Good (Yet)
Your Agent Just Authorized What?!
SOTA Generative Media Panel
Agentic Sites: Building Hyper Personalized Websites
Agents Are Where Microservices Were in 2015
AI Agents Are Just Distributed Systems Now
From Tokenmaxxing to Trusted Throughput
Tell the Robot What You Want
The Half Life of Agent Infrastructure
The Signal Layer: What to Build When Anything Can Be Built
Tribal Dungeons of Global Shipping: AI Agents at Global Scale
Which AI startups actually land enterprise contracts?
AI Evals for Cross-Functional Teams
AI-Native Organisations Run on Skills: How to Structure and Scale Them
Building the Engine While Flying the Plane: Launching the Figma MCP Server
Building uReview, Uber's Multi-Agent Code Review Engine
From AI-Assisted to AI-Native: Building a Frontier Development Team
How do you diffuse AI into the real world?
How to Avoid Disaster When Vibe-Coding a Billing Engine
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage)
Productionizing LLM Gateways: Architecture, Tradeoffs and Hard Lessons
Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers
Can LLMs Write Fast Multi-GPU Kernels?
How Anthropic Builds: Lessons from Labs
How to Generate Mergeable Code with a Context Engine
KV Cache-Aware Routing and P/D Disaggregation on Kubernetes
The Agentic Commerce Stack
AI in GTM at Notion
Building GTM AI Agents: Lessons from Deploying to 6,000 Users
GTM Engineering: The Technical Bits
How AI Agents Let GTM Teams Scale
How We Got LLMs to Recommend Our Open Source Library
Knowledge Systems: The New GTM Stack
Reverse-Engineering the AI Buyer
The Building Blocks of GTM Orchestration
The Death of Developer Advocates
The Missing Layer in Agentic AI
Einstein Arena: Harnessing Collective Agent Intelligence for Open Science
Agent Frameworks Considered Harmful
FinOps for AI Agents: Who Spent All the Tokens?
Give the Agent a Budget, Not a Token
Preferences Over Benchmarks: Model Routing
The Agent Behind the Curtain: Building the Oz Cloud Agent Platform
What If Your Chip Design Team Moved Like a Single Body?
Agentic SDLC at Uber
Building Agents Is Trivial Now, Context Is the Next Frontier
The Missing Layer: Design Taste in AI Agents
How I automate my own job at Hugging Face using agents
IT Admin for the AI Workforce
Prototyping as Leadership: How a CTO Ships with AI Agents
The Era of Compound Engineering
The Last Human Code Review: Building Trust in AI-Generated Code
Unlock Agent Autonomy: The Runtime for AI-Native Systems
Your Agent Evolved. Your Evals Didn't.
Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards
200 Million Patient Interactions Later
AI is the World's Largest Relationship Therapist
Don't Be Data Poor
From Ambient Documentation to Clinical Intelligence
Guardrails First: Engineering Member-Facing Health AI
Healthcare's Agent Bytecode: X12 as the Harness for AI Agents
How to build an AI-Native Health Company
Shipping AI to a Million Patients Without an A/B Test
Trading Desks to Clinical Trials: Parallels in Applied Vertical AI
Why Your Enterprise Tech Stack Isn't Ready for AI Agents
Building an Agentic Video Editor for Mass Consumer
Generative Video at the Speed of Light
Infra behind Krea 2: How to train and serve at scale
The Next Game Engine Won't Have a Manual
The Next Medium: Why Real-Time Interactive Video Changes Everything
Training Krea 2: What Matters in Generative Model Training
Voice agents with Realtime Video
While My Guitar Gently Speaks
Context Engineering in 2026
How to Kill the Code Review
Security Firewall for Agents
Bringing agents onto the World Wide Web
Computer Use at the Edge of the Statistical Precipice
Computer-use models will agentify the web, not APIs
From RL to IRL
How Web Data Infrastructure Powers the Next Generation of AI
The Dark Arts of Web Automation: Teaching Agents to Use Websites Like Humans
The Rise of CaaS: Context-as-a-Service for Agentic AI
Beyond Static Intelligence: Evaluating Continual Learning
Bringing Continual Learning into Enterprises
Designing Agents (The Floor Is the Frontier)
Gradient-Free Continual Learning
Improving Agents is a Data Mining Problem
Intelligence + Continual Learning = Expertise
Lessons from Studying Every Memory System
LLM Knowledge Bases: A Practical Guide
Memory Harnesses for Long-Running Research Agents
Scaling Compute on Context
Scaling up Continual Learning
Agents, codebases, and teams
The Evolution of Agentic Surfaces
Codex, Behind the Harness
Taking Reinforcement Learning Cross Datacenter
Always-on agents run production without the on-call tax
Guide, Verify, Solve
Multiplayer agentic engineering
Velocity Sickness: What Happens When Your Whole Team Gets 10x Faster
Anthropic's CCA Exam as a Field-Guide for Agentic Engineering
Benchmarking Coding Agents on New vs Legacy Codebases
Realtime multiplayer, automation, and you!
Compression at the Edge
Local Models: Trust, Control, Optimization
Open Source Is Dead. Long Live Open Source.
The New Primitives: Building AI Native Software
The State of Model Routing
Gadgets: Personal app vibe coding that is actually safe
Building Turbopuffer
MCP Apps: Extending the Frontier
MCP Tasks (async): Why Aren't Any Agents Supporting Them?
When Will the Benchmaxxing Plague End?
Rethinking Environments for Long-Horizon Work
Teaching AI to Find Real Vulnerabilities
Agents at Scale: Inside MiniMax's Model and the Infrastructure Behind It
Benchmarks: The Good, the Bad, and the Ugly
Data and Environment Curation for Post-Training LLMs
Data Quality Is the Compute Multiplier
Ending AI Slop
Fighting Slop with Slop
Learning on the Job: The Future of Post-Training
Reinforcement Learning without Verifiable Rewards
Scaling to Long Horizons
The Base Model Is Dead
The Data for Fully Autonomous Software Engineers and Companies
Verifiable Environments for AI in Biology
What's Next After RLHF?
Build for the Memo, Not the Demo
First Steps Toward Automated AI Research
Let's integrate AI Agents in Event-Sourced Systems
Your Finance Agent's Bottleneck Is You
How Kepler Built Verifiable AI for Financial Services
Morgan Stanley's ALPHALAB: Multi-Agent Research Across Optimization Domains
Persona Engineering: A Field Guide to AI Synthetic Personas
SimulationMaxxing: How We Ship Agents 20× Faster
Skills are New Features: Building a Skill-Centric Harness
We Vetted 2,000 AI Skills Before They Reached Developers
Wearing the Agent: From Group Chats to Glasses
Why Off-the-Shelf AI Doesn't Understand Money
Your Agent Didn't Fail. Your Harness Did.
AI Agents for Performance: Ship Faster, Pay Less
AI tools for Forward Deployed Engineering
Forward Deployed Engineering 101
How Forward Deployed Engineering is Done at Cognition
How Forward Deployed Engineering Is Done at Decagon
How Forward Deployed Engineering is done at Factory
How Forward Deployed Engineering is done at Kepler
How Forward Deployed Engineering is done at Ramp
Serving 2 Million Models Without Melting: Scaling the Hugging Face Hub
The Dirty Secret of Forward Deployed Engineering
DeepSWE: A Contamination-Resistant Coding Benchmark
State of Data
The Messy Reality of Scale: Synthetic Data and Pre-Training
Evaling Video Slop
Evals-Driven Development for a Mental Health AI Coach
From Agent Traces to Agent Simulations
Loop Engineering from First Principles
Why Large? Tiny LMs and Agents on Edge and Robotics
Building Closed-Loop Evals for a Multimodal Agent at Scale
Everything Is a Rollout
From Signal to PR: Anatomy of a Self-Improving Agent
How Evals and Prompts Shape Agent Behavior
Setting Yourself Up for Success
The Future of Evals: From LLM as a Judge to Agent as a Judge
Training Frontier Models to Out-Think Hackers
Vending-Bench: Long-Horizon Agent Evals
AI on Your Lakehouse: Context Comes in Shapes, Not Queries
Citation Needed: Provenance for LLM-Built Knowledge Graphs
Harness Engineering is Not Enough: Why Software Factories Fail
Learned Execution Graphs for Anomaly Detection & Drift in APIs
Local Agentic Theory For Mobile Games
Notion's Token Town
Perception Agents
The Unreasonable Effectiveness of Separating the Task from the Model
Video Has No Memory. Here's How We Built One.
Why Agentic Systems Need Ontologies
Why We Killed Our Multi-Agent Pipeline
Active Graph Agent Runtime (BabyAGI 4)
Claude for Long-Horizon Tasks
CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens
From Systems of Record to Systems of Context
Thinner Agents on a Smarter Substrate: The Ontology-based Semantic Layer
Your Moat Is Your Data Model
Better Auth
Every Harness Will Become A Claw
HTML Is All Agents Need
The Biggest Challenge in Your Stack? Evals, Evals, Evals
The Desktop Frontier
Your agent architecture has a half-life of 6 months
Agent Output Is Not UX: Rendering Layer Your LLM Pipeline Is Missing
Agentic Development Security
Agentic Security: Permissions, Provenance, and the Agent Supply Chain
AI's Jurassic Park Period
Build the AI GTM Agent That Knows the Buyer
Can Oncology Workflows Run Without Human Touch?
Designing Voice Agents for Real Conversations
Don't Let the LLM Drive
Enterprise Agents Have a Structure Problem
In the Land of AI Agents, the Verifiers Are King
It's 10pm. Do You Know Where Your Agents Are?
Medic for Apache Spark: First Aid for Failing Jobs
Privacy-Preserving Intelligence
Security Track Intro
Skills are the New SDKs
Through the AI Fog: The Architectural Decision Agentic Security Depends On
We Gave an Agent Production Code Access and Then Tried to Sleep at Night
When Agents Meet Physical Data: The Other Physics of Agent Harnesses
Why Your Agent Disagrees With Itself (And What To Do About It)
Your LLM Stack Is a 2008 Database With Better Marketing
Your Voice Agent Doesn't Need a Frontier Model
Build Evals That Actually Matter
From Blind Spots to Merged PRs: Continuous Agentic Performance Optimization
From Tokens to Cells: Foundation Models for Single-Cell Biology
You Didn't Ship a Bug. You Just Wrote It for a Human.
A Practitioner's Guide to Graphs
Agents Need Feature Flags
Agents Need Receipts, Not More Tool Calls
Autonomous Agents for Scientific Tasks
Content Is Code
Stop Burning Tokens: Why Self-Improvement Needs Domain Expertise First
Stop Renting Your Cognitive Infrastructure
The UX of AI: Making AI-Powered Apps Your Users Don't Hate
Your Agents Need a Save Button
Every company should have a Brain
On AI and Knowledge
Software engineering is not about writing code
Special Topics in Kernels, RL, Reward Hacking in Agents
The Great Loops Debate
Using LLMs to Secure Source Code
How Autoresearch Is Changing ML Research
Imagination Engineering: "Live in the future and then build what's missing."
Claude Fable, Claude Tag, and Anthropic's Culture
Computer-Use 2.0: Agents Just Got Multi-Cursor
Recursive Model Improvement
Don't Ship Skills Without Evals
Forward Deployed Engineering at Cursor
The engineer of the future is the person who is able to choose what is worth doing.
WTF Is the Context Layer? The Missing Infrastructure for Production Agents
From fork() to Fleet: Designing an Agent Sandbox Cloud
I've Never Seen Anything Scarier Than an LLM with Tool Calls
Modern Post-Training: A Deep Dive
Stop Evaluating Models Like It's the 50s
A Song of Types and Agents
Recursive Language Models for Large Codebases
remobi.app: Don't Change Your Terminal Workflow for Mobile
ReviewDebt: A Practical Framework for Scoring Every Pull Request
Semantic Blindness: 500,000 Sensors Confused an LLM
The Agentic Web and the Bazaar Era of AI
The AI bugpocalypse is here. Now what?
What Does Done Even Mean? Agents and Paperclip's Liveness Model
Chat and citations won't save your vertical AI
Claws Out: Securing and Building with OpenClaw
Design Patterns for AI Trust: Juries, Libraries, and Agent Tiers
Develop at Idea Velocity
Every Solo Agent Builder Eventually Reinvents a Worse Version of CI/CD
From Writing Code to Designing Systems: How the Developer Role is Changing
State of the Union: Why Local, Why Now
Stop AI Agent Hallucinations: 5 Techniques + Production Patterns
The Factory That Dreams: 39 AI Agents, No Framework
Should AI Engineers Still Read Code in 2026? The Z/L Continuum
Understanding is the new bottleneck
The Golden Age of AI Engineering
Building an ACP-Compatible Agent Live
Everything We Knew About Software Has Changed
I Run a Fleet of AI Agents Across Three Machines. Here's What Broke.
Running a Chess YouTube Channel Entirely by AI
Teaching Coding Agents to Do Spreadsheets
Think You Can Build a Game with AI? Think Again!
Your agent is blindfolded
Your coding agent doesn't always follow your rules
Your LLM Deception Monitor Is Broken. The Fix Is in the Training Data
500 People Vibe-Coded for 30 Days. I Was One of Them.
Beyond the Harness: A Journey Towards Adaptive Engineering
Build AI Systems for Discernment, Not Approval
GTM Is You
How We Taught Agents to Use Good Retrieval
Respect The Process
SWE-Marathon: Evaluating Coding Agents at Billion-Token Scale
The Pipeline Is Dead
What if the harness mattered more than the model?
Field Guide to Fable
Continual Learning for AI Agents: From Failures to Durable Improvements
MCP Apps: Primitives, Discovery, and the Future of Software
The Missing Layer After Launch
Your AI Product Will Fail Unless You Can Explain It
Harness Engineering & Startup Battlefield
Autoresearch & Keynotes
The Prompt Is Still a Punch Card
Software Factories & Keynotes
Building Great Agent Skills: The Missing Manual
Deterministic Infra for Non-Deterministic AI Agents
Frontier Results, On Device
The Agentic AI Engineer
The Future Is Domain-Specific Agents
The Prompt is the Platform
You Can't Prompt the Room: The Last Skill AI Won't Replace
Your Agent Failed in Prod. Good Luck Reproducing It.
Agents Building Agents
AI-Driven Multi-Document Correlation for Financial Compliance
AI System Design: From Idea to Production
Browser Agents Don't Need Better Models. They Need Better Eyes.
Building an Autonomous Engineering Org
Bypassing the Multimodal Tax: Hybrid RAG, SQL RRF & UI Telemetry
HTML is All You Need (for Agents to Make Graphics)
OpenClaw in Your Hand: Building a Physical AI Terminal
Research to Reality: Bringing Frontier ML Research to Production
Structuring the Unstructured
The 100-Tool Agent Is a Trap
User Signal Dies at the Retrieval Boundary
Using Spec-Driven Development for Production Workflows
Voice In, Visuals Out: The Agony and the Ecstasy
We Cut 94% of AI Coding Tokens With a Local Code Index
When All Context Matters: Extended Cache Augmented Generation
Your Agent Is Wasting Tokens and You Don't Know It
A Genius With Amnesia
Agents in Production: How OpenGov Built and Scaled OG Assist
Stop Writing Tone Instructions. Layer Them.
Turn 10,994 Notes Into Memory
Build Systems, Not Code
Production Evals For Agentic AI Systems
Recursive Coding Agents
The Log Is The Agent
The Miranda Hypothesis: How Hamilton Poisoned Persona Evals
6 Things to Know about AIE World's Fair 2026
The Production AI Playbook: Deploying Agents at Enterprise Scale
Your Agent's Biggest Lie: "I Searched the Web"
You Might Not Need 50 Diffusion Steps
Why MCP and ChatGPT Apps Use Double Iframes
The agent-ready web: Simplify user actions with WebMCP
Why Can't Anyone Answer Questions About the Business?
Your Attention Is the Bottleneck, Not Your Agents
Self Driving Products: Product Signals to Pull Requests
Sovereign Escape Velocity: Ownership with Open Models
Stop Making Models Bigger, Make Them Behave
From Transcription to Live Music: Gemini's Audio Stack
GPU Cloud Deployment Without Leaving Your IDE
RAG is dead, right??
Road to 5 Million Tokens: Breaking Barriers in Long Context Training
Why Eval++ Is the Next Great Compute Primitive
Why More Context Makes Your Agent Dumber and What to Do About It
From MCP to Scale: Pipelines That Build Themselves
LLM Observability, Evaluation, Experimentation Platform
Under 5 minutes to a deployed LLM endpoint
Building Interactive UIs in VS Code with MCP Apps
Building Safe Payment Infrastructure for the Autonomous Economy
Evals Are Broken, Use Them Anyway
Beyond Transcription: Building Voice AI That Understands Conversations
Building Agent Interfaces: Lessons from Chrome DevTools (MCP) for Agents
Dark Factory: OpenClaw Ships Faster Than You Can Read the Diff
AI Engineer Melbourne 2026 Keynote Livestream | Day 2
SWE-rebench: Lessons from Evaluating Coding Agents
Text Diffusion
The Art & Science of Benchmarking Agents
BDD, ADR, PRD, WTF: Capturing Decisions for Humans and AI Alike
Benchmarking Semantic Code Retrieval on Claude Code
Beyond Components: Designing Generative UI for MCP Apps
How Lovable self-improves every hour
Task Fidelity Scaling Laws
What Lies Beneath the API
How to Talk to Statues
Rethinking What State-of-the-Art Means
What if the network was the sandbox?
Can LLMs Generate Enterprise Quality Code?
Engineering voice agents: Latency, quality, and scale
Spec-Driven Testing for Agents With A Brain the Size of A Planet
How I Deleted 95% of My Agent Skills and Got Better Results
How We Built Zeta2: Training an Edit Prediction Model in Production
Why (Senior) Engineers Struggle to Build AI Agents
Reachy Mini: the $300 open source robot you can actually hack
Reverse Engineering a Viking VoIP Phone Protocol with Claude Code
Why Your Agents Need Decision Traces, Not Just Documents
Context Graphs for Explainable, Decision-Aware AI Agents
How Agent Observability Differs from Traditional Observability
Most Enterprise Agentic Projects Are Doomed, Here's Why
The AI Skill I Rely On Daily
The maturity phases of running evals
Why Rust is the Ideal Language for Vibe-Coding
Run Frontier AI at Home
Stop Babysitting Your Agents
What the Best Agents Share
Agentic Evaluations at Scale, For Everybody
Bounded Autonomy: Between Free Will and Determinism
Does GenAI "belong" to data scientists?
How Google DeepMind Runs Agents at Scale
Let's Talk About FOMAT: Fear of Missing Agent Time
Scaling the Next Paradigm of Heterogeneous Intelligence
Introducing WebMCP: Agents in the Browser
Prompt to Pipeline: Building with Google's Gen Media Stack
The Missing Primitive for Agent Swarms
Fast Models Need Slow Developers
Gemini Nano on device
Lobster Trap: OpenClaw in Containers from Local to K8s and Back
Cooking with Agents in VS Code
Scaling Agents on Kubernetes with acpx and ACP
Your Coding Agent Should Do AI System Engineering
Any-to-Any: Building Native Multimodal Agents
From 46% to 90%: Fine-Tuning Tiny LLMs for On-Device Agents
Skill issue: Lessons from skilling up coding agents to use Langfuse
Don't Build Slop (4 Levels of AI Agent Maturity)
Personalization in the Era of LLMs
What Breaks When You Build AI Under Sovereignty Constraints
Build Agents That Run for Hours
Let's Go Bananas with GenMedia
Rewiring the State
AI Engineer Singapore Day 2
Fighting AI with AI
Harnesses in AI: A Deep Dive
Why Your AI UX Is Broken (and It's Not the Model's Fault)
AIE Singapore Day 1
Beyond Code Coverage: Functionality Testing with Playwright MCP
Connecting the Dots with Context Graphs
How to Leverage Domain Expertise
Agents Don't Do Standups: Building the Post-Engineer Engineering Org
Combine Skills and MCP to Close the Context Gap
How Building with AI Can Double the Throughput of Your Engineering Team
Make your own event-sourced agent harness using stream processors
Mind the Gap (In Your Agent Observability)
Ship Real Agents: Hands-On Evals for Agentic Applications
Building a Chess Coach
CI/CD Is Dead, Agents Need Continuous Compute and Computers
Self-Training Agents: Hermes Agent, HF Traces, Skills, MCP & Finetuning
Give Your Agent a Computer
Lessons from Trillion Token Deployments at Fortune 500s
Malleable Evals: Why Are We Evaluating Adaptive Systems with Static Tests?
A Piece of Pi: Embedding the OpenClaw Coding Agent in Your Product
Viktor: AI Coworker That Lives in Slack
Why MLX
Feedback Loops are All You Need
How We Solved Context Management in Agents
Two Roads to Durable Agents: Replay vs. Snapshot
Give Your Chat Agent a Voice
Voice AI: When Is the "Her" Moment?
Why TTS Models Now Look Like LLMs
Agentic Search for Context Engineering
FLUX, Open Research, and the Future of Visual AI
How Transformers Finally Ate Vision
Agent Optimization with Pydantic AI: GEPA, Evals, Feedback Loops
Everything You Need To Know About Agent Observability
Vibe Engineering Effect Apps
Full Walkthrough: Writing & Using Skills
MCP UI: Extending the frontier
The Multi-Agent Architecture That Actually Ships
Accelerating AI on Edge
Demand-Driven Context: A Methodology for Coherent Knowledge Bases Through Agent Failure
The Small Model Infrastructure Nobody Built (So We Did)
Build Dumb AI Loops That Ship
Skill Issue: How We Used AI to Make Agents Actually Good at Supabase
Training an LLM from Scratch, Locally
Context Is the New Code
Mergeable by default: Building the context engine to save time and tokens
TLMs: Tiny LLMs and Agents on Edge Devices with LiteRT-LM
Human-in-the-Loop Automation with n8n
I Gave an AI Agent the Keys to My Life: Here's What Happened
Software Engineering Is Becoming Plan and Review
Agents for Everything Else
Agents on the Canvas in tldraw
Mastering AI Pricing
Shipping complex AI applications
Building Conversational Agents
LLM codegen fails and how to stop 'em
Replacing 12K LoC with a 200 LoC Skill
Build & deploy AI-powered apps
Everything I Learned Training Frontier Small Models
OpenAI Codex Masterclass
Building your own software factory
One Login to Rule Them All: Cross-App Access for MCP
Why building eval platforms is hard
Gateways are All You Need
Gemma 4 Deep Dive
Scaling GitHub for your Agents
Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment
AgentCraft: Putting the Orc in Orchestration
MCP = Mega Context Problem
Full Walkthrough: Workflow for AI Coding
What Do Models Still Suck At?
Software Fundamentals Matter More Than Ever
The End of Apps
Agents Need More Than a Chat
AIE Miami Day 2
Building Generative Image & Video Models at Scale
How AI Is Changing Software Engineering
Taste & Craft: A Conversation with Tuomas Artman
Build Your Own Deep Research Agents
Gemma, DeepMind's Family of Open Models
Running LLMs on your iPhone: 40 tok/s Gemma 4 with MLX
The New Application Layer
Code Mode: Let the Code do the Talking
The Future of MCP
How Google DeepMind Is Researching the Next Frontier of AI for Gemini
The Friction is Your Judgment
Harness Engineering: How to Build Software When Humans Steer, Agents Execute
State of the Claw
$1 AI Guardrails: The Unreasonable Effectiveness of Finetuned ModernBERTs
Building pi in a World of Slop
Paperclip: Open Source Human Control Plane for AI Labor
AI Didn't Kill the Web, It Moved in!
AIE Europe Keynotes & Coding Agents
Judge the Judge: Building LLM Evaluators That Actually Work with GEPA
One Registry to Rule Them All
Running LLMs Locally: Practical LLM Performance on DGX Spark
AIE Europe Keynotes & OpenClaw
Bending a Public MCP Server Without Breaking It
Cognitive Exhaust Fumes, or: Read-Only AI Is Underrated
Contact Center Voice AI: Low-Latency Intelligence Extraction from Messy Audio Streams
From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work
Let LLMs Wander: Engineering RL Environments
OpenRAG: An open-source stack for RAG
Platforms for Humans and Machines: Engineering for the Age of Agents
Why, and how you need to sandbox AI-Generated Code?
Your Insecure MCP Server Won't Survive Production
Agentic Engineering: Working With AI, Not Just Using It
How METR Measures Long Tasks and Experienced Open Source Developer Productivity
Identity for AI Agents
Building Durable, Production Ready Agents
Your MCP Server is Bad (and you should feel bad)
Spec-Driven Development: Agentic Coding at FAANG Scale and Quality
Automating Large Scale Refactors with Parallel Agents
DSPy: The End of Prompt Engineering
Build a Prompt Learning Loop
Building Durable Agents with Workflow DevKit & AI SDK
Claude Agent SDK [Full Workshop]
Welcome to AIE CODE