All episodes

Context Graphs for Explainable, Decision-Aware AI Agents — Andreas Kollegger & Zaid Zaim, Neo4j

May 28, 2026 · 16:39

Andreas Kollegger and Zaid Zaim of Neo4j argue that context graphs transform AI agents from knowledge-driven to decision-aware by providing the "why" behind actions through policies, rules, and precedent. They present a five-stage decision framework: frame the problem with causality and environment, pull global rules and past precedent, run risk value analysis (including reference class validation—e.g., a drug correct 99% of the time may be fatal for the 1%), decide to act or escalate to authority, and write the full reasoning chain into the graph. This last step turns every decision into precedent for future agents. The talk emphasizes explicit risk assessment, such as whether a decision is reversible and what is being maximized, and uses examples like medical prescribing and financial loan eligibility to illustrate how agents must know their reference class before acting.

The AI Skill I Rely On Daily — Priscila Andre de Oliveira, Sentry

May 27, 2026 · 17:05

Priscila Andre de Oliveira, a senior software engineer at Sentry, reveals that 67% of her AI usage is for comprehension and only 2% for code generation, based on analyzing 116 of her own Claude sessions. Working in Sentry's 15-year-old codebase with 100 PRs merged daily and 100,000 organizations depending on it, she built a personal skill called 'Catch Me Up' with six exploration modes (architecture, conventions, feature traces, syntax, testing, history). She argues that understanding what the agent found before letting it plan and implement prevents misaligned mental models that produce slop code. The episode emphasizes that in large, complex codebases, AI's biggest unlock is comprehension, not generation, and advises developers to align their mental models before prompting.

Why Rust is the Ideal Language for Vibe-Coding — Daniel Szoke, Sentry

May 27, 2026 · 16:25

Daniel Szoke, Sentry's Rust SDK maintainer, argues Rust is ideal for vibe-coding: its compiler enforces correctness, catching bugs that Python and TypeScript allow to compile and run. He challenges the preference for easy-to-write languages, warning that dynamic typing and null values invite subtle bugs. Szoke highlights Rust's type safety, null safety, and fearless concurrency, demonstrating with a 100-thread counter where TypeScript's data race compiles and fails intermittently while Rust rejects it with an error naming the non-Send type. He argues every compile error an agent fixes is a production bug avoided, and the Rust compiler is faster and more reliable than a review agent.

The maturity phases of running evals — Phil Hetzel, Braintrust

May 27, 2026 · 18:34

Phil Hetzel from Braintrust argues that evaluating AI agents should not mimic exhaustive unit tests but instead focus on known failure modes, using a flywheel of production traces to guide improvements. He outlines four maturity phases: vibe checking with documented human justifications, scaling those justifications into LLM-as-judge evaluations, handling context-gathering tool calls, and tackling CRUD tools that require representing external system states at trace time. To address state-replay challenges, he recommends injecting captured system state directly into traces or using timestamp queries against vector databases. The goal is to rerun production data offline, using LLM judges evaluated against ground truth, and automatically uncover failure modes through topic modeling.

Run Frontier AI at Home — Alex Cheema, EXO Labs

May 26, 2026 · 1:45:02

Alex Cheema of EXO Labs argues that running frontier AI locally has 100x improvement potential in cost and performance, demonstrated with GLM 5.1—a trillion-parameter model—running across four Mac Studios at roughly 20 tokens per second for $40,000. He details kernel fusion that recovered 30% performance on Qwen 3.5 by eliminating unnecessary kernel launches, and RDMA integration that cut node-to-node latency from 300 microseconds to single digits, enabling tensor parallelism to actually scale. Cheema advocates splitting inference: prefill on compute-dense hardware (e.g., an RTX Spark) and decode on high-bandwidth hardware (e.g., Mac), cutting large-prompt inference roughly in half. He warns against misleading benchmarks like one-bit quantized models, and outlines how multi-agent setups, test-time scaling, and continual learning could further improve local inference efficiency. The talk includes a live demo of GLM 5.1 across four Mac Studios connected via Thunderbolt 5, and a preview of EXO's upcoming benchmarking site to track intelligence per Joule.

What the Best Agents Share — Mardu Swanepoel, Flinn AI

May 26, 2026 · 10:21

Mardu Swanepoel of Flinn AI identifies four patterns shared by top agents like Cursor, Claude, Manus, and Harvey: focus modes, transparent execution, personalization, and reversibility. Focus modes constrain the action space to improve output quality and align user expectations, as Cursor does with planning and debug modes. Transparent execution shows tool calls and reasoning to build trust and enable early intervention, exemplified by Claude's live task list and Manus's progress tracking. Personalization optimizes speed to understanding through playbooks (Harvey) and memory, so agents follow firm-specific methods. Reversibility bounds downside with rollbacks at line, file, or conversation levels (Cursor) and integration with native undo in Harvey's Word add-in, encouraging users to tackle higher-value tasks.

Stop babysitting your agents... — Brandon Waselnuk, Unblocked

May 26, 2026 · 18:54

Brandon Waselnuk of Unblocked argues that the bottleneck for AI coding agents is not access (MCPs, tools) but understanding—they need a context engine that builds a research packet from codebase, Slack, PRs, and org structure before generating code. He debunks three myths: naive RAG suffers from satisfaction of search, more MCPs don't provide reasoning, and million-token windows don't enable effective reasoning. His team's context engine reduced a Zendesk integration task from 2.5 hours and 20.9M tokens (with MCPs only, but code that would have broken production) to 25 minutes and 10.8M tokens, earning a senior engineer's approval with one nitpick. Three hard lessons: optimize for understanding not access, resolve conflicts rather than hide them (e.g., Slack thread where CTO says code is wrong), and never cache answers because context changes daily. He demonstrates a social graph tool (open-sourced Monday) that maps engineers to code areas and collaborators, and shows a demo where the agent's MCP calls the context engine to generate a plan covering factory patterns, library modules, and client registration.

Agentic Evaluations at Scale, For Everybody — Nicholas Kang & Michael Aaron, Google DeepMind

May 25, 2026 · 20:03

Nicholas Kang and Michael Aaron from Google DeepMind's Kaggle team argue that AI evaluations are broken due to being scattered, stale, and lacking transparency, citing a competing lab publishing inflated results by using custom compaction settings. They introduce four solutions: hackathons to channel community expertise, a standardized agent exam that returned 500+ submissions in its first week without promotion, a Game Arena where models play poker, chess, and werewolf for an ELO rating that cannot saturate, and an open benchmarks platform. A wastewater treatment plant engineer in Turkey built a novel safety benchmark from 20 years of field experience. They note that on SWE-Bench Pro, six frontier models land within a couple of percentage points, but the harness shifts performance by 22%, complicating comparisons. Challenges include high cost (400,000 poker hands for statistical significance), maintaining community engagement, and dealing with fast model deprecation cycles.

Does GenAI "belong" to data scientists? — Phil Hetzel, Braintrust

May 25, 2026 · 18:54

Phil Hetzel of Braintrust argues that generative AI development should not be isolated to data scientists or ML engineers, but instead requires a diverse team including product engineers, systems engineers, and non-technical domain experts. Because models are already built by OpenAI and Anthropic, the remaining work is prompt and context engineering, distributed systems, human annotation, and functional evaluation—not traditional training pipelines. Data scientists add value through rigorous testing and LLM-as-judge evaluation, but must move beyond precision/recall toward broader functional metrics. Traditional enterprises often mistakenly hand GenAI to ML platform teams, while AI natives use small cross-functional groups with closer problem proximity. The ideal mix combines technical roles for implementation and system design with non-technical experts for prompt engineering and human annotation, keeping the agent relevant through continuous feedback.

Bounded Autonomy: Between Free Will and Determinism — Angus J. McLean, Oliver

May 25, 2026 · 16:52

Angus J. McLean, AI Director at Oliver, argues that developers should intentionally constrain large language models rather than maximizing their capabilities, because models naturally tend toward complexity and verbosity. He shares how Oliver generates 4,000 creative assets daily for 200+ brands using agents, but warns that context windows will never be sufficient as world knowledge doubles every 12 hours. McLean advises replacing internet access with curated documentation, asking how little context can be used to complete a task, and never automating a job you cannot do yourself. He illustrates this with his own experience building a complex agent application for his CV that was outperformed 100x by a simple HTML page. The talk frames AI as fundamentally a translation process between representations—text to image, image to audio, etc.—and recommends using multiple representation structures like Markdown, graphs, and folders. McLean's core message is that abundance stops scrappiness, so self-imposed constraints drive creativity and better results.

How Google DeepMind Runs Agents at Scale — KP Sawhney & Ian Ballantyne, Google DeepMind

May 24, 2026 · 25:13

Ian Ballantyne and KP Sawhney from Google DeepMind explain how the company scales its agentic platform anti-gravity, featuring a Darwinian skills library and quota management prioritizing paying customers. KP explains deep research currently passes huge context blobs, but his focus is replacing them with a shared file system, enabling artifact generation like infographics. Token-hungry agents require brute-force quota limits; 24/7 monitoring stops spikes, and internal teams face worse quotas than customers. Observability uses a custom web app tracing agent trajectories to raw predict requests. The skills library relies on contributions from domain experts, with survival through evaluation in sandboxed environments. For code review, per-language auto-review models fine-tuned on style guides automatically comment on PRs.

Let's Talk About FOMAT: Fear of Missing Agent Time — Michael Richman, Cmd+Ctrl

May 24, 2026 · 16:17

Michael Richman introduces FOMAT (Fear of Missing Agent Time), the anxiety of wasting agent productivity when you're away from your dev machine. He built Cmd+Ctrl, a system that sends push notifications when an agent stalls or finishes, lets you respond from phone or watch, and allows starting new sessions remotely. The demo shows Claude Code mirrored on an iPhone, with real-time interaction and a standup dashboard summarizing all sessions. The open-source daemon layer works with Claude Code, Cursor, Codex, Gemini CLI, and others, aggregating sessions across machines into a single pane of glass. Richman argues this alleviates the cognitive load of managing multiple agents and supports the new flow of agent choreography.

Scaling the Next Paradigm of Heterogeneous Intelligence — Adrian Bertagnoli, Callosum

May 24, 2026 · 15:13

Adrian Bertagnoli, founding engineer at Callosum, argues that the era of homogeneous intelligence—scaling single models on identical chips—is ending, and heterogeneous intelligence, which routes tasks to optimal chips and models, is the next paradigm. He demonstrates this with two case studies: on the Ulong benchmark, running recursive language models on Cerebras instead of GPT-5.2 cuts cost by 7x and latency by 5x while matching accuracy; on Video Web Arena, a mixture of Qwen 3 VL8B and Kimi K2.5 beats GPT-5.2 and Gemini 2.5 by 18% and 25%, while costing 3.7x less and running 3x faster. The key insight is that complex problems decompose into subtasks—like zooming on a webpage—which require different intelligence levels; offloading those to smaller models yields 11x speed and 43x cost improvements. Callosum builds an automation layer that predicts the best model and hardware for each subtask, and has secured a £3 million grant with the UK's Arya institute to operate the first heterogeneous co-located cluster.

Introducing WebMCP: Agents in the Browser — RL Nabors

May 23, 2026 · 23:08

Rachel Nabors, former web standards contributor and now Principal Developer Experience Engineer at Arise, argues that chat-only agent interfaces (the 'starfish' design) are the CLI of the future and demonstrates how to replace them with rich interactive surfaces using MCP Apps and WebMCP. She explains STDIO vs HTTP transports, shows how MCP Apps bundle HTML, CSS, and JavaScript into single files rendered in agent iframes, and introduces WebMCP, which adds tool attributes to existing page elements so browser agents can call functions without screenshot parsing or DOM traversal. Using her own web comic site as a case study, she builds a comic reader with full panel navigation, transcript mode, and speech synthesis via the Web Speech API, and advocates for better client support of MCP resources to avoid inefficient tool calls for context loading.

The Missing Primitive for Agent Swarms — Lou Bichard, Ona

May 23, 2026 · 18:37

Lou Bichard, field CTO at Owner, argues that agent swarm infrastructure for coding agents is missing a coordination primitive, while runtimes and orchestration are largely solved. He defines a Software Factory as incrementally removing humans from the SDLC and highlights internal systems from Stripe (Minions) and RAMP (Inspect) as real-world examples. Owner provides VM-level isolation for agent fleets and sub-agent patterns, demonstrated with a demo of process-based and VM-based swarms. Bichard identifies GitHub as a poor coordination layer for hundreds of parallel pull requests and proposes solutions like state machines, durable execution, and a CLI gateway that any local agent can invoke to check progress. He notes context rot and agents skipping steps as key challenges, and announces a public two-week project to build a Software Factory from scratch starting next week.

Prompt to Pipeline: Building with Google's Gen Media Stack — Paige & Guillaume, Google DeepMind

May 23, 2026 · 1:54:35

Paige Bailey, Guillaume Vernade, and Ian Valentine from Google DeepMind demonstrate the company's full generative media stack—from Gemini 3.1 Flash Light's video analysis at $0.25 per million tokens to Genie 3's playable world models and Gemma 4's on-device agentic coding—showing developers how to build multimodal apps without cloud APIs. Paige shows AI Studio's Build feature creating a bookshelf scanning app with Firestore and OAuth. Guillaume walks through a workshop using Nano Banana 2 for character portraits, VO 3.1 Lite for video generation at $0.05 per image, LIA 3 for chapter scores, and text-to-speech with distinct voices. Ian runs Gemma 4's 26B mixture-of-experts model on a MacBook to generate 10 SVGs in parallel and build a game from a spec, all locally. The episode argues that Google's models absorb common agent patterns, making custom fine-tunes less necessary.

Fast Models Need Slow Developers — Sarah Chieng, Cerebras

May 22, 2026 · 18:02

Sarah Chieng from Cerebras argues that the 20x speed increase of models like Codex Spark (1,200 tokens/sec vs. 40-60 for Sonnet/Opus) forces developers to rethink workflows, or risk generating technical debt at unprecedented scale. She presents a practical playbook: validation and linting become free at every step, so must run continuously; developers can generate 75 component variations across five sub-agents and cherry-pick the best; and with context filling in 30 seconds instead of ten minutes, a four-file external memory system (agents, plan, progress, verify) maintains continuity between sessions. Chieng emphasizes real-time collaboration with the model rather than spawning agents and walking away, and advocates using a slower planner model with a fast executor to orchestrate agents effectively.

Lobster Trap: OpenClaw in Containers from Local to K8s and Back — Sally Ann O'Malley, Red Hat

May 22, 2026 · 21:56

Sally Ann O'Malley of Red Hat argues that running OpenClaw in containers with Podman and Kubernetes delivers secure, portable, and reproducible AI agent setups. She uses Podman secrets and OpenClaw's secret ref feature to manage API keys, ensuring secrets stay out of logs and configs. O'Malley demonstrates a local installer that spins up an OpenClaw container in two seconds and lifts the same workload to Kubernetes. She cites an Nvidia team of 10 engineers each running their own OpenClaw in Kubernetes for model evals, claiming it replaced the work of six people. Her vision is a team-standard containerized OpenClaw baseline with company-approved MCP servers and skills, enabling reproducible onboarding and personalization across an organization.

Gemini Nano on device — Florina Muntenescu & Oli Gaymond, Google DeepMind

May 22, 2026 · 19:38

Florina Muntenescu and Oli Gaymond from Google DeepMind explain Gemini Nano, an on-device model that ships at 3–4 GB and is shared across apps via the AI Core system service, which handles scheduling, queuing background batch jobs overnight, and prioritizing foreground apps. The MLKit GenAI APIs (prompt API for text/image input, text output) give access to Gemini Nano, but require flagship devices from the last two years for optimal performance; classic MLKit (vision, OCR) runs on over a billion devices. Hybrid inference, launched weeks before this talk, automatically falls back to Gemini Flash in the cloud when the on-device model isn't available, extending reach. An embedding API for RAG-style solutions is coming soon. For fully custom models, LiteRT offers an alternative path but requires more developer effort for testing and optimization.

Cooking with Agents in VS Code — Liam Hampton, Microsoft

May 21, 2026 · 17:04

Liam Hampton from Microsoft demonstrates how to run three AI agents simultaneously in VS Code using GitHub Copilot: a local agent with Claude Opus for iterative unit test writing, a background agent using git work trees to build a front end from a GitHub issue with minimal oversight, and a cloud agent in GitHub Actions to add documentation and open-source files. He argues that VS Code serves as a single entry point for all three agent types—local for hands-on iteration, background for large tasks where partial involvement is acceptable, and cloud for tasks the developer doesn't need to touch. The talk walks through a live demo where the three agents work in parallel on one codebase, solving different problems (testing, UI, documentation) without interference, and explains the underlying infrastructure: cloud agents run securely in GitHub Actions with MCP servers and built-in safeguards, while local and background agents leverage VS Code's chat customizations and third-party extensions. Hampton also highlights the new modal for managing agents, custom instructions, skills, and MCP servers, positioning Copilot as a unified control plane for diverse AI workflows.

Scaling Agents on Kubernetes with acpx and ACP — Onur Solmaz, OpenClaw

May 21, 2026 · 19:00

Onur Solmaz, a founding engineer at textcortex and OpenClaw maintainer, built acpx, a headless CLI for the Agent Client Protocol (ACP), to automate processing of 300–500 daily AI-generated pull requests on OpenClaw. He replaces manual PTY scraping with structured agent-to-client communication, driving Codex sessions through a node-based workflow: reproduce the bug, judge the implementation, check for conflicts, run a review loop, and emit structured JSON. Solmaz runs parallel Codex sessions from five Discord channels while traveling, one channel per task. He also presents an open-source Kubernetes operator called Spritz (from textcortex) that provisions disposable full-compute pods per task, wires them into Slack, and tears them down when work is done, advocating for on-demand disposable agents over persistent chat apps.

Your Coding Agent Should Do AI System Engineering — Ben Burtenshaw, Hugging Face

May 21, 2026 · 18:25

Ben Burtenshaw from Hugging Face demonstrates how coding agents can take on AI systems engineering tasks—writing CUDA kernels, fine-tuning models, and running multi-agent research labs—by leveraging skills and the Hugging Face Hub. He shows a 1.88x speedup on H100s with an RMSNorm kernel written by Claude Code, and a fine-tuned Qwen3 0.6B achieving 35% on LiveCodeBench. Skills compress years of specialization into hours by turning zero-shot tasks into few-shot workflows. For multi-agent research, a Planner generates hypotheses from papers, Workers implement them as training scripts, and a Reporter monitors results via the open-source Trackio dashboard, with all jobs running on Hub compute. The key is exposing open primitives like kernels, Trackio, and HF jobs as agent-controllable tools.

Any-to-Any: Building Native Multimodal Agents - Patrick Löber, Google DeepMind

May 20, 2026 · 16:21

Patrick Löber, a member of the technical staff at Google DeepMind, explains how to build native multimodal agents using the Gemini API ecosystem, covering multimodal understanding, native image and speech generation, and real-time interaction via the Live API. He demonstrates constructing a NotebookLM clone as an agentic system where a reasoning Gemini model decides whether to generate an infographic or podcast-style audio using function calls to specialized models like Nano Banana for images and a text-to-speech model for speech. The episode details practical implementation: uploading PDFs, video, and audio files; using context caching to reduce costs by 90%; and generating infographics or multi-speaker audio directly from prompts. Löber highlights that native generation models understand world context—like drawing arrows on a map to produce the Golden Gate Bridge—and that the Live API enables audio-to-audio interactions with a single architecture, supporting multiple languages and accents.

Skill issue: Lessons from skilling up coding agents to use Langfuse - Marc Klingen, Clickhouse

May 20, 2026 · 24:09

Marc Klingen, founder of Langfuse, shares six learnings from building a skill that lets coding agents like Claude Code add Langfuse observability and evals to projects. The skill addresses the problem of agents hallucinating stale instrumentation from outdated pre-training context by surfacing a search endpoint for documentation, helping agents navigate 478 documentation pages, and referencing rather than duplicating content. Klingen explains how examining traces revealed 80% of issues, basic eval setups were better than none, and an auto-research loop with a target function suggested six improvements (three accepted). However, the target function nearly backfired by optimizing away documentation-fetching steps vital for long-term reliability. He also discusses challenges of skill distribution, versioning, and whether to aim for quick initial setup or perfect single-shot implementation.

From 46% to 90%: Fine-Tuning Tiny LLMs for On-Device Agents — Cormac Brick, Google

May 20, 2026 · 21:01

Google's Cormac Brick explains how developers can build on-device AI agents using either system-level Gemini Nano via AI Core or app-level custom models via LiteRT-LM. He demonstrates a skill harness built on Gemma 4 that enables agentic tasks like restaurant roulette, running fully on-device with JavaScript UI. For fine-tuned tiny models, Function Gemma at 270M parameters improved from 46% to over 90% accuracy on eight of ten app-intent functions after synthetic data fine-tuning. The talk also covers the Eloquent transcription app, which chains two Gemma 3-based models (ASR and text polishing) under a few hundred million parameters for offline use. Key trade-offs are latency, privacy, and customization versus system integration effort.

What Breaks When You Build AI Under Sovereignty Constraints - Bilge Yücel, deepset GmbH

May 19, 2026 · 19:09

Bilge Yücel, Senior Developer Relations Engineer at deepset, argues that sovereign AI requires explicit control over data flow, model choice, infrastructure, and operations, and retrofitting these pillars breaks existing systems in predictable ways. Replacing frontier APIs with self-hosted models forces re-evaluation from scratch, moving private data across jurisdictions creates multi-database search problems, replacing managed infra reveals vendor lock-in, and adding observability exposes black-box systems. She presents a sovereign architecture with guardrails, MCP tools, and Haystack's swappable components to mitigate these issues. The closing checklist asks whether you can swap models without changing application logic, have compliant run logs, and respond to incidents without calling a hyperscaler.

Don't Build Slop (4 Levels of AI Agent Maturity) - Ara Khan, Cline

May 19, 2026 · 18:52

Ara Khan of Cline presents four levels of AI agent maturity, arguing that most builders suffer from mass psychosis and should focus on thoughtful architecture. Level one is using existing frameworks for rapid prototyping. Level two introduces five rules: treat every agent as a state machine, keep system prompts minimal (e.g., GPT-5.3's prompt is one-third the size of GPT-5's to avoid sensory overload), integrate with a CLI for pseudo-RL pipelines, avoid building slop by designing architecture manually, and master frontier model APIs to leverage reasoning traces correctly. Level three advocates Kanban boards as the ideal UX form factor for managing parallel inference-bound agents, a prediction he made on March 26 that Claude Code shipped ten hours before this talk. Level four involves shipping agents to the cloud for scalability, enabling long-running tasks and parallel execution without local dependencies.

Personalization in the Era of LLMs - Shivam Verma, Spotify

May 19, 2026 · 20:12

Shivam Verma of Spotify's AI foundation explains how Spotify personalizes recommendations using open-weight LLMs, user embeddings from 750 million accounts, and Semantic IDs that compress each of 100 million tracks into six hierarchical tokens, enabling autoregressive next-item prediction. Three components: transformer-based user embeddings, Semantic IDs (e.g., Ariana Grande and Bruno Mars share first two tokens as pop artists), and a soft tokenization layer projecting user vectors into the LLM's token space for personalization without fine-tuning. The system is productionized for podcast next-episode recommendations. Verma also introduces Taste Profile, allowing users to edit their taste profile via natural language for steerable recommendations. This moves from traditional multi-stage pipelines to a unified generative model.

Rewiring the State — Eoin Mulgrew, No. 10 (Downing Street)

May 18, 2026 · 28:18

Eoin Mulgrew, from the Number 10 Data Science team, details how a small insurgent unit at the center of UK government bypasses bureaucracy to rapidly deploy AI. The team recruits exclusively outsiders (0.7% acceptance rate), pays market rates, and ships tools in weeks. Examples include an engineer who saved £1.5M by building a statute-book analysis tool in two weeks, a policy simulation platform for Universal Credit, a delivery red-teaming PMO, and a public service that went from idea to live in two months. The team also placed fellows in the AI Safety Institute, the Incubator for AI (co-creating Xtract with DeepMind to digitize planning applications), and Justice AI, which embeds engineers in prisons. Mulgrew closes with Will, a Y Combinator founder and Harvard dropout, standing outside HMP Wormwood Scrubs with the keys two weeks into the job, urging talented technologists to 'join us, and we'll give you the keys to the state.'

Let's go Bananas with GenMedia — Guillaume Vernade, Google DeepMind

May 18, 2026 · 1:17:14

Guillaume Vernade from Google DeepMind demonstrates the full GenMedia stack—Nano Banana for images, Veo for video, Lyria for music, and TTS—by illustrating an open-source book live. The core insight is that Gemini acts as the prompt engineer for every other model, and this works partly because the gen media models were trained on prompts written by Gemini. He shows how to generate character portraits, chapter scenes, animated video clips using images as first frames, and distinct music per chapter, with Lyria Realtime allowing continuous music that responds to new prompts like a DJ. A new interactions API caches context server-side to make chained multi-turn calls cheaper. For TTS, he uses a trick: assigning different speaking styles (e.g., long poetic pauses vs. breathless stutter) to the same two voices to create four distinct-sounding characters.

Anthropic Workshop: Build Agents That Run for Hours — Ash Prabaker & Andrew Wilson

May 18, 2026 · 1:15:40

Anthropic's Ash Prabaker and Andrew Wilson detail how to build agents that run for hours by replacing self-evaluation with adversarial evaluator agents that use Playwright to test live apps and grade subjective output via rubrics. They explain that context compaction doesn't cure coherence drift, so structured handoffs between fresh context windows are essential. The generator and evaluator negotiate testable sprint contracts before building, and the planner provides high-level specs without overspecifying technical details. They show that a solo Claude Code session built a retro game maker that looked complete but failed in play mode, while the adversarial harness produced a fully functional app with live physics and AI features. Key takeaways include reading traces as the primary debug loop, deleting harness components as models improve, and using file-system state for long-running agents.

Harnesses in AI: A Deep Dive — Tejas Kumar, IBM

May 17, 2026 · 20:27

Tejas Kumar, AI Developer Advocate at IBM, defines an AI harness as everything around the model that grounds it in reality, contrasting it with an agent loop. He demonstrates building a harness for a browser agent tasked with upvoting the first Hacker News post using GPT-3.5 Turbo, emphasizing that the prompt remains unchanged. The initial agent fails and lies about success; the harness adds guardrails (max iterations, context compression), a verify step that checks tool history to catch lies, and a login handler that programmatically injects credentials when the agent hits the login page. The final agent reliably logs in and upvotes. Kumar argues that harnesses provide reliability and control, allowing cheap models to perform well, and predicts 2026 as the year of harnesses, with dynamic on-the-fly harnesses as a potential next step toward AGI.

Fighting AI with AI — Lawrence Jones, Incident

May 17, 2026 · 17:29

Lawrence Jones, founding engineer at Incident.io, describes how his team uses AI to debug their own AI SRE product, which runs hundreds of prompts per investigation across logs, metrics, traces, and code. He explains three patterns: a small CLI (evaltool) that lets coding agents read and edit large eval YAML files, enabling a red-green runbook where agents write failing evals, fix prompts, and verify nothing else broke. Their bigger unlock is serializing every UI debugging view as a downloadable file system, which when dropped into Claude Code allows agents to trace through the prompt hierarchy and identify exactly which prompt to change. For fleet-scale analysis, they run 25 parallel agents—each analyzing one investigation—then cluster results to surface systemic failure patterns across customer accounts. Jones emphasizes that file systems are exceptionally good agent context and that creating AI runbooks for complex analysis saves days or weeks.

Why Your AI UX Is Broken (and It's Not the Model's Fault) — Mike Christensen, Ably

May 17, 2026 · 18:38

Mike Christensen, a staff engineer at Ably, argues that direct HTTP streaming (SSE) for AI chat apps breaks because it ties a response stream to a single connection, making resumability, multi-device sync, and live control mutually exclusive. He introduces durable sessions—a persistent, shared resource decoupled from any individual client or agent—built on Ably's Pub/Sub channels, which automatically handle reconnection, cross-tab synchronization, and concurrent multi-agent activity without complex plumbing. Christensen demonstrates with a live demo: a forced network disconnect that self-recovers, two tabs in perfect sync, two agents running in parallel without an orchestrator, and a handoff to a human agent who joins mid-conversation with full history. The episode concludes that treating the session as a durable shared resource unlocks resilient, multi-surface, and live-controllable AI experiences that the standard request-response model cannot support.

Beyond Code Coverage: Functionality Testing with Playwright MCP — Marlene Mhangami, Microsoft

May 16, 2026 · 19:45

Marlene Mhangami of Microsoft and GitHub argues that AI boosts developer productivity only when paired with clean code practices, citing a Stanford study of 120,000 developers and GitHub Octoverse data showing 275 million weekly commits in 2026 with a growing share co-authored by AI. She advocates test-driven development (TDD) with Playwright for functional testing over unit tests, as AI-generated tests often affirm code behavior rather than user experience. In a live demo, she uses GitHub Copilot CLI and Playwright MCP server to automatically write failing Playwright tests for a toy store's search and filter features, then generate code to pass them. She emphasizes testing one feature per test, capturing screenshots for PRs, and committing code before fixes to preserve context. She closes with advice on using Playwright agents for complex state management and confirming cross-screen-size support.

How to Leverage Domain Expertise — Chris Lovejoy, Notius Labs

May 16, 2026 · 24:45

Chris Lovejoy argues that winning in vertical AI is an organizational problem solved by domain experts acting as Oracle (directly improving AI), Evaluator (defining metrics for engineers), or Architect (building self-improving systems). Granola's first employee, a writer, reviews meeting notes and tweaks prompts as an Oracle because there is no objectively perfect note. Tandem used decentralized Oracles—doctors per specialty and country—to handle variation in medical scribe outputs. Anteria progressed from Oracle to Evaluator to Architect as prior authorization required measurable correctness and automated learning from usage variation. Lovejoy advises hiring a principal domain expert early, giving them ownership, and hiring for breadth (domain expertise plus adjacent skills like data science or engineering) to avoid slow progress and turnover.

Connecting the Dots with Context Graphs — Stephen Chin, Neo4j

May 16, 2026 · 17:39

Stephen Chin of Neo4j argues that retrieval alone is insufficient for AI systems, because context graphs—which store relationships, reasoning traces, and decision provenance—enable grounded, auditable answers. He demonstrates with a healthcare example where a generic RAG system returns generic advice while a graph-grounded system knows the patient smokes and has had surgery, tailoring recommendations. The episode walks through Lenny’s Podcast memory demo and a financial services loan-decision app that surfaces prior rejections, margin trades, and fraud risk patterns, making the graph traversal visible. Chin notes Gartner has placed context graphs on the AI hype cycle and Foundation Capital called them a $3 trillion startup opportunity. Neo4j’s open-source agent memory package (short‑term, long‑term, reasoning memory) powers these context graphs, aiming to help engineers escape fragmented enterprise data and build explainable, policy‑aware AI.

Agents Don't Do Standups: Building the Post-Engineer Engineering Org — Mike Spitz, PFF

May 15, 2026 · 17:50

Mike Spitz, CTO of PFF, details a three-month case study where two engineers using AI agents outperformed a team of ten, achieving 25x more deployments and 10x higher output by ticket complexity. The two engineers deployed five times daily while the ten deployed once every five days; customer satisfaction rose to 8.6 out of 10 from a prior 7–7.5. Scrum practices were eliminated—standups, sprint planning, and retrospectives—replaced by every-other-day huddles. The new workflow moves from a spec to a lightweight design document (LDD) to auto-generated tickets and PRs, with agents handling style and naming in code reviews. A QA agent spins up on staging after each merge to check acceptance criteria against tickets. Spitz advises starting slowly with engineers who have deep system knowledge, encoding engineering culture into composable skills, and treating the development lifecycle like a factory.

Combine Skills and MCP to Close the Context Gap — Pedro Rodrigues, Supabase

May 15, 2026 · 18:27

Pedro Rodrigues from Supabase argues that combining agent skills with the Model Context Protocol (MCP) outperforms either alone, closing the context gap that makes agents unreliable on production systems. In a test with Claude Sonnet 4.6, an agent with only MCP created a SQL view that bypassed row-level security (RLS) by omitting the `security_invoker=true` flag, while the same agent with a skill added the flag correctly. He shares three principles for building product skills: point to living documentation rather than duplicating it, put critical security rules directly in `skill.md` because agents skip reference files, and be opinionated about optimal workflows (e.g., running DDL directly on dev/staging databases before generating migration files). Their evals across Claude Opus 4.6, Sonnet 4.6, GPT 5.4, and GPT 5.4 mini in three conditions (no MCP/no skill, MCP only, MCP plus skill) showed a unanimous task-completeness improvement when skills were added.

How Building with AI Can Double the Throughput of Your Engineering Team — Brian Scanlan, Intercom

May 15, 2026 · 21:49

Brian Scanlan of Intercom explains how treating Claude Code like a new hire—onboarding it to a 15-year-old Rails monolith, writing skills for every recurring task, and connecting it to production systems—doubled engineering PR throughput in under a year. By going all in on one platform instead of letting everyone choose their own tool, Intercom achieved a 17.6% automatic PR approval rate with SOC 2 sign-off, and its CI infrastructure collapsed under the volume. The key principle: give agents problems, not tasks. Scanlan recounts a security incident where Claude automatically pulled files, ran analysis, and handed back next steps in two minutes using a skill he didn't know existed. The talk emphasizes that all engineering work—debugging, testing, planning—should be agent-first, and that companies must invest in platform-level adoption and continuous skill improvement.

Ship Real Agents: Hands-On Evals for Agentic Applications — Laurie Voss, Arize

May 14, 2026 · 2:04:18

Laurie Voss, head of developer experience at Arize AI, delivers a hands-on workshop on evaluating agentic applications using Arize Phoenix, demonstrating that choosing the right eval matters more than tuning it: a correctness eval scored 0 out of 13 on the same financial analysis agent that a faithfulness eval scored 13 out of 13, because the model doesn't know the current year and cannot verify forward-looking data. He walks through building a complete eval pipeline from scratch—starting with tracing a Claude Haiku-based financial agent, reading and categorizing traces to identify root causes, then implementing code evals, built-in LLM-as-a-judge evals, and a custom actionability rubric with labeled examples. Voss emphasizes the importance of meta-evaluation to validate judge accuracy and introduces Phoenix experiments to prove prompt changes actually improve scores, not just vibes. Practical tips include using the impact hierarchy (data quality > prompting > model selection > hyperparameters) and the value of regression evals for safe model upgrades. The workshop closes with cost-aware evaluation, pairwise evaluation, and reliability scoring as next steps beyond the foundations…

Mind the Gap (In your Agent Observability) — Amy Boyd & Nitya Narasimhan, Microsoft

May 14, 2026 · 1:20:07

Amy Boyd and Nitya Narasimhan of Microsoft explain how to close the gap between agent behavior and requirements using Microsoft Foundry's observability stack. They demonstrate tracing via OpenTelemetry, built-in evaluators for quality, safety, and agentic metrics (e.g., intent resolution, task adherence), and red teaming where a second AI attacks the agent to reveal vulnerabilities. The showcase is the observe skill: pointed at an agent with no eval data, it generates a dataset, runs batch evaluations, optimizes the prompt, compares versions, and rolls back to the best one—all from a single prompt. The skill surfaces failures developers didn't know existed, accelerating the optimize loop with human-in-the-loop guidance.

Make your own event-sourced agent harness using stream processors — Jonas Templestein, Iterate

May 14, 2026 · 1:04:27

Jonas Templestein and Misha from Iterate introduce an event-sourced agent harness built on stream processors, arguing that agents should be modeled as an append-only event log with a synchronous reducer for state and an after-append hook for side effects. They demonstrate how every action—streaming chunks, tool calls, errors—becomes an event, enabling full debuggability and replay without re-running LLM calls. The key innovation is a "dynamic worker configured" event whose payload is a JavaScript processor; appending it to any stream instantly turns that stream into an AI agent with no server or dependencies. This allows processors from different authors and languages to compose on the same stream, and a safety checker can inject context within 200ms without blocking the agent. The hosts emphasize eventual consistency over before-hooks, and show deployment via Cloudflare Workers or by simply subscribing from any HTTP client.

Self-Training Agents: Hermes Agent, HF Traces, Skills, MCP & Finetuning — Merve Noyan, Hugging Face

May 13, 2026 · 19:11

Merve Noyan from Hugging Face argues that open-weight and open-source models have caught up with closed models, citing GLM 5.1 topping the Artificial Analysis Intelligence index. She walks through Hugging Face’s ecosystem for agentic AI: benchmark datasets on the Hub to filter models by SWE-bench or AIME scores; inference providers that route to the cheapest or fastest option per model; a traces repository type for storing and exploring agent sessions; and skills that plug into coding agents (e.g., Claude Code) to fine-tune vision-language models on a dataset by name—calculating VRAM, selecting an instance, and launching the job. She demos an agent-driven fine-tuning of Qwen2-VL on a vision-language dataset, and a case study where an LLM agent orchestrated OCR of 30,000 AI papers using open OCR models and Hugging Face Jobs, eliminating napkin math. The MCP server also enables querying Hub models, datasets, and spaces from agents.

Building a Chess Coach — Anant Dole and Asbjorn Steinskog, Take Take Take

May 13, 2026 · 18:22

Anant Dole and Asbjørn Steinskog of Take Take Take, Magnus Carlsen's chess app, built an AI chess coach that keeps LLMs as translators rather than reasoners. Stockfish evaluates positions, tactical and positional detectors extract forks, pins, and structural weaknesses, and the LLM only converts those structured signals into English—preventing hallucination. They target sub-3-second latency using Gemini Flash. When a user flags bad commentary, it posts to Slack and injects into a running Claude Code channel via MCP. Claude investigates, modifies prompts or detectors, regenerates commentary, and asks clarifying questions. They run automated evals across 16 scenarios: Gemini Flash at 75%, Claude thinking below 60%, GPT-5 Mini lower. Their key insight: separate data pipeline from language generation, and close the loop with autonomous agents.

CI/CD Is Dead, Agents Need Continuous Compute and Computers — Hugo Santos and Madison Faulkner

May 13, 2026 · 18:37

Madison Faulkner and Hugo Santos (Namespace) argue that traditional CI/CD is dying because it was built for humans pushing one or two diffs a week; at agent scale, thousands of autonomous agents opening PRs cause runner saturation, cold Docker builds, cache thrash, and merge queues that behave like serialized database locks. They propose replacing PRs with intent and plan fed into an agent loop that performs fast inline validation—builds and tests in the inner loop—while humans review intent-plus-outcome instead of diffs in a premerge queue. The future they envision involves agents exploring multiple commits in parallel for the same plan (a multiverse) where the inner loop must be stateful and extremely fast to keep up with the moving tip of the repo. CI doesn't disappear but shifts into continuous enforcement of invariants and governance within the agent harness.

Give Your Agent a Computer — Nico Albanese, Vercel

May 12, 2026 · 1:08:53

Nico Albanese demonstrates building an agent with Vercel's AI SDK v6, centered on the insight that giving an agent a file system transforms its behavior—it follows through on long tasks, stays on track, and builds on prior work. He walks through creating a tool loop agent from scratch, adding provider-executed web search with typed UI components, and integrating Vercel's persistent named sandboxes that snapshot state after inactivity. The agent gains a bash tool for file system access, a memories.md file for persistent memory injected into instructions each turn, and instructions to generate Python scripts for repeatable tasks so it accumulates tools across sessions. Albanese explains how these patterns scale: an internal agent called D0 reduced customer support tickets by 90% with a 95% satisfaction rate, and his personal coding agent ran for 104 minutes in one turn, using 316 tool calls and only 32% of GPT-5.4's context window with zero compaction. The session concludes with a preview of a larger sub-agent system that uses durable workflow steps and background sub-agents to keep the main thread under 7,000 tokens.

Lessons from Trillion Token Deployments at Fortune 500s — Alessandro Cappelli, Adaptive ML

May 12, 2026 · 18:35

Alessandro Cappelli, co-founder of Adaptive ML, argues that 95% of GenAI pilots fail to reach production because they rely on proprietary models or instruction fine-tuning, which lack systematic feedback integration. Reinforcement learning (RL) is the only post-training technique that mathematically incorporates defects, business metrics, and production signals to continuously improve models. RL enables smaller, cheaper, faster models that enterprises can own—critical for scaling use cases like AT&T’s transcript summarization or Manulife’s agents. For agents, RL naturally fits because it was designed for environments; synthetic data is generated as a byproduct of environment training, not a prerequisite. Reward signals come from business KPIs (e.g., containment rate) or LLM judges defined by human rubrics in hours, not weeks. Adaptive ML’s Adaptive Engine abstracts away RL complexity (orchestrating four models for PPO) and provides pre-built recipes to industrialize model deployment.

Malleable Evals: Why Are We Evaluating Adaptive Systems with Static Tests? — Vincent Koc, OpenClaw

May 12, 2026 · 15:05

Vincent Koc argues that AI applications are adaptive systems, yet evaluations remain static datasets—a problem he calls 'eval calcification.' In this talk at AI Engineer, he explains that 80% of an agent’s work is stable, but the 20% that constantly shifts as users change is what breaks businesses. He proposes treating evals as living code: agents that self-curate test suites from their own traces, integrate telemetry in the loop so the harness detects and self-corrects from failures, and define end states rather than right answers. Koc draws on his work with Comet and the OpenClaw harness, where the harness itself adapts and changes. The result is evaluations that are not a fixed dataset but a self-optimizing system that grows with the application.

A Piece of Pi: Embedding The OpenClaw Coding Agent In Your Product — Matthias Luebken, Tavon

May 11, 2026 · 20:42

Matthias Luebken explains how to embed Pi, the minimal coding agent SDK from OpenClaw, into real products, arguing that the key architectural principle is to make systems easy for agents. He demonstrates a B2B sales pipeline application where incoming RFP emails are routed to customer-specific agent sessions, CLIs expose CRM and ERP data cleanly, and the only human output is a draft in the user's inbox. The agent is purely an LLM calling tools in a loop, with Pi's extensions enabling UI interactions and session management. Luebken emphasizes that coding agents will become core building blocks for software, and Pi's minimal design is ideal for tinkering and learning.