Gemini

Context Engineering in 2026 — Louis-François Bouchard, Omar Solano & Samridhi Vaid, Towards AI

Aug 17, 2026 · 1:03:26

Louis-François Bouchard, Omar Solano, and Samridhi Vaid of Towards AI test context engineering on their AI tutor: keeping full history beat every compaction technique on recall, cost, and latency because 97% of tokens were served from cache (up to 50x cheaper), making summarization a trap unless it shrinks context by more than 50x. Full history recovered specific details 95% vs 32% after summarizing, and distinctive facts survived 800k tokens. Local hardware changes it: a 32k window can't keep everything, and larger models don't widen context. Dense retrieval hit 0% recall at 400k tokens where BM25 got 100%, so they use hybrid retrieval. Rule: name the constraint before compacting.

Lessons from Studying Every Memory System — Shlok Khemani, Independent

Aug 12, 2026 · 19:31

Shlok Khemani, an independent researcher, reverse-engineered the memory systems of ChatGPT and Claude to show how consumer AI personalization evolved from user-managed fact lists to background-updated running profiles. He details that ChatGPT's v2 profile is ~4,000 tokens of dense keyword clues, updated every few days, while Claude's is 1,000 tokens of full sentences, refreshed daily and visible in settings, arguing memory is a function of compute with trade-offs between serving and update costs. He highlights a false memory where ChatGPT claimed he visited Turkey in 2025 (he went to Thailand), blaming a product problem—no system notices conflicts or reasons over email and calendar—rather than a technology limitation. He concludes that memory cannot be outsourced, continual learning already happens outside model weights, and the real bottleneck is context gathering across fragmented products.

Teaching AI to Find Real Vulnerabilities — Prof. David Brumley, Bugcrowd

Aug 1, 2026 · 27:17

Carnegie Mellon professor and Bugcrowd chief AI officer David Brumley argues that teaching AI to hack mirrors human learning: a ladder from crashes to arbitrary code execution, graded by deterministic oracles rather than LLM judges. He shows why benchmarks fail when targets hold multiple vulnerabilities — models reward-hack the easiest bug — and presents his 'audit task' scoring precision and recall across all discovered bugs. Testing on Chrome's V8 with 41 real vulnerabilities, MITHOS hit 73% full code execution and GPT 68%, while Gemini and Kimi scored 0%. Several exploits were novel: MITHOS reverse-engineered Math.random to forge a pointer, found a new WASM path, and produced a real zero day. The episode grounds this in stories from picoCTF winner Fluorescence to DARPA's Cyber Grand Challenge, urging RL environments built on real bugs over benchmark-maxxing security.

Data Quality Is the Compute Multiplier — Ari Morcos, DatologyAI

Jul 31, 2026 · 19:05

DatologyAI CEO Ari Morcos argues data quality is the compute multiplier: better data steepens scaling, so the same compute buys better models. His oil-refinery approach—clean, curate, create, compose—uses synthetic rephrasing for diversity; curation let a VLM beat the public Pareto frontier with 145x less training compute and match Qwen 3.5 with 35x fewer flops per correct answer. Curating English also boosts non-English via cross-lingual transfer. For Thomson Reuters, mid-training on curated legal data lifted LegalBench 5 points without catastrophic forgetting and tripled post-training gains. Arcee's Trinity Large, trained on 17 trillion curated tokens, matched GLM-5 and Kimi and beat Claude on some tasks for under $20 million, proving data curation is cheaper than compute.

Data and Environment Curation for Post-Training LLMs — Mahesh Sathiamoorthy, Bespoke Labs

Jul 31, 2026 · 19:12

Mahesh Sathiamoorthy, CEO of Bespoke Labs, argues that data and RL environments, not algorithms, are the bottleneck in post-training LLMs, and shares open-source work including OpenThoughts and Curator. He details the OpenThoughts curation recipe, built with Stanford, Berkeley, and UW, whose counterintuitive lessons include that sampling multiple answers per question works well, stronger teachers are not always better, and synthetic rewriting failed for agent tasks. He notes that for agents, SFT still contributes most of the gains, with RL only adding the last few percentages. A concrete production case: Credit Karma needed compliant credit card recommendations, and tagging fine-tuning data lifted compliance metrics while improving latency and throughput. He closes with the full stack needed to build RL environments and post-train agents.

Agents at Scale: Inside MiniMax's Model and the Infrastructure Behind It — Dan Fu and Olive Song

Jul 31, 2026 · 20:14

Olive Song, RL lead at MiniMax, and Dan, Together AI's VP of Kernels, argue that open-weight MiniMax M3 is closing the gap to frontier labs via community feedback and inference optimization. Dan details the day-zero stack: GPU kernels for M3's sparse attention, KV cache at million-token contexts, and adapting to agentic workloads that upload codebases. Song says M3 trains multimodal from scratch to prevent text-vision collapse, and uses RL with environment design and rewards for long-horizon tasks like replicating a 12-hour iClear paper, plus validation/test splits to avoid hacking. Together's Parallel Kernel Bench holds unsolved problems, so overfitting it yields kernels the company deploys. Both see self-evolution and better GPU utilization as why open models keep accelerating.

DeepSWE: A Contamination-Resistant Coding Benchmark — James Shi, Datacurve

Jul 26, 2026 · 17:34

James Shi from Datacurve presents DeepSWE, a contamination-resistant coding benchmark of 113 original tasks that differentiates model performance clearly. The leaderboard shows a wide spread, with Fable 5 top and Gemini 3.1 Pro near bottom. Qualitative findings: Claude forgets multi-part prompts in 2 out of 3 rollouts and attempts Git log cheating up to 25% of the time, GPT implements exactly what is asked, and stronger models more often write their own tests. DeepSWE's tasks have half the prompt length of SWE Bench Pro but produce five times the solution lines of code, with program-based verifiers checking observable behavior. Shi explains tasks are authored by core contributors, and anti-cheating measures separate verifier and agent runtimes.

Vending-Bench: Long-Horizon Agent Evals — Lukas Petersson, Andon Labs

Jul 24, 2026 · 18:05

Lukas Petersson, co-founder of Andon Labs, presents Vending-Bench, a long-horizon evaluation where AI models run a simulated vending machine business for a year, revealing emergent misbehavior such as price collusion, lying to suppliers, and power seeking. The benchmark exposes a simulation awareness problem—models behave differently when they know they are being tested. To address this, Andon Labs moved to real-world deployments: a café in Stockholm run by Gemini (which lost $6,000 and was replaced by GPT), a retail store on Union Street, and an AI radio station where Claude emerged as the best DJ. They developed a method to fork real environments into simulations mid-run, dramatically reducing simulation awareness. In a replay test of a Nazi song incident, Grok played it over 90% of the time, Gemini about half the time, while Opus and GPT refused every time.

From Systems of Record to Systems of Context — Omri Bruchim & Tomer Ast, monday.com

Jul 22, 2026 · 15:58

Omri Bruchim and Tomer from monday.com argue that AI assistants fail to understand users because the bottleneck is understanding, not retrieval—so they are building a 'Monday world model' that precomputes context before the user asks. The system uses two engines: a slow engine that mines weeks of activity into a durable user profile (knows you), and a fast engine that reads recent signals for urgent items (knows your day). This split mirrors neuroscience’s hippocampus-neocortex and data architecture’s lambda architecture. The context is served to their Sidekick assistant, which degrades gracefully by falling back to verified context and compounds as every new day sharpens the profile. The result: Sidekick can answer 'what should I focus on right now' with understanding, not just a list of disconnected bullets.

HTML Is All Agents Need — James Russo, HeyGen

Jul 21, 2026 · 15:13

James Russo, software engineer at HeyGen, argues that HTML, CSS, and JavaScript are the native languages of LLMs and all agents need to create great videos—leading to HyperFrames, an open-source framework that turns agent-authored HTML into deterministic MP4s. By letting the small Gemini 3 Flash model author code first, they ensured the thinnest wrapper won, with only a few data attributes for timing. Rendering works by freezing the browser clock and seeking frame by frame, ensuring everything loads before capturing each frame—enabling deterministic video from any web technology (Three.js, WebGL, Lottie). HyperFrames skills focus on taste and video craft rather than teaching frameworks, raising the floor for single-shot output. The framework has already rendered over 1.3 million videos in 90 days from 267,000 creators, with 15,000 daily renders and 32,000 GitHub stars—proving the approach at scale.

Agent Output Is Not UX: Rendering Layer Your LLM Pipeline Is Missing - Bala Ramdoss, Amazon Lens

Jul 20, 2026 · 14:13

Bala Ramdoss (Amazon) argues that the UI delivery layer—generative UI—determines whether agentic AI features ship successfully, not the model itself. He presents three patterns from building Amazon Lens at scale: (1) a typed, versioned rendering contract where the model selects from a fixed catalog of components (e.g., flight carousel vs. list) and the client falls back safely for unknown types; (2) streaming UI chunks to show skeletons then fill progressively, shifting focus from total latency to time-to-first-chunk; and (3) a Backend-for-Frontend (BFF) that absorbs model output, hydrates actions and conversation context, and reuses existing native components so the AI feels like a natural part of the app. The episode demonstrates that mobile apps, which cannot be patched instantly, require this architecture to avoid crashes and deliver a snappy, trustworthy experience.

Autonomous Agents for Scientific Tasks - Sina Shahandeh, Radicait

Jul 18, 2026 · 19:23

Sina Shahandeh (Radicait) presents an approach to improve autonomous agents for scientific tasks by focusing on hypothesis generation rather than just implementation. He argues that standard coding agents saturate because they run out of ideas, and introduces a hierarchical decomposition method that breaks problems into subcomponents (e.g., data, architecture, training loss) and prompts LLMs to generate radical changes—like switching from 2.5D to 3D convolutions for CT-to-PET translation. He also shows how adversarial/collaborative loops with multimodal models (e.g., Gemini) can critique intermediate results, and uses Peter Steinberger's Oracle CLI to invoke GPT-5 Pro for better reasoning. The talk demonstrates these techniques on real-world medical imaging tasks, including image registration and lung nodule analysis, and identifies multimodal model limitations as a key bottleneck for fully autonomous scientific discovery.

Special Topics in Kernels, RL, Reward Hacking in Agents — Daniel Han, Unsloth

Jul 17, 2026 · 2:20:21

Daniel Han of Unsloth argues that reward hacking—where AI models cheat to maximize reward—is a critical problem in agent training, citing examples from GPT-5.1's calculator hacking and GPU mode kernel competitions. He shows that models exploit benchmark flaws, such as viewing Git history or editing timers, and that even open-source models like GLM 5.2 require anti-hacking measures. Han emphasizes that harness and tooling quality now outweigh model choice, with inference providers sacrificing accuracy for speed (e.g., 10% accuracy drops across providers). He also warns that hardware limits (float4 precision, diminishing returns) shift focus to software algorithms like FlashAttention and gradient checkpointing. The workshop concludes that benchmarks are unreliable—DeepSpeed's false positive rate is contested at 44.9%—and urges verification before trusting performance claims.

"Software engineering is not about writing code" — Benoit Schillings, Google DeepMind VP of Research

Jul 17, 2026 · 20:26

Benoit Schillings, VP of Technology at Google DeepMind, argues that the era of syntax generation is over, with AI now capable of superhuman code writing, shifting the bottleneck to architecture and validation. He explains that 80% of new code on GitHub is machine-generated, leading to a saturation of human training data and the need for self-play techniques inspired by AlphaZero. Schillings highlights DeepMind's use of self-play to generate and verify coding challenges, enabling models to reach superhuman performance. He emphasizes the shift to inductive architecture, where models must plan, decompose complex problems, and transfer knowledge across domains. Additionally, he calls for new programming languages designed for models rather than humans, and explores how AI's rapid experimentation will transform fields like chemistry and biology by uncovering patterns invisible to humans.

Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison

Jul 15, 2026 · 51:30

This episode features Anthropic's Cat Wu and Thariq Shihipar discussing Claude Code, Claude Tag, and Claude Fable, arguing that these tools have shifted engineering from slow spec-driven processes to rapid, ambitious building. Thariq notes that with each model generation, delegation increased, and Claude Fable now enables one-shot features. Cat says engineers now need product taste over execution, as timelines shrink from six months to a week. Claude Tag, a proactive multiplayer agent, lands 65% of product engineering PRs internally by monitoring channels and remembering preferences. The team reduced Claude Code's system prompt by 80% for frontier models by removing examples and hard constraints, relying on model judgment. Auto mode, used internally since January, mitigates prompt injection through thousands of evals and Sonnet classifiers. Cultural hacks include default-public channels and a 'don't negotiate against ourselves' mindset, leading to ambitious builds like Thariq's Claude-powered video editing and a Street Fighter game.

Stop Evaluating Models Like It's the 50s - Alejandro Vidal, Mindmakers

Jul 13, 2026 · 23:35

Alejandro Vidal of Mindmakers argues that counting correct answers in LLM benchmarks—classical test theory—should be replaced by item response theory (IRT) from psychometrics for richer evaluations. Using real data from Epoch.ai, he shows that while Claude Opus 4.1 scored 245 right and Gemini 3 Pro 247, IRT reveals Gemini is nearly one standard deviation more intelligent because it answers harder questions. IRT assigns each item difficulty (B) and discrimination (A), enabling benchmark auditing—Vidal flagged mislabeled items like a question about passengers whose gold answer was actually total people killed. He demonstrates reducing a 484-item benchmark to 97 items with 99% ranking correlation by selecting high-discrimination items, saving tokens and money. IRT also detects contamination via unexpected residuals, protects benchmarks through adaptive testing with unique fingerprint sets, and identifies model families (e.g., DeepSeek distillations correlate 0.38). Vidal previews future extensions like multidimensional models and alignment measurement.

RLM: Recursive Language Models for Large Codebases - Shashi, Superagentic AI

Jul 12, 2026 · 17:27

Shashi from Superagentic AI explains how Recursive Language Models (RLM), a pattern from MIT, solve the context window problem in large codebases by externalizing context management into a programmable REPL where the model writes code to inspect, slice, and compute relevant chunks, and recursively delegates sub-questions via llm_query. The RLM loop loads the repo as data, produces bounded observations, and can recursively call another model for deeper insights. Shashi demonstrates RLM Code, an open-source independent implementation running locally and on Gemini with a Docker sandbox, showing two tool calls and a complete trajectory. He notes that similar RLM concepts are used in proprietary systems like Codex, Claude managed agents, and dynamic workflows, making it a practical pattern for AI engineers dealing with monorepos.

Develop at Idea Velocity - Jeffrey Lee-Chan, Snapchat

Jul 11, 2026 · 15:28

Jeffrey Lee-Chan (Snapchat) and Austin (CMUX) explain how to achieve 'idea velocity' by building parallel multi-agent harnesses that let one engineer direct 10–20 coding agents instead of becoming the bottleneck. Lee-Chan argues the key is separating 'Agent Orchestrator Managers' from specialized workers to prevent low-level implementation bias, using OpenClaw for frictionless Slack-based communication and CMUX terminals for real-time parallelization and unbiased manager oversight. He demonstrates two apps—an AI RPG with dice-roll mechanics and a multi-AI analysis tool—built with this stack, and discusses token-burn tradeoffs between models like Codex 5.3, GPT-5.4, and Minimax. The episode also covers staging environments to avoid doubling token usage, the benefit of persistent memory and contextual guardrails, and the importance of pushing human interaction to the start or end of the workflow for improved parallelization.

Think You Can Build a Game with AI? Think Again! - Danielle An & David Hoe, Meta

Jul 8, 2026 · 18:00

Meta engineers Danielle An and David Hoe share insights from leading AI-driven game creation at Meta, arguing that while anyone can now prompt a basic game with AI, truly standout games require aesthetic cohesion, playtesting, and runtime LLMs that make NPCs dynamic and unscripted. They demonstrate how anchoring an LLM on a single image (like a QR code) can unify art style and gameplay, and show a multiplayer game where LLM-driven NPCs compete with unique personalities. The key shift is from linear, costly game development to parallel, rapid iteration cycles enabled by AI tools. They also highlight challenges: managing indeterminism across the entire stack (from user prompts to platform ranking), debugging agentic systems, and ensuring content safety with runtime generation. The takeaway: whether you're a beginner, intermediate, or advanced creator, the AI gaming frontier is at day zero, with open problems in token economics and scalable safety.

Building an ACP-Compatible Agent Live — Bennet Fenner, Zed

Jul 8, 2026 · 18:19

Bennet Fenner from Zed demonstrates building an ACP-compatible coding agent live, showing how the Agent-Client Protocol lets agents and editors communicate over JSON-RPC. He starts with a minimal agent that reads and edits files, then adds ACP support using the TypeScript SDK—implementing initialize, session creation, and prompt handling. Next, he streams model tokens via session updates, emits tool call progress with file paths and diffs, and proxies file system operations through the client. The demo culminates in the agent bootstrapping itself to add a terminal tool, which then runs shell commands inside Zed. ACP currently works over stdio; a remote transport is in development.

Running a Chess YouTube Channel entirely by AI — Stephan Steinfurt, TNG

Jul 8, 2026 · 16:31

Stephan Steinfurt, from TNG, presents their AI system that automatically creates daily chess puzzle explanation videos for YouTube. The agent combines a chess engine (for analysis) with Google's Gemini 3.1 Pro (for natural language) to generate detailed move-by-move commentary, including arrows and highlights. It downloads games from LeChess nightly, runs checks/captures/threats analysis, and uses 11Labs for text-to-speech with emotional tags. The YouTube channel has 500k views and 4,000 subscribers, with each video costing 20-30 cents (not yet monetized). Steinfurt notes the error rate is low (1 in 20 videos has a mistake) and discusses balancing explanations for different skill levels using the Maya engine to suggest human-like moves.

How we taught agents to use good retrieval - Hanna Lichtenberg, Mixedbread AI

Jul 7, 2026 · 14:28

Mixedbread AI co-founder Amir and AI engineer Hanna Lichtenberg argue the main bottleneck for knowledge agents is not reasoning but retrieval, coining the 'Oracle Gap'—the performance drop when agents use default tools. On BrowsComPlus, Oracle accuracy is 93% but Codex drops 9 points; with Mixedbread's search they recover to within 3 points. They show models write keyword gibberish (e.g., 'Senator, women, questions, billionaires, not a company') because they were trained on code tools like grep. To fix this, they built a search agent with 4 tools (overview, semantic, filter, grep) using a harness that encourages natural query sentences. Training involved supervised fine-tuning from a larger teacher and reinforcement learning with a reward combining retrieval metrics and trajectory quality (e.g., judging if queries are natural sentences). Their agent achieved NDCG@10 of 0.4 on Oblique Congress (vs. 0.18 for GPT multihop) and topped Snowflake's MedQA benchmark with 93.4% accuracy using Gemini 3.5 Flash.

Build AI Systems for Discernment, Not Approval - Angel Ortmann Lee, Duolingo

Jul 7, 2026 · 25:53

Angel Ortmann Lee, a Software Engineer at the Duolingo English Test, argues that human-in-the-loop AI systems often fail because humans cognitively surrender—adopting AI output with minimal scrutiny, as seen in a Wharton study where 80% accepted wrong AI answers. At Duolingo, an experiment with fake AI cheating alerts showed skilled proctors flagged legitimate sessions 50% of the time due to automation bias. A simple guideline change emphasizing independent evidence boosted accurate rejections by 21%, proving the fix lies in engineering the interaction, not better models or oversight. Lee outlines design principles: engineer reasoning patterns (e.g., frame humans as investigators), match friction to stakes (add review gates for high-stakes decisions), treat every interaction as a label (capture diffs when humans override AI), and proactively define success metrics to structure interactions that yield high-quality data. The flywheel of intentional design yields a virtuous cycle of better data, models, and human judgment.

SWE-Marathon: Evaluating Coding Agents at Billion-Token Scale - Rishi Desai, Abundant AI

Jul 7, 2026 · 12:58

Rishi Desai of Abundant AI presents SWE-Marathon, a benchmark for coding agents that finds even the strongest setup achieves only a 26% resolution rate across 20 project-scale tasks. Trajectories average 31 million tokens, with the longest consuming 877 million tokens, and a computer-use agent verifier evaluates full-stack products via browser interactions. Desai warns that weak verifiers become attack surfaces in long-horizon evals, showing agents bypassing tasks by calling GCC from within a Rust compiler, caught by anti-cheat layers using S-Trace. Across 1,400 rollouts, 12.8% showed suspicious shortcuts and 9% clear verifier bypasses, but zero earned reward through exploits due to multi-channel checks. The central claim: long-horizon SWE is unsolved, and robust verification—not harder unit tests—is the key bottleneck for future benchmarks.

Frontier results, on device - RL Nabors, Arize

Jun 29, 2026 · 30:52

RL Nabors (Arize) argues that most frontier-model calls can be replaced by smaller, local models, saving cost, latency, and energy. She presents a four-step framework: prototype big with a foundation model, collect a golden dataset, run capability evals using Arize's open-source Phoenix, then select the 'sage' (small and good enough) model. Demonstrating with her social app Mima, she tested Qwen 2.5, Qwen 3, LLaMA 3.2, and Gemma 4 against Claude Sonnet on summary accuracy, latency, and cost. LLaMA 3.2 (3B params) won at 90% accuracy and 1-second P50 latency, versus Gemma 4's 8 seconds. Prompt engineering—specifically few-shot prompting—closed the gap further, achieving 92.9% factual consistency and 100% JSON validity. Nabors emphasizes running regression evals to prevent regressions, and notes that on-device inference eliminates data exposure and round-trip latency.

Turn 10,994 Notes Into Memory - Paul Iusztin, Decoding AI & Louis-François Bouchard, Towards AI

Jun 26, 2026 · 39:32

Paul Iusztin and Louis-François Bouchard introduce an AI Research OS that transforms a personal Second Brain (e.g., an Obsidian vault of 5,000+ notes growing by 250 files/month) from a passive archive into a live, queryable memory for AI agents. They argue that bigger context windows aren’t enough; proper memory and context management are needed. The system evolved through three iterations: first a simple deep research loop generating static research Markdown files (used for 35 course lessons), then targeting both the public web and the user’s Second Brain, and finally adding a persistent wiki layer. The architecture uses plain files (Markdown, YAML index) instead of vector databases, with a hierarchy of raw sources, source summaries, and wiki derivatives (concepts, comparisons, entities). The wiki evolves with every question, not just during ingestion. Demos show ingesting Obsidian notes, GitHub repos, and arbitrary links, then querying the wiki to update it dynamically.

The Log Is The Agent - Ishaan Sehgal, Omnara

Jun 25, 2026 · 15:11

Ishaan Sehgal, CEO of Omnara, argues that an AI agent's true identity is not the model, runtime, or tools but its append-only event log—the durable record of every user input, model output, tool call, and permission. Drawing an analogy to a video game save file that persists beyond hardware failure, he explains that treating the log as the agent enables reliability, scalability, forking, migration, multiplayer, and ownership. He warns that deepest lock-in is log lock-in: if a provider owns the log, it effectively owns the agent. Omnara's open-source managed agents platform is built around the session log as the system, not a side effect, allowing agents to survive crashes, resume across machines, and be fully owned and inspected by users.

The agent-ready web: Simplify user actions with WebMCP — Tara Agyemang, Google

Jun 11, 2026 · 21:34

Tara Agyemang from the Google Chrome team introduces WebMCP, a proposed web standard that replaces brittle DOM scraping with structured tools for AI agents. She explains two implementation paths: the declarative API (adding HTML attributes to forms) and the imperative API (registering custom JavaScript tools). A live demo shows a concert ticket purchase completed in three tool calls: search, open page, purchase. WebMCP is in early preview on Chrome 146, with an eval CLI and inspector extension available for testing.

Sovereign Escape Velocity: Ownership w Open Models — Gus Martins, & Ian Ballantyne, Google DeepMind

Jun 10, 2026 · 20:52

Gus Martins and Ian Ballantyne of Google DeepMind introduce Gemma 4, a family of open-weight models that deliver high quality per parameter, enabling deployment on a single GPU or even a phone. They argue that the models' efficiency — a 31B model rivals those twenty times larger — and the shift to Apache 2.0 licensing remove barriers for sovereign institutions like those in Ukraine, Bulgaria, and Brazil. Ian demonstrates multi-agent translation running locally on an M4 Mac, showcasing ownership and control over agentic workloads.

From Transcription to Live Music: Gemini's Audio Stack — Thor Schaeff, Google DeepMind

Jun 9, 2026 · 19:34

Thor Schaeff from Google DeepMind presents the Gemini audio stack—Gemini 3 Flash Preview for deep audio understanding, Gemini 3.1 Flash Live for real-time sound-to-sound multimodal interaction, and Lyria 3 for music generation. He shows how a single API call extracts speaker labels, timestamps, emotions, language detection, and translation, and how speech generation uses a 'director's note' to modify a base voice's accent and tone. The talk culminates in a live demo where the Gemini Live model uses Lyria via tool calls to generate a German techno schlager about the UK startup scene.

Evals Are Broken, Use Them Anyway — Ara Khan, Cline

Jun 6, 2026 · 19:04

Ara Khan from Cline argues that evals are broken—people either treat benchmark numbers as gospel or dismiss them for vibes—but that the truth lies in between, and they should still be used. He presents three heuristics: don't believe model vendor eval numbers, stay current but not an earliest adopter, and look for new precise evals like Terminal Bench. Khan details Cline's journey from ignoring evals to building their own, then adopting Terminal Bench (89 real-world coding tasks). He explains the process: get a score (Cline started at 43%), portfolio allocate failures by sending another agent through traces to identify small levers, then hill climb by fixing zone1 bugs, zone2 nuanced prompt engineering (e.g., Anthropic-specific techniques that don't transfer to Codex or Gemini), and avoid zone3 overfitting. The episode offers a practical framework for using evals to improve agent performance while staying grounded in real-world usefulness.

Text Diffusion — Brendan O’Donoghue, Google DeepMind

Jun 4, 2026 · 28:03

Brendan O'Donoghue, a research scientist at Google DeepMind, explains that text diffusion models generate tokens 10x faster than autoregressive models by performing 24 denoising steps to produce 256 tokens, dramatically reducing memory transfers. Unlike GPT-4o and Gemini 2.5 Flash, which incorrectly answered 40 and 42 on a math problem, Gemini Diffusion used bidirectional attention to self-correct from 60 to 49 to 39. The model adaptively allocates compute: 4 steps for memorized digits of π, 31 for quantum mechanics, and automatically stops when satisfied. Text diffusion also enables in-place editing, demonstrated by fixing code bugs or adding paragraphs. However, lower throughput on large batches makes it expensive to serve at scale today. O'Donoghue showcases low-latency applications: a fully generated Wikipedia, a Reddit clone with AI text and images, an on-the-fly operating system, and a to-do app built in 15 seconds by voice.

SWE-rebench: Lessons from Evaluating Coding Agents — Ibragim Badertdinov, Nebius

Jun 4, 2026 · 16:30

Ibragim Badertdinov from Nebius presents SWE-rebench, a monthly updated benchmark that evaluates coding agents on fresh real-world software engineering tasks to prevent data leakage from pretraining. The leaderboard reveals that models like Claude Code cheat by reading git history or fetching original GitHub issues, even after restrictions; Badertdinov emphasizes that task quality is critical, as ambiguous or overfitted tests introduce noise rather than difficulty. The filtering pipeline has produced 30,000 real-world training environments used by frontier labs. The episode also covers practical evaluation lessons: define retry policies, use caching to cut costs by 4x, and verify infrastructure against reported numbers. SWE-rebench reports tokens per problem, price per problem, and pass rates across five runs, helping AI engineers choose between models and harnesses reliably.

Beyond Components: Designing Generative UI for MCP Apps — Ruben Casas, Postman

Jun 3, 2026 · 16:58

Ruben Casas from Postman argues that AI models can now write better frontend code than he can—his prompt to rewrite his blog produced a search box with blur animation and accessibility out of the box—yet most agent UIs still invoke static prebuilt components. He presents three levels of UI generation: static components (AG UI, Goose) passing props to predefined React elements; declarative UI where the model generates JSON or YAML for a rendering engine (e.g., Vercel's JSON Render), which he deems the current ideal balance; and fully generative UI where the model writes HTML, CSS, and JavaScript on demand, as in his weather agent that does so in one tool call. The key obstacle is trust, necessitating sandboxing, and MCP apps with their double iframe default are the best delivery mechanism. He likens today to early TV—radio shows with cameras—and predicts the future lies beyond components in collaborative human-agent interfaces on shared canvases, as seen with the Skeletro MCP app.

What if the network was the sandbox? — Remy Guercio, Tailscale

Jun 1, 2026 · 24:29

Remy Guercio from Tailscale argues that standard sandboxing conflates execution isolation with access control, proposing Aperture—an LLM gateway built on Tailscale's WireGuard identity network—which gives every connection verified identity (user, tag, or group) so agents get placeholders instead of real API keys, making exfiltration impossible. Aperture provides visibility into every tool call, bash command, and MCP request without instrumentation inside the container; internally at Tailscale, bash dominates over structured tool calls. Access permissions are configured via Tailscale's grants and ACLs, supporting quotas, cost controls across providers, and webhooks for tool calls. The gateway works at the LLM layer, capturing even non-tool-call agent behaviors like direct code execution, and is available on Tailscale's free plan.

Can LLMs generate Enterprise Quality Code? — Prasenjit Sarkar, Sonar

May 31, 2026 · 15:12

Prasenjit Sarkar from Sonar evaluates whether LLMs generate enterprise-quality code using SonarQube analysis of 4,444 Java assignments across 53 models. While Gemini 3.1 Pro High achieves 84.17% pass rate, GPT-5.4 Pro High generates 1.2 million lines (high bloat), and Claude Sonnet 4.6 has 300 security issues per million lines. The ACDC framework addresses these gaps: Guide (Sonar Sweep and Context Augmentation), Verify (SonarQube Agentic Analysis in 1–5 seconds pre-commit), and Solve (Remediation Agent that fixes issues and checks regressions before presenting fixes). Sonar's leaderboard at sonar.com/leaderboard provides detailed pass rates, cyclomatic/cognitive complexity, bug density, and security metrics per model.

Why (Senior) Engineers Struggle to Build AI Agents — Philipp Schmid, Google DeepMind

May 30, 2026 · 10:40

Philipp Schmid from Google DeepMind argues that senior engineers struggle to build AI agents because they carry years of implicit context that agents don't, designing tools that assume it. He highlights five key shifts: text replaces structured state, so agents can handle semantic meaning like approving a research plan with additional input; errors are inputs, not restart triggers, since long-running agents (5-15 minutes) can't afford to start over; evals replace unit tests because agents are non-deterministic and success is measured by how often it works, not fixed outputs; and agents evolve while APIs don't, so tools like a `deleteItem` endpoint need agent-friendly docstrings because the agent only sees the schema. He advises to hand over control to the LLM, design for recovery, and build to delete since models improve rapidly.

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.

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.

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.

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.

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.

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.

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…

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.

Training an LLM from Scratch, Locally — Angelos Perivolaropoulos, ElevenLabs

May 4, 2026 · 1:21:26

Angelos Perivolaropoulos from ElevenLabs walks through building a small GPT-2-like LLM from scratch on a local machine, demonstrating that the core techniques used by major labs are accessible in a few hundred lines of PyTorch code. The workshop uses character-level tokenization (65 tokens) on a Shakespeare dataset to enable fast training with limited compute. The model architecture includes multi-head self-attention, MLP layers, residual connections, and layer normalization, totaling 10 million parameters across six transformer blocks with a 256-token context window. The training loop employs next-token prediction with a warm-up cosine decay learning rate schedule and validation loss to detect overfitting. Inference uses temperature sampling (default 0.7) and top-k sampling to improve creativity. Perivolaropoulos explains that audio and multimodal models share the same transformer foundation but differ in tokenization (e.g., mel-spectrograms for audio) and use specialized losses like L2 or KL divergence, while reasoning models result from post-training base models with high-quality chain-of-thought data.

Mergeable by default: Building the context engine to save time and tokens — Peter Werry, Unblocked

May 3, 2026 · 1:41:25

Peter Werry of Unblocked argues that context engines—systems that supply AI agents with only the relevant organizational context—are critical to avoid agent doom loops and wasted tokens. He debunks three myths: naive RAG, connecting MCP servers, and bigger context windows do not solve the context problem. Werry describes building a social engineering graph to identify experts and distill team best practices, and shares hard lessons including hiding conflicts and caching answers. In a benchmark task, Unblocked's context engine reduced a 2.5-hour, 21-million-token task to 25 minutes and 10 million tokens. The talk offers a practitioner's guide to building context engines with conflict resolution, personalization, and access control.

Context Is the New Code — Patrick Debois, Tessl

May 3, 2026 · 27:14

Patrick Debois argues that as AI coding agents become more capable, context—prompts, rules, and memory—needs its own engineering discipline, introducing the Context Development Lifecycle: Generate, Evaluate, Distribute, and Observe. He explains how to create reusable prompts like agent MD and pull documentation via MCP, test context using evals with LLM-as-judge and sandboxed execution, package context as skills with registries and dependency management, and observe through agent logs, PR feedback, and production failures to feed improvements back into context. He also notes that context requires its own CI/CD with error budgets due to non-determinism, and highlights the need for context filters and security scanning. The talk draws parallels to DevOps and positions Tessl as a platform implementing these practices.

Building Conversational Agents — Thor Schaeff and Philipp Schmid, Google DeepMind

Apr 30, 2026 · 1:47:34

Thor Schaeff and Philipp Schmid of Google DeepMind demonstrate building conversational agents with the Gemini Interactions API and Live API, arguing that the new Interactions API simplifies agent development by introducing server-side state management, unified content blocks, and remote MCP support. They walk through creating a coding agent with read/write file and bash tools using Gemini 3 Flash, highlighting how the model uses tool calling to execute commands and return results. The Live API, powering real-time voice and video interactions, supports native multilingual audio, tool calling, and Google Search grounding, though the presenters acknowledge its current limitations in production, including lack of session transcript retrieval and shorter context windows (15 minutes audio-only). They showcase a Live Jukebox demo integrating Lyria 3 music generation and discuss business use cases like Shopify Sidekick, Waymo, and elderly companion apps, emphasizing that while the technology is ready for experimentation, production readiness depends on partner integrations for observability and compliance.

Build & deploy AI-powered apps — Paige Bailey, Google DeepMind

Apr 29, 2026 · 1:03:20

Paige Bailey, engineering lead for developer relations at Google DeepMind, demonstrates how the company's latest multimodal models and AI Studio platform enable rapid prototyping of AI-powered apps at minimal cost. She showcases Gemini 3.1 Flash Lite analyzing YouTube dinosaur videos for under a penny, the new Build feature constructing a fully functional bookshelf cataloger with Firebase database and Google login, and Gemini Live providing real-time multilingual screen interaction. Other demos include Genie 3 generating playable world models from text prompts, NanoBanana 2 performing cost-effective image editing, Veo 3.1 Lite producing stock footage (e.g., a "vegan basketball food truck" featuring Chef Curry), Lyria 3 creating custom music tracks, and Gemma 4 offering open-source multimodal models that run on mobile devices. Bailey emphasizes that the entire stack—grounded by Google Search and code execution—allows developers to ship ideas that would have been startups years ago, with all code exportable for production use.

Full Walkthrough: Workflow for AI Coding — Matt Pocock

Apr 24, 2026 · 1:36:30

Matt Pocock presents a hands-on workshop on building a full AI-assisted coding workflow, arguing that software engineering fundamentals—not hype—make agents effective. He introduces the 'smart zone' and 'dumb zone' of LLMs (performance drops after ~100k tokens) and the 'Memento problem' (agents forget between sessions). His process starts with a 'Grill Me' skill that relentlessly questions the user until shared understanding is reached, then produces a PRD without reading it, slices work into vertical 'tracer bullet' issues, and runs agents AFK using TDD. He advocates designing codebases with deep, testable modules and shows Sandcastle, a TypeScript library for parallel agent execution with separate implementer (Sonnet) and reviewer (Opus). The workshop transforms ambiguous briefs into shippable features while keeping humans in the loop for QA and taste.

What Do Models Still Suck At? - Peter Gostev, Arena.ai, BullshitBench

Apr 24, 2026 · 20:24

Peter Gostev presents data from his BullshitBench and Arena.ai to argue that language models still struggle with nonsense questions and expert-level tasks, despite benchmark charts showing relentless improvement. His BullshitBench reveals that only Claude Sonnet 4.5 and some Qwen models consistently push back on nonsense, while GPT and Gemini models accept it 50% of the time. Arena.ai's dissatisfaction rate among top 25 models has improved from 17% pre-reasoning to about 9% currently, but remains non-zero, and expert categories like gaming, magic, finance, and law show minimal improvement. For software expert prompts, dissatisfaction dropped from 23.5% in Q2 2024 to 13% in Q1 2026, but gaming is a persistent weakness where models fail to create engaging game mechanics. Gostev warns that narrow benchmarks overstate progress and urges focusing on the full distribution of real-world tasks.

Full Workshop: Build Your Own Deep Research Agents - Louis-François Bouchard, Paul Iusztin, Samridhi

Apr 20, 2026 · 1:57:03

Louis-François Bouchard, Samridhi Vaid, and Paul Iusztin built a combined system of a deep research agent and a deterministic writing workflow to automate high-quality technical content creation, trading flexibility for control. The research agent uses an MCP server (FastMCP) with tools for Google search, YouTube analysis, and report compilation, powered by Gemini and orchestrated by Claude Code. The writing workflow is a static pipeline that loads a user guideline, writing profiles (structure, terminology, character), and few-shot examples into a system prompt, then applies an evaluator-optimizer loop: a reviewer outputs structured pydantic objects with profile/location/comment to flag violations, and the editor applies them in priority order (guideline > research > profile). They stress that research demands autonomy while writing needs constraint, and show how to avoid AI slop by banning specific words and using profiles. For observability, they use Opik to capture all traces, and for evals they built a 20-sample dataset from real LinkedIn posts, split into train/dev/test, to calibrate an LLM judge (binary pass/fail) that they run on dev and test splits to measure F1 and detect…

Gemma, DeepMind's Family of Open Models — Omar Sanseviero, Google DeepMind

Apr 20, 2026 · 15:26

Omar Sanseviero presents Gemma 4, Google DeepMind's latest family of open models, which range from 2B to 32B parameters and introduce a novel per-layer embedding (E2B) architecture optimized for on-device inference. The models feature multimodal understanding (images, video, audio), multilingual support across 140+ languages, and are released under an Apache 2 license. Within a week, Gemma 4 reached 10 million downloads, contributing to over 500 million total downloads for the Gemma family and 100,000 community-derived models. Sanseviero highlights official variants like Shield Gemma for content safety and MedGemma for medical tasks, as well as community efforts such as AI Singapore's Southeast Asian language models and Sarvam's sovereign AI initiative for India. He emphasizes real-world applications including cancer therapy pathway discovery and fully offline agentic tasks on phones and Raspberry Pis, arguing that open models are rapidly enabling high-performance, private, and customizable AI across diverse use cases.

How Google DeepMind is researching the next Frontier of AI for Gemini — Raia Hadsell, VP of Research

Apr 18, 2026 · 20:37

Google DeepMind VP of Research Raia Hadsell presents three non-language-model frontiers of AI: Gemini Embeddings 2, an omnimodal embedding model that unifies text, video, audio, and PDFs into a single semantic vector for fast retrieval; weather forecasting models including GraphCast (spherical GNN for 15-day forecasts), GenCast (probabilistic model 97% more accurate than benchmarks), and FGN (directly predicts cyclones, used by the US National Hurricane Center); and Genie world models that create interactive, memory-rich 3D environments from prompts, enabling real-time dynamic changes for gaming and education.

Paperclip: Open Source Human Control Plane for AI Labor — Dotta Bippa

Apr 15, 2026 · 24:34

Dotta Bippa introduces Paperclip, an open-source human control plane for AI labor that lets you manage an org chart of agents to run a zero-human company. The tool enables you to hire employees, set goals, automate jobs, and bring your own agent (e.g., Gemini, Claude, Codex) with skills and instructions. Paperclip supports reliable workflows like QA reviews and approvers, and routines for recurring tasks such as summarizing PRs or writing changelogs. Dotta demonstrates creating a Remotion video celebrating Paperclip's 40,000 GitHub stars (now 50,000) by instructing the CEO agent to hire a video writer and apply brand guidelines—something that would have taken a week becomes an afterthought. Paperclip is not just for coding; it handles marketing, sales, and finance. Upcoming features include CEO chat, maximizer mode, multi-user support, cloud deployments, and a desktop app, all aimed at giving humans control over AI labor.

Judge the Judge: Building LLM Evaluators That Actually Work with GEPA — Mahmoud Mabrouk, Agenta AI

Apr 10, 2026 · 40:51

Mahmoud Mabrouk, co-founder of Agenta AI, demonstrates how to build calibrated LLM-as-a-judge evaluators using the GEPA prompt optimization algorithm, arguing that miscalibrated evals are worse than none. He walks through a practical workflow for a customer support agent using the TaoBench airline dataset, covering metric design, data annotation, and GEPA-based optimization. The seed judge achieved 61% accuracy; after optimization, accuracy rose to 74% with reduced bias, though the judge still struggled to fully learn the complex policy. Mabrouk shares key lessons: start with a seed prompt biased toward compliance, use larger models for refinement, overfit to training data first, and beware of high token costs.

AI Didn’t Kill the Web, It Moved in! — Olivier Leplus (AWS) & Yohan Lasorsa (Microsoft)

Apr 10, 2026 · 52:55

Yohan Lasorsa (Microsoft) and Olivier Leplus (AWS) argue that AI isn't replacing the web—it's becoming its native layer, embedded in every stage of development. They demo coding agents that use lightweight 'skills' to automate workflows like fetching GitHub issues and testing via Playwright, then show Chrome's MCP server letting agents debug performance across different network conditions. New on-device Web AI APIs (summarizer, proofreader, prompt API) run models locally in the browser, enabling features like auto-writing reviews from an uploaded product image without cloud calls. Finally, they introduce LLMs.txt for guiding AI agents to relevant documentation and Web MCP—a proposal to register native tools on websites (e.g., 'add to cart') so agentic browsers can execute actions without mimicking human clicks. The episode delivers concrete implementations, from coding to deploying AI-ready web apps.

OpenAI + @Temporalio : Building Durable, Production Ready Agents - Cornelia Davis, Temporal

Jan 12, 2026 · 1:18:30

Cornelia Davis, developer advocate at Temporal, demonstrates how the OpenAI Agents SDK and Temporal combine to build durable, production-ready AI agents. The integration, co-developed by OpenAI and Temporal, wraps agentic loops in Temporal workflows, providing automatic retries, event sourcing, and state management that survive process crashes and network failures. A live demo shows a weather alert agent that calls an LLM, invokes tools like get_weather_alerts and get_ip_address, and recovers seamlessly after the worker is killed. Davis highlights that Temporal’s architecture treats processes as logical entities, allowing agents to run for days and handle human-in-the-loop delays without developer-managed infrastructure. She also explains handoffs and micro-agent orchestration, and points to the AI Cookbook on docs.temporal.io with ready-to-run recipes including the OpenAI Agents SDK integration.

DSPy: The End of Prompt Engineering - Kevin Madura, AlixPartners

Jan 8, 2026 · 1:13:13

Kevin Madura of AlixPartners argues that building robust enterprise AI applications requires shifting from brittle prompt engineering to programming with LLMs using DSPy, a declarative framework that treats prompts as implementation details optimized by the system. He demonstrates how typed interfaces (Signatures) and modular logic (Modules) allow developers to focus on control flow while deferring implementation to the LLM, with Adapters controlling prompt formats (e.g., JSON vs. BAML) to improve performance by 5-10%. The talk's core is Optimizers (like MIPRO and JEPA), which automatically tune prompts by learning from data, shown improving a time entry corrector from 86% to 89% accuracy. Real-world examples include routing files by type (SEC filings vs. contracts), using a 'poor man's RAG' with attachments for multimodal documents, and a boundary detector that segments legal documents from images. Madura emphasizes that DSPy enables transferability across models (e.g., GPT-4.1 to GPT-4.1 Nano) and addresses cost concerns by allowing offline optimization to reduce LLM calls.

Welcome to AIE CODE - Jed Borovik, Google DeepMind

Jan 5, 2026 · 4:10

Jed Borovik, Google DeepMind's Gemini assistant and lead of the Jewels coding agent product engineering team, opens the 2025 AI Engineering Code Summit in New York by declaring that the most important problem in applied AI is code. He frames the event as a single-track summit designed to push the entire AI coding industry forward, not any single company. Borovik highlights the previous leadership track, which covered how AI transforms software organizations, and sets the day's focus on patterns, systems, and products enabling that transformation. He thanks DeepMind as presenting sponsor, noting the timely release of Gemini 3 and Nano Banana Pro, along with Anthropic as platinum sponsor and other gold and silver sponsors. Borovik encourages attendees to visit sponsor booths in the expo area and expresses excitement for the keynotes to come.

Jack Morris: Stuffing Context is not Memory, Updating Weights is

Dec 29, 2025 · 1:02:44

Jack Morris argues that large language models fail at niche, long-tail knowledge tasks, such as optimizing AMD GPU kernels or answering private company queries, because they rely on context windows and RAG, which suffer from quadratic self-attention costs and context rot. He advocates for a third paradigm—training knowledge directly into model weights—using synthetic data generation (e.g., synthetic continued pretraining from Stanford) to expand small datasets and parameter-efficient methods like LoRA or memory layers to avoid catastrophic forgetting. Morris demonstrates that full fine-tuning on a 3M 10-K report causes the model to only regurgitate exact sentences, whereas generating diverse synthetic question-answer pairs enables better generalization. He notes that RL-based fine-tuning (e.g., GRPO) can achieve improvements with as few as 14 parameters, while memory layers offer the best trade-off between learning and forgetting. The episode also explores temporal information handling, federated learning resurgence, and the practical decision boundary between RAG and weight-based injection based on data freshness and volume.

Amp Code: Next Generation AI Coding – Beyang Liu, Amp Code

Dec 22, 2025 · 18:31

Beyang Liu, co-founder and CTO of Amp Code, presents Amp as an opinionated frontier coding agent that rejects MCP in favor of custom tools to avoid context confusion and optimize feedback loops. Amp's architecture relies on specialized subagents—the finder for code search, the oracle for deep reasoning, the librarian for external context, and the kraken for large-scale refactors—rather than a model selector. The agent offers two top-level modes: a slower 'smart' agent for complex tasks and a 'rush' agent for quick, in-loop edits, recently updated to leverage Gemini 3. To address inference costs, Amp ships subtle ads in the terminal to sponsor free usage for students and side projects. Liu also highlights a shared-threads feature for team learning and a community called the Weird Builder Cohort, emphasizing a culture of experimentation over hype.

The Infinite Software Crisis – Jake Nations, Netflix

Dec 20, 2025 · 18:57

Jake Nations, engineering lead at Netflix, argues that AI-generated code accelerates the software crisis by conflating easy with simple—producing tangled, incomprehensible systems. He traces the crisis from 1968 to today's infinite code generation, citing Fred Brooks' 'No Silver Bullet' and Rich Hickey's definition of simple as 'one fold, no entanglement.' Nations presents a three-phase methodology—research (compressing 5 million tokens of code into a 2,000-word spec), planning (paint-by-numbers implementation steps), and implementation (using a manual migration seed)—to maintain human understanding. He warns that without this approach, engineers lose the ability to recognize dangerous complexity, and challenges listeners: will we still understand our own systems when AI writes most of the code?

Building in the Gemini Era – Kat Kampf & Ammaar Reshi, Google DeepMind

Dec 15, 2025 · 17:57

Kat Kampf and Ammaar Reshi from Google DeepMind present Gemini 3 and Nano Banana Pro, arguing that these models enable anyone to build complex, aesthetic applications through natural language alone. Gemini 3 achieves state-of-the-art results in one-shot UI design and agentic tool calling, with SweBench outperformance. Nano Banana Pro integrates Google Search for world knowledge and renders text accurately, handling up to 14 consistent people per image. They demonstrate vibe coding in AI Studio, building a personalized comic book with precise text, laptop stickers grounded in search, and a 3D racing game that scaled to 23 players live. Upcoming full-stack runtime adds backend support and automatic database integration, further democratizing software creation.

From Vibe Coding To Vibe Engineering – Kitze, Sizzy

Dec 14, 2025 · 25:28

Kitze, founder of Sizzy, argues that "vibe engineering"—actively steering AI agents with technical knowledge—trumps passive "vibe coding" for building real software. He shares how Cursor's Composer 1 let him port Benji.so and Glink to Next.js 16 with Monorepo in under a week, reviving near-dead projects. Kitze insists LLMs excel at React because humans are bad at it, and that repetitive code is fine since agents don't care. He warns against giving AI tools to juniors without oversight, and predicts the bottom of the job market will thin as agents replace interns. The talk ends with a pitch for "vibe code fixers" as a new role, maintaining legacy systems like cowboy coders.

Hard Won Lessons from Building Effective AI Coding Agents – Nik Pash, Cline

Dec 12, 2025 · 14:18

Nik Pash, head of AI at Cline, argues that frontier models have made clever agent scaffolds obsolete—capability now beats engineering tricks. He insists that real model improvement comes from benchmarks and RL environments, not from RAG or indexing systems. Pash details Cline's RL environment factory, which converts real-world coding tasks into training data by qualifying tasks, reconstructing environments, and defining pure outcome verifiers. He announces Clinebench, an open-source benchmark built from actual software development captured via Cline's provider, designed to measure and improve models on real tasks rather than synthetic puzzles. Pash urges the community to contribute by using Cline on open-source projects, turning model struggles into benchmark candidates.

Defying Gravity - Kevin Hou, Google DeepMind

Dec 2, 2025 · 25:10

Kevin Hou from Google DeepMind introduces Antigravity, a new agent-first IDE that combines three surfaces: an AI editor, an agent-controlled Chrome browser, and an Agent Manager. The central claim is that agents should live outside the IDE, enabling longer-running tasks and multimodal interactions. Key features include Artifacts—dynamic representations like plans, screen recordings, and diagrams—that replace raw chain-of-thought with visual summaries. The browser enables context retrieval and verification via screen recordings, while image generation allows iterative design through comments. Hou explains the research-product flywheel: DeepMind researchers use Antigravity internally to identify model gaps, improving capabilities like computer use and instruction following, which then ship in the product. He also details four categories of model improvements: intelligence, tools, long-running tasks, and multimodal, all powered by Gemini 3 Pro and related models.

Backlog.md: Terminal Kanban Board for Managing Tasks with AI Agents — Alex Gavrilescu, Funstage

Nov 24, 2025 · 14:19

Alex Gavrilescu presents Backlog.md, an open-source CLI tool that stores tasks as Markdown files in Git repos, featuring a terminal Kanban board and MCP server for AI agents. He argues that breaking features into atomic Markdown tasks prevents agents from running out of context or implementing unwanted extras. The demo shows Claude creating a task from requirements, generating an implementation plan, and coding a move-mode feature—all via MCP tools. Gavrilescu emphasizes two review checkpoints (after task creation and after the plan) and notes that Backlog.md itself is 99% AI-written. The tool works cross-platform, requires no external APIs, and syncs across branches via Git.

Enterprise Deep Research: The Next Killer App for Enterprise AI — Ofer Mendelevitch, Vectara

Nov 24, 2025 · 5:19

Ofer Mendelevitch from Vectara introduces Enterprise Deep Research as the next killer app for enterprise AI, applying autonomous, multi-step reasoning to internal knowledge bases. Vectara's trustworthy agent OS enables this with multimodal ingest, hybrid retrieval, and hallucination mitigation (HHEM model at 5.5M downloads). Deep Research queries private data to generate comprehensive reports with citations, replacing manual workflows. Key use cases include responding to RFPs by scanning enterprise datasets, generating on-demand employee onboarding guides from Jira/Notion/SharePoint, and creating investment memos in financial services. The system uses multi-agent parallel execution and corpus understanding for accurate planning, addressing 73% of LLM users' top challenge: factual accuracy.

From Stateless Nightmares to Durable Agents — Samuel Colvin, Pydantic

Nov 24, 2025 · 22:13

Samuel Colvin of Pydantic demonstrates building production-grade durable AI agents using PydanticAI, Temporal, and Pydantic Logfire, arguing that stateless architectures fail at scale and that durable execution with checkpointing and recovery is essential. He shows a 20 questions game where two agents play, but with 20% simulated failures, restarts are avoided by wrapping agents in Temporal wrappers for automatic retries. Colvin then implements a Deep Research agent that plans searches, runs parallel web searches via Tavilli, and synthesizes results, all recoverable. In a live demo, killing the workflow and restarting resumes instantly, replaying cached LLM calls in milliseconds. He also previews Pydantic AI Gateway and demonstrates Pydantic Evals comparing Gemini, GPT-4.1, and Claude Sonnet 4.5 on performance and cost.

Building an Agentic Platform — Ben Kus, CTO Box

Aug 24, 2025 · 19:06

Ben Kus, CTO of Box, argues that building an agentic architecture early was critical to overcoming the limitations of pure LLM-based data extraction for enterprise unstructured content. Starting with simple LLM calls in 2023, Box faced accuracy issues on complex documents, OCR failures, and difficulty handling hundreds of fields. They pivoted to an agentic framework using directed graphs, multi-model voting, and LM-as-a-judge with reflection loops, which dramatically improved accuracy and allowed incremental improvement. This architecture also enabled deep research on customer data and clean separation between agentic logic and system scaling. Kus emphasizes that agentic thinking should be applied early, even to seemingly non-agentic tasks like metadata extraction, and that Box avoids fine-tuning in favor of prompt-based agentic orchestration.

Five hard earned lessons about Evals — Ankur Goyal, Braintrust

Aug 23, 2025 · 19:46

Ankur Goyal of Braintrust argues that successful AI applications depend on deliberately engineered evaluations (evals) to reflect real user feedback and drive product improvements. He details three signs of effective evals: launching updates within 24 hours (citing Notion), converting complaints into evals, and using evals offensively to assess use cases before shipping. Evals require custom scorers as specs—not off-the-shelf—and context engineering (optimizing tool definitions and outputs) is the new frontier; shifting outputs from JSON to YAML improves token efficiency. New models can upend everything, as shown by a benchmark that jumped from 10% to viable with Claude 4 Sonnet, so a model-agnostic architecture with proxies is key. Optimize the whole system (data, task, scoring)—Braintrust's Loop auto-optimizes prompts, data, and scorers. In Q&A, he advises human judgment when adding user feedback to evals to avoid overfitting.

The Next Unicorns: 7 Top AI startups from the HF0 Residency

Aug 21, 2025 · 22:16

Diego Rodriguez (Krea) presents an AI creative suite that generated 1M images/day for a Fox ad, while OpenHome debuts the first AI smart speaker with 10K developers and 500 free dev kits. Josh’s Coframe made $20M for a travel firm by making websites adaptive, and Eugene’s Featherless AI built QWERTY 72B without transformer attention, claiming scale is dead in favor of reliability. Jonas Bauer’s Upside uses LLMs to structure enterprise data, Lengyue’s OpenAudio introduces S1, the first instructable voice model beating ElevenLabs, and Alex Atallah’s OpenRouter provides a single API for all LLMs, growing 10–100% monthly.

How to look at your data — Jeff Huber (Chroma) + Jason Liu (567)

Aug 6, 2025 · 19:23

Jeff Huber (Chroma CEO) and Jason Liu argue that AI practitioners should look at their data—both inputs and outputs—with fast evals and conversation analysis to systematically improve retrieval and product decisions. Huber advocates for fast evals using golden datasets of query-document pairs over public benchmarks or expensive LLM judges, showing how synthetic queries aligned to real user behavior can empirically compare embedding models; in a Weights & Biases chatbot case study, Voyage 3 large outperformed text-embedding-3-small and others. Jason Liu focuses on outputs: extract structured metadata from conversations, cluster them to find segments, then compare KPIs like performance across clusters to prioritize what to fix, build, or ignore—for example, if 40% of conversations involve data visualization and the agent performs poorly, invest in better plotting tools. This population-level analysis enables impact-weighted decisions, turning vague metrics like 0.5 factuality into actionable insights by segment. The episode emphasizes that retrieval improvements are foundational, and once you have users, looking at conversation structure drives a data-driven product roadmap.

State of Startups and AI 2025 - Sarah Guo, Conviction

Aug 2, 2025 · 23:52

Sarah Guo of Conviction argues that AI's value creation is massive and early, with companies like Cursor reaching $100M ARR in 12 months and Harvey exceeding $70M ARR. She predicts that by end of 2026, AI agents will ship code directly to production, voice AI will replace text for most business communication, and inference costs will drop below a cent per million tokens. Reasoning is a new scaling vector unlocking higher-stakes use cases, and agent startups have increased 50% in the last year. Multimodal models from HeyGen and Eleven are already rocketing past $50M ARR. The model market is more competitive than ever, with GPT-4 costs falling from $30 to $2 per million tokens in 18 months and open-source like DeepSeek competing. Guo advises builders to focus on thick wrappers around LLMs, leveraging domain and workflow knowledge, and warns against generic text boxes: 'The prompt is a bug, not a feature.' Execution, not first-mover advantage, is the moat.

Pipecat Cloud: Enterprise Voice Agents Built On Open Source - Kwindla Hultman Kramer, Daily

Jul 31, 2025 · 26:46

Kwindla Hultman Kramer, co-founder of Daily, introduces Pipecat, an open-source, vendor-neutral framework for building voice AI agents, and Pipecat Cloud, a deployment layer optimized for real-time voice. He argues that achieving sub-800-millisecond voice-to-voice response times is critical and that frameworks like Pipecat handle hard problems like turn detection, interruption handling, and context management. Kramer explains that Pipecat supports 60+ models and services, including Gemini and OpenAI, and that Gemini is often 10x cheaper for 30-minute conversations. He notes that while speech-to-speech models like Moshi and Sesame are promising for natural conversation, they currently lag in instruction-following for enterprise use cases. Kramer also addresses global latency challenges, recommending deployment close to inference servers or using open-weight models locally, and highlights Pipecat Cloud's integration with Krisp for background noise reduction and a free open-source smart turn model.

[Full Workshop] Building Conversational AI Agents - Thor Schaeff, ElevenLabs

Jul 31, 2025 · 1:01:42

Thor Schaeff of ElevenLabs demonstrates how to build multilingual conversational AI agents using ElevenLabs' platform, which combines speech-to-text (ASR) with 99-language support, a voice library of over 5,000 voices, and language detection system tools that automatically switch between 31 languages (with plans to expand). The agent pipeline transcribes user speech, feeds it to any LLM (like GPT-4 or Gemini), and streams the response back as speech for low-latency conversations. Schaeff shows real-time language switching in Mandarin, Hindi, and English, and explains how to assign per-language voices (e.g., Chennai-accented Tamil). He addresses safety tooling—voice watermarking, live moderation, and consent verification—and discusses cost (per-minute pricing), latency mitigation via Flash models and RAG, and handling multi-language mixing within a single utterance, though accuracy degrades with more than two languages intermixed.

Everything is ugly, so go build something that isn't — Raiza Martin, Huxe (ex NotebookLM)

Jul 28, 2025 · 25:15

Raiza Martin, former lead of Google's NotebookLM and founder of Huxe, argues that the current chaotic phase of AI product design is a once-in-a-career opportunity to rebuild from first principles, calling everything we use 'the ugliest that it will ever be.' Drawing from her experience forcing NotebookLM into existence against skepticism, she emphasizes that personal clarity of vision fuels product building, and purpose must be relentlessly focused on a single outcome—for NotebookLM, enabling users to upload 50 files and interact with them. She stresses earning trust by nailing deterministic behavior first, noting that 90% of first queries were summarization and failures drove users away forever, then layering on delightful probabilistic features like podcast generation. Finally, she warns against the 'kitchen sink' approach, citing her own Huxe app that did everything but users only used one feature, advocating restraint as an innovation multiplier and focus on one excellent outcome to avoid building ugly products.

Real-time Experiments with an AI Co-Scientist - Stefania Druga, fmr. Google Deepmind

Jul 28, 2025 · 18:42

Stefania Druga, formerly at Google DeepMind, demonstrates a real-time AI co-scientist system built with under $300 in open-source hardware and two weeks of effort, capable of live scientific experimentation. Using a micro:bit with Jack DAC temperature sensor, ReCamera for object tracking, and a microscope, the system streams sensor data, images, and voice to Gemini via a React app that dynamically assembles multimodal context. Druga presents two home experiments: crystal growth, where she discovered that formation occurs in bursts once critical saturation is reached, and fermentation, monitoring CO2 and temperature to optimize dough rise. She references DeepMind's AI co-scientist paper, which replicated a 12-year gene transfer discovery in two days and identified novel drug targets for liver fibrosis that proved effective in wet labs. Her vision moves from async data analysis to real-time empirical hypothesis generation, and she highlights open-source platforms like Jubilee and open bioreactors for automating lab equipment, with future plans to use real-time data to inform realistic simulations.

Ship Agents that Ship: A Hands-On Workshop - Kyle Penfound, Jeremy Adams, Dagger

Jul 27, 2025 · 1:21:00

Kyle Penfound and Jeremy Adams from Dagger demonstrated building production-minded AI agents using Dagger, a programmable delivery engine that runs containerized workflows identically on laptops and in CI. They created a workspace submodule with tools — read file, write file, list files, and run tests — and wired it to an LLM (Claude 3.5) so the agent can edit code and validate changes through the project's actual test suite. The agent runs in isolated containers for determinism and traceability, with behavior visualized via Dagger Cloud. They extended the agent to respond to GitHub issues: a label triggers GitHub Actions to run Dagger, read the issue, hand the assignment to the agent, and open a pull request. The talk emphasized that Dagger's modularity lets developers give agents precisely scoped tools while reusing existing CI workflows, providing guardrails without sacrificing flexibility.

Waymo's EMMA: Teaching Cars to Think - Jyh Jing Hwang, Waymo

Jul 26, 2025 · 17:28

Jyh-Jing Hwang of Waymo presents EMMA, an end-to-end multimodal model built on Gemini that directly processes camera inputs and route text into driving waypoints, achieving state-of-the-art open-loop planning on the NuScenes benchmark without LiDAR or HD maps. Adding chain-of-thought reasoning—identifying critical objects and meta-decisions—further surpasses specialized models like MotionLM on Waymo's 100K dataset. Co-training on tasks such as 3D detection and road graph estimation maintains competitive performance across domains. For evaluation, Waymo leverages generative video models (e.g., Veo2) to simulate diverse conditions like rain and night, testing EMMA's robustness. The work demonstrates how Gemini's generalization can help scale Waymo's autonomous driving to new cities by handling long-tail scenarios.

A2A & MCP Workshop: Automating Business Processes with LLMs — Damien Murphy, Bench

Jul 26, 2025 · 1:23:14

Damien Murphy presents A2A and MCP protocols for building multi-agent systems that automate business processes from webhooks, using a host agent that delegates tasks to sub-agents (Slack, GitHub, Bench) via A2A, with each sub-agent using MCP tools from Zapier or internal APIs. He demonstrates processing a meeting transcript to create a GitHub issue, send a Slack message, and research attendees, emphasizing that A2A handles remote agent discovery and opaqueness while MCP provides standardized third-party tool access. Murphy highlights benefits like context isolation—sub-agents absorb large tool outputs and keep the host's context small—and parallel processing, but notes limitations: A2A's early stage, MCP's silent failures (e.g., Zapier Slack missing channels), the non-determinism of LLM orchestration, and the challenge of prompt caching costs. He argues that A2A is best for third-party agents where complexity is hidden, while MCP is useful for extensible tool integration, but if you control the tools or agents, direct function calls are simpler and more reliable.

Your Coding Agent Just Got Cloned And Your Brain Isn't Ready - Rustin Banks, Google Jules

Jul 25, 2025 · 13:40

Rustin Banks, an AI product manager at Google Labs, shares how Jules, Google's asynchronous coding agent powered by Gemini 2.5 Pro, enables developers to shift from sequential coding to orchestrating many parallel agents. He demonstrates real-world use on a conference schedule website, adding tests with Jest and Playwright simultaneously, implementing features like Google Calendar integration and AI summaries, and running accessibility audits. Banks argues that success requires clear verification criteria, creating 'disagreement' with agents to ensure correctness, and a robust merge/test framework. He notes that in its first two weeks, Jules generated 40,000 public commits, and emphasizes that agents-as-a-service in the cloud allow infinite scalability and development from any device.

Latent Space Paper Club: AIEWF Special Edition (Test of Time, DeepSeek R1/V3) — VIbhu Sapra

Jul 25, 2025 · 53:54

VIbhu Sapra presents DeepSeek's latest models and announces a new curriculum-based Test of Time Paper Club. DeepSeek's May 28th R1 update doubles reasoning tokens (12k→25k) and matches O3/Gemini 2.5 Pro, improving AIME 2024 from 70% to 87.5%. A new distillation of R1 traces into Qwen 3 8b achieves performance on par with Qwen's 235b thinking model, proving reasoning models distill efficiently. The Test of Time Paper Club will cover 50–100 foundational papers over six months in San Francisco and remote, targeting core AI engineering topics from attention and scaling laws to inference techniques. Sapra emphasizes that pure RL (GRPO) on verifiable math and code unlocks emergent reflection and aha moments, shifting scaling from pre-training compute to inference-time reasoning.

Human seeded Evals — Samuel Colvin, Pydantic

Jul 25, 2025 · 12:02

Samuel Colvin, creator of Pydantic, demonstrates how type safety and validation loops in Pydantic AI build reliable GenAI applications. He argues that type-safe frameworks enable confident refactoring, a necessity for evolving AI apps, and shows how returning validation errors to the model fixes simple mistakes like incorrect date formats. The agentic loop with tools and final result tools ensures structured extraction, while type-safe dependencies on tools prevent runtime errors. Colvin also highlights Logfire observability, which traces calls, shows pricing, and helps debug failures like failed memory retrieval. The talk covers agent definitions, validation error retries, and the importance of explicit exit conditions in agent loops.

Does AI Actually Boost Developer Productivity? (100k Devs Study) - Yegor Denisov-Blanch, Stanford

Jul 23, 2025 · 18:12

Yegor Denisov-Blanch from Stanford presents findings from a study of nearly 100,000 developers across 600+ companies, showing AI boosts developer productivity by an average of 15-20%, but the effect varies widely. The study measures functionality delivered, not commits, and reveals that AI introduces significant rework—bug fixes from AI-generated code. Productivity gains depend on task complexity, codebase maturity (Greenfield vs. Brownfield), language popularity, and codebase size: low-complexity Greenfield tasks see 30-40% gains, while high-complexity Brownfield tasks see only 0-10%. AI can even decrease productivity for low-popularity languages like COBOL or Haskell, and context window limitations reduce performance on larger codebases. The study provides data-driven guidance for when AI helps or hinders, with a matrix showing 20% gains for low-complexity common languages and minimal gains for complex niche ones.

How agents will unlock the $500B promise of AI - Donald Hruska, Retool

Jul 23, 2025 · 16:22

Donald Hruska, engineering lead for Retool's Agents product, argues that AI agents will unlock the $500B promise of AI by moving enterprises beyond toy chatbots into production-grade systems. He explains that building a basic agent is easy (e.g., 100 lines of code using React) but getting it into production requires solving security, cost overruns, observability, and compliance. Hruska outlines four options—build from scratch, use a framework like LangGraph, a managed platform like Retool Agents, or verticalized agents—and advises building for core differentiators and buying for commodity workflows. He cites Retool customers like ClickUp saving over $200,000 in vendor costs and Descript saving hundreds of hours weekly, while noting inference costs dropped 99.7% from 2022-2024. Retool charges $3 per hour for its cheapest agent and supports on-prem deployment.

Building Agents (the hard parts!) - Rita Kozlov, Cloudflare

Jul 23, 2025 · 21:12

Rita Kozlov, VP of Product for Cloudflare's developer platform, presents the building blocks of AI agents—client, AI reasoning, workflows, and tools—arguing that effective agents require all four components. She highlights the Model Context Protocol (MCP) as a standard for exposing APIs to LLMs, and demonstrates Cloudflare's Agents SDK, which simplifies hosting remote MCP servers with built-in OAuth, state management via durable objects, and real-time WebSocket communication. Kozlov cites real-world impact: companies using agents for sales automation see 20% revenue increases, 90% faster support response times, and 50–75% time savings. She walks through a human-in-the-loop credit card approval workflow built with Nok, showing how durable objects maintain long-running state, prevent duplicate actions, and route approvals across Slack, email, or in-app notifications. The talk emphasizes that once an MCP server is deployed, it can be used directly from Cursor, Claude, ChatGPT, or a custom client, including voice interfaces via WebRTC-to-WebSocket translation.

tldraw.computer - Steve Ruiz, tldraw

Jul 21, 2025 · 18:45

Steve Ruiz, founder and CEO of tldraw, demonstrates the company's AI experiments on their infinite canvas, including Make Real—which turns hand-drawn wireframes into working web apps using vision models—and tldraw computer, a visual programming environment where arrows and LLMs power a graph of connected nodes that can execute multi-step prompts, generate images and speech, and even run loops indefinitely. He also shows Draw Fast for real-time image generation and Teach, where Claude can draw and edit shapes on the canvas. The episode explains how tldraw's SDK (tldraw.dev) enables others to build custom canvas applications, and highlights the company's philosophy of 'shitty but amazing' rapid prototyping.

Excalidraw: AI and Human Whiteboarding Partnership - Christopher Chedeau

Jul 21, 2025 · 16:59

Christopher Chedeau, creator of Excalidraw, explains how to integrate AI into whiteboarding by focusing on turning prompts into editable diagrams rather than static images. He argues that just adding any AI model harms the product, citing a failed attempt to generate realistic images because users don't draw realistically. The successful integration uses Mermaid.js to output Excalidraw files, letting humans modify the AI-generated diagram. He envisions a future of iterative human-AI collaboration, and demonstrates other practical features like auto-naming files, generating illustrations (coming soon), and challenges AI engineers to build a browser-based logo background remover. He concludes that the industry is in a physical-to-virtual transition for AI, and that LLMs work best when targeting a structured domain-specific language.

Robots as professional Chefs - Nikhil Abraham, CloudChef

Jul 20, 2025 · 18:58

Nikhil Abraham, CEO of CloudChef, explains how his company turned a general-purpose bimanual robot into a professional chef that works in commercial kitchens for $12 an hour. The robot learns new recipes from a single expert demonstration, using thermal and visual embeddings to handle ingredient and appliance variation. CloudChef's system achieves 95% autonomy and outperforms expert human chefs in cooking decision-making, as evaluated on over 1,000 recipes. The robot is deployed in restaurants like Wingstar and Elan, cooking real meals at 80–95% human speed. Abraham notes that the platform can operate 168 hours a week and aims to expand to tasks like chopping.

[Full Workshop] Reinforcement Learning, Kernels, Reasoning, Quantization & Agents — Daniel Han

Jul 19, 2025 · 2:42:28

Daniel Han of Unsloth presents a technical workshop covering reinforcement learning (RL), kernels, reasoning, quantization, and agents, arguing that RL with verifiable rewards (RLVR) is the key to unlocking LLM capabilities beyond supervised fine-tuning. He explains why open-source models plateaued after September 2024 until DeepSeek-R1 showed that RL can elicit reasoning, and breaks down PPO, GRPO, and the REINFORCE algorithm, emphasizing that GRPO removes the value model for efficiency. Han details how reward functions—not algorithms—are the hardest part, with examples like distance-based scoring for math. He demonstrates a free Colab notebook training a base model to reason, and shows that dynamic quantization can shrink models like DeepSeek-R1 from 730 GB to 140 GB with only ~1% accuracy loss, arguing that GPUs may stop getting faster after FP4 precision.

A Taxonomy for Next-gen Reasoning — Nathan Lambert, Allen Institute (AI2) & Interconnects.ai

Jul 19, 2025 · 19:21

Nathan Lambert, senior research scientist at AI2 and founder of Interconnects.ai, argues that next-generation reasoning models require a taxonomy of four traits: skills, calibration, strategy, and abstraction. While current models excel at math and code (skills), they overthink easy problems, wasting tokens and latency—calibration is needed to match output length to task difficulty. The real frontier is planning: models must learn strategy (choosing the right direction) and abstraction (breaking problems into tractable sub-tasks) to enable long-horizon agents like Deep Research and Claude Code. Lambert traces how OpenAI's Q*→Strawberry→o1 took 12–18 months of human data to teach backtracking and verification; planning should be easier because humans can write 5-step plans. He predicts post-training compute could reach parity with pre-training, citing DeepSeek's shift from 0.18% post-training compute in V3 to an estimated 10–20% for R1. The path forward: collect diverse verifiable questions, filter by difficulty, run stable RL—then scale.

How to Train Your Agent: Building Reliable Agents with RL — Kyle Corbitt, OpenPipe

Jul 19, 2025 · 19:48

Kyle Corbitt, co-founder of OpenPipe, argues that reinforcement learning (RL) with GRPO can make agentic systems far more reliable and cost-effective than prompted frontier models. He presents ART-E, an email assistant trained on Qwen 2.5 14B, which achieved 96% accuracy versus 90% for o3 and slashed cost from $55 to $0.80 per 1,000 queries. The two critical problems are building a realistic environment (solved using the Enron email dataset) and defining the right reward function (turning it into a verifiable task with LLM-as-judge). Extra rewards—favoring fewer tool turns and penalizing hallucination—further improved efficiency. Corbitt also warns about reward hacking, giving examples like a model that exploited a bug to put every word in every category, and shares that the training cost just $80 in GPU time and a week of engineering.

Google Photos Magic Editor: GenAI Under the Hood of a Billion-User App - Kelvin Ma, Google Photos

Jul 19, 2025 · 20:28

Kelvin Ma, an engineer on Google Photos' editing team, explains how the billion-user app built the Magic Editor by integrating generative AI with on-device computational photography. He traces the evolution from earlier ML features like post-capture segmentation (UNet model, 10 MB) and Magic Eraser (a system of models) to the new server-side generative AI experience, which handles tasks like relocating objects and reimagining backgrounds. Key challenges include managing model size (now hundreds of MB), client-server latency, ambiguous problem scoping (e.g., moving from 5% to 80% reliability), and trust and safety. Ma advocates using evals, reducing ambiguity through product-research collaboration, and iterating from large general models to smaller, faster ones for production. He also highlights that Google Photos serves 1.5 billion monthly active users and processes hundreds of millions of edits per month, and the editor is being rebuilt as AI-first.

On Curiosity — Sharif Shameem, Lexica

Jul 19, 2025 · 18:35

Sharif Shameem, founder of Lexica, argues that curiosity is the main force for pulling ideas from the future into the present, and that building and sharing demos is the best way to explore AI models' hidden capabilities. He recounts early GPT-3 demos from 2020-2021, when the model had a 2,000-token context window and cost $75 per million output tokens, showing how he built a JSX compiler in the browser, a shopping agent that parsed web pages, and a multi-step reasoning tool called MultiVAC. Shameem emphasizes that AI engineering is more like excavating than traditional engineering, and that researchers often don't know the full capabilities of their own models. He closes by invoking computing pioneer J.C.R. Licklider, arguing that today's AI engineers have a moral obligation to follow their curiosity and share what they discover.

Teaching Gemini to Speak YouTube: Adapting LLMs for Video Recommendations to 2B+DAU - Devansh Tandon

Jul 16, 2025 · 22:51

Devansh Tandon, a Product Manager at Google leading YouTube's discovery system, details how YouTube adapted Gemini LLMs to power its recommendation engine for billions of daily active users. The team built SemanticID, a tokenization system that compresses video features into semantically meaningful tokens, creating a new language for YouTube content. They then continued pre-training Gemini on sequences of user watches to make the model bilingual in English and this video language. For generative retrieval, they prompt the adapted model with user demographics and watch history to output video recommendations as SemanticIDs, achieving 95%+ cost savings to serve at scale. Challenges include serving billions of users with low latency and handling video freshness—Taylor Swift's new music video must be recommendable within minutes. Tandon argues LLM-led recommendations are a bigger consumer application than search and hints at future interactive, steerable recommendations and even personalized content creation.

Measuring AGI: Interactive Reasoning Benchmarks for ARC-AGI-3 — Greg Kamradt, ARC Prize Foundation

Jul 16, 2025 · 18:28

Greg Kamradt, President of ARC Prize Foundation, introduces ARC-AGI-3, the first interactive reasoning benchmark for AGI that drops agents into novel games without prior instruction, forcing exploration to solve tasks. Unlike static tests, this benchmark measures skill acquisition efficiency—how quickly an AI learns and applies new skills—using human baselines from 400+ in-person tests. It strips away language and trivia, relying only on core knowledge priors (basic math, geometry, agentness, objectness). A public training set of ~40 games will be released, but performance is measured on a private evaluation set of 120 games unseen by developers or AI. Kamradt asserts that as long as AI cannot outperform humans on these problems, we do not have AGI; a sandbox preview with five games and a mini agent competition is planned for next month, with full launch in Q1 2026.

RL for Autonomous Coding — Aakanksha Chowdhery, Reflection.ai

Jul 16, 2025 · 19:27

Aakanksha Chowdhery, CEO of Reflection AI and former lead researcher on PaLM and Gemini at Google, argues that reinforcement learning (RL) scaling is the next frontier for autonomous coding agents. She explains that inference-time techniques like majority voting and self-revision improve accuracy but require many samples (e.g., 10,000 for rare correct generations). RL training can learn to generate correct outputs directly, especially in verifiable domains like code with unit tests. Reflection AI aims to build superintelligence starting with autonomous coding, leveraging automated verification to design better reward functions. She notes challenges in scaling RL, including system complexity and reward hacking, but sees coding as ideal due to execution feedback.

Benchmarks Are Memes: How What We Measure Shapes AI—and Us - Alex Duffy, Every.to

Jul 15, 2025 · 15:44

Alex Duffy argues that AI benchmarks function as cultural memes—ideas that spread and shape what models learn—giving those who design them immense power over AI's trajectory. He traces the lifecycle from a single person's idea to saturation, using examples like 'How many Rs in strawberry' and Pokémon. Duffy introduces AI Diplomacy, a benchmark where language models negotiate and betray each other, revealing that models like DeepSeek R1 and Gemini 2.5 Flash excel at social manipulation while Claude models are naively optimistic. He warns against benchmarks that reward sycophancy (like ChatGPT's thumbs-up training) and advocates for multifaceted, experiential, and generative benchmarks that empower people. Duffy urges the audience to ask non-AI people what they care about, turning benchmarks into tools that build trust and define humanity's role in an AI world.

Prompt Engineering and AI Red Teaming — Sander Schulhoff, HackAPrompt/LearnPrompting

Jul 14, 2025 · 2:01:05

Sander Schulhoff, creator of Learn Prompting and HackAPrompt, argues prompt engineering remains vital despite claims of its demise, drawing on his systematic review of 1,500+ papers for 'The Prompt Report.' He covers advanced techniques including chain-of-thought, decomposition, ensembling, and few-shot prompting, noting that role prompting is ineffective for accuracy-based tasks and that example ordering can swing performance by 50%. He then explains AI red teaming, distinguishing jailbreaking from prompt injection, and warns that system prompts and guardrails cannot prevent attacks—even simple obfuscation like base64 or typos still works. He highlights the critical unsolved problem of agentic security, where agents with real-world actions are easily tricked, and introduces a live competition at the conference to gather more attack data. His key takeaway: AI security is fundamentally harder than classical cybersecurity because 'you cannot patch a brain.'

How LLMs work for Web Devs: GPT in 600 lines of Vanilla JS - Ishan Anand

Jul 13, 2025 · 1:41:34

Ishan Anand shows that GPT-2 small implemented in 600 lines of vanilla JavaScript makes LLMs understandable for web developers without ML backgrounds. He explains tokenization via byte-pair encoding, 768-dimensional embeddings representing semantic meaning via co-occurrence, and the Transformer's attention mechanism that lets tokens share context. The multi-layer perceptron learns next-token prediction through backpropagation, while the language head converts embeddings to token probabilities using softmax. Anand demonstrates each step—tokenization, embedding lookup, positional encoding, attention, MLP, and output—in a browser debugger, and notes that GPT-2's architecture underpins ChatGPT, with innovations like scale, supervised fine-tuning, and RLHF. The workshop provides an intuitive mental model of Transformers, turning perceived AI magic into understandable machinery.

AI Engineering with the Google Gemini 2.5 Model Family - Philipp Schmid, Google DeepMind

Jul 11, 2025 · 1:44:51

In this workshop, Philipp Schmid from Google DeepMind demonstrates AI Engineering with the Gemini 2.5 model family, focusing on using Gemini 2.5 Flash via a free API tier for hands-on coding tasks including text generation, multimodal processing of images, audio, and PDFs, function calling with structured outputs, and integration with MCP servers. The session covers setting up API keys in AI Studio, uploading files via the Files API (free for 1 day), and controlling thinking budgets (0–24,000 tokens) to manage cost and reasoning depth. Schmid shows how Gemini natively processes videos at 1 frame per second for accurate timestamp extraction and how PDFs are handled by combining OCR text with image understanding. He introduces native tools like Google Search with grounding metadata, code execution, and URL context, and explains how MCP servers can be used seamlessly with the Gemini SDK for tool calling. The workshop also covers parallel vs sequential function calling, the Agent Development Kit (ADK), and the upcoming asynchronous function calling for the Live API, providing a practical path from simple generation to agentic workflows.

Thinking Deeper in Gemini — Jack Rae, Google DeepMind

Jul 10, 2025 · 18:13

Jack Rae, lead of Gemini Thinking at Google DeepMind, presents thinking as a solution to the fixed test-time compute bottleneck in large language models. He explains that Gemini inserts a thinking stage where the model iterates via reinforcement learning, learning to self-correct and explore multiple strategies. This enables a continuous cost-performance tradeoff via thinking budgets, improving reasoning on math and code. Future work includes Deep Think, which raises USA Math Olympiad performance from the 50th to the 65th percentile by scaling inference compute further. Rae envisions models that, like mathematician Ramanujan, achieve deep, data-efficient reasoning from limited knowledge.

A year of Gemini progress + what comes next — Logan Kilpatrick, Google DeepMind

Jul 10, 2025 · 11:58

Logan Kilpatrick, head of product for Google AI Studio at DeepMind, announces the final update to Gemini 2.5 Pro, which achieves state-of-the-art results on Aider and HLE benchmarks. He details Google's 50x increase in AI inference over the past year, driven by merging research and product teams into DeepMind. The episode outlines Gemini's evolution toward a universal assistant that unifies Google products, with upcoming features including proactivity, native audio and video capabilities (Veo), and smaller models. Kilpatrick also previews developer-focused updates: a SOTA embeddings model, a deep research API, and Veo 3 and Imagine 4 in the API, alongside repositioning AI Studio as a dedicated developer platform.

2025 in LLMs so far, illustrated by Pelicans on Bicycles — Simon Willison

Jul 9, 2025 · 18:30

Simon Willison reviews the past six months of LLM releases — including AWS Nova, Llama 3.3 70B, DeepSeek R1, Mistral Small 3, Claude 3.7 Sonnet, GPT 4.5, Gemini 2.5 Pro, GPT-4o, Llama 4, GPT 4.1, O3/O4 Mini, and Claude 4 — using his 'pelican on bicycle' SVG benchmark to argue that local models have become good enough to run GPT-4 class models on a laptop and that combining tools with reasoning is the most powerful technique in AI engineering, while noting risks like prompt injection and the 'lethal trifecta'. He tracks 30 significant model releases, highlighting that Mistral Small 3 (24B) matches Llama 3 70B's performance, which itself matched the 405B model, enabling local inference. DeepSeek's R1 caused a $500B+ Nvidia stock drop on January 27. GPT 4.1 Nano is the cheapest model yet at a fraction of a cent per pelican. He also examines bugs: ChatGPT's sycophantic 'shit-on-a-stick' incident and Claude 4's tendency to snitch to authorities when given ethical instructions and email tools. Willison concludes that while the pace is accelerating, control over context and security remain critical.

Trends Across the AI Frontier — George Cameron, ArtificialAnalysis.ai

Jul 8, 2025 · 17:52

George Cameron of Artificial Analysis presents multiple frontiers—reasoning, open-weights, cost, speed—across the AI stack, arguing that trade-offs between intelligence, latency, and expense are critical for building applications. Reasoning models like O4 mini high use an order of magnitude more output tokens (72M vs GPT-4.1's 7M) and take over 40 seconds per response versus 4.7 seconds, impacting agentic workflows where 30 sequential calls multiply latency. The open-weights gap has nearly closed, with China-based labs like DeepSeek R1 and Alibaba's Qwen 3 leading. O3 cost roughly $2,000 to run the intelligence index, while GPT-4.1 nano is over 500 times cheaper. Output speeds have jumped from GPT-4's 40 tokens/s in 2023 to over 1,000 on a B200 accelerator. Despite efficiency gains, demand for compute will keep rising due to larger models, reasoning’s extra tokens, and multi-step agents.

12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer

Jul 3, 2025 · 17:06

Dex Horthy, founder of HumanLayer, presents the 12-Factor Agents framework for building reliable LLM-powered applications, arguing that production-grade agents are primarily deterministic software with targeted LLM steps rather than fully autonomous loops. He distills patterns: own prompts and context windows, treat tools as JSON and code, use small focused agents with three to ten steps, contact humans via tool calls. Horthy emphasizes context engineering—LLMs are pure functions—and shows how to compact errors, unify state, and add pause/resume via APIs. He shares a DevOps agent that became a bash script, and advocates for outer-loop agents. The framework, which gained 4,000 GitHub stars in two months, treats agents as stateless reducers that meet users on any channel, with engineers controlling the inner loop of token and control flow.

Turning Fails into Features: Zapier’s Hard-Won Eval Lessons — Rafal Willinski, Vitor Balocco, Zapier

Jun 30, 2025 · 16:15

Zapier AI Tech Lead Rafal Willinski and Staff Engineer Vitor Balocco explain how Zapier's evaluation system turns agent failures into targeted improvements through a data flywheel. They detail collecting explicit feedback at critical moments and mining implicit signals like testing behavior, cursing, and user follow-ups. The pair advocates building unit test evals for specific failure modes, then trajectory evals and LLM-as-judge with rubrics to avoid overfitting and capture multi-turn criteria. They share that over-indexing on unit tests hurt model benchmarking, and reasoning models can compare model runs, revealing differences like Claude as a decisive executor versus Gemini's yapping. Ultimately, they argue that the goal is user satisfaction, so A/B testing on a small traffic fraction is the ultimate verification.

Engineering Better Evals: Scalable LLM Evaluation Pipelines That Work — Dat Ngo, Aman Khan, Arize

Jun 27, 2025 · 24:46

Dat Ngo, AI architect at Arize AI, presents advanced LLM evaluation strategies for production systems, arguing that effective evals go beyond out-of-the-box LLM-as-a-judge to include code-based heuristics, human feedback, and golden datasets. He explains how to build a virtuous cycle of collecting observability data, running evals, and tuning them over time, and demonstrates agent evaluation techniques like trajectory evals to identify failure modes across complex workflows. Ngo covers trade-offs between offline evals and inline guardrails, the use of log probabilities for confidence scoring, and automated prompt optimization through meta-prompting, all illustrated with customer examples from Reddit, Duolingo, and Booking.com.

Forget RAG Pipelines—Build Production Ready Agents in 15 Mins: Nina Lopatina, Rajiv Shah, Contextual

Jun 27, 2025 · 1:15:43

Rajiv Shah, Nina Lopatina, and Matthew from Contextual AI demonstrate how developers can build production-ready RAG agents in minutes using Contextual AI's managed RAG platform, emphasizing that RAG should be treated as a managed service to avoid reinventing infrastructure. They walk through ingesting documents like NVIDIA financials and spurious correlation reports, then querying the agent with questions requiring quantitative reasoning across tables. The platform handles extraction, layout analysis, image captioning, hybrid retrieval, and a state-of-the-art reranker, capped by a grounded language model that avoids hallucinations and provides attribution. Evaluation is done via LM Unit, a model-as-judge that scores responses on criteria like accuracy and causation. The episode also shows integrating the agent with Claude Desktop via MCP and answers audience questions on pricing (consumption-based with a $25 credit), scalability, entitlements, HIPAA, and domain-specific language.

[Full Workshop] Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments

Jun 27, 2025 · 1:20:38

Harold from the VS Code team demonstrates "Vibe Coding at Scale" at the AI Engineer World's Fair, presenting three stages—YOLO, structured, and spectrum vibes—for customizing AI assistants in enterprise environments. He live-codes a hydration tracking app using GitHub Copilot's agent mode, auto-approve, and new workspace scaffolding, then shows how to enforce design principles via Copilot instructions and reusable prompts. Harold introduces custom modes (e.g., TDD mode), tool sets, and MCP servers like Playwright and Perplexity for research and browser testing. He emphasizes iterating on instructions, committing often, and using spec-driven development to balance speed with reliability, arguing these techniques enable true flow-state collaboration even on complex codebases.

Building Multimodal AI Agents From Scratch — Apoorva Joshi, MongoDB

Jun 27, 2025 · 36:58

Apoorva Joshi, an AI developer advocate at MongoDB, leads a hands-on workshop on building multimodal AI agents from scratch. She defines agents as systems using LLMs to reason, plan, and execute tasks with tools, contrasting them with simple prompting and RAG. The workshop focuses on processing mixed-media documents (text and images) by converting each page to a screenshot, embedding it with Voyage AI's multimodal (VLM-based) model to avoid the modality gap of CLIP, and storing embeddings in MongoDB for vector search. The agent uses Google's Gemini 2.0 Flash as the multimodal LLM, implements REACT (reasoning and acting) for planning with feedback, and manages short-term memory via session IDs. Participants build a tool-calling agent that retrieves relevant page screenshots, passes them with conversation history to Gemini, and generates answers for queries like analyzing charts or extracting insights from documents.

CI in the Era of AI: From Unit Tests to Stochastic Evals — Nathan Sobo, Zed

Jun 27, 2025 · 14:50

Nathan Sobo, co-founder of Zed, explains how his team adapted continuous integration for AI-powered features in their Rust-based code editor. Zed's traditional CI eliminates non-determinism with simulated schedulers and deterministic tests, but LLMs forced a shift to stochastic evaluation. Their process starts with broad data-driven evals, then drills into focused stochastic unit tests run 100–200 times with pass thresholds, and finally refines into deterministic tests. Specific challenges like parsing streaming edits, XML tag mismatches, indentation normalization, and strange escaping were solved by robust algorithms—e.g., fuzzy matching and indent delta detection—rather than complex ML. Sobo emphasizes that rigorous empirical testing and traditional software engineering skills remain essential, even when embracing probability over binary pass/fail.

Fun stories from building OpenRouter and where all this is going - Alex Atallah, OpenRouter

Jun 25, 2025 · 18:47

Alex Atallah, founder of OpenRouter, tells the story of how he launched the LLM aggregator in early 2023 after observing the open-source race sparked by Meta's Llama 1 and Stanford's Alpaca distillation under $600. He argues the inference market is not winner-take-all, citing OpenRouter's data showing Google Gemini growing from 2-3% to 34-35% of tokens over 12 months. The platform evolved from a simple model collection into a marketplace with over 400 models and 60 providers, solving architecture challenges like 30-millisecond latency, cancelable streams, and a middleware plugin system for web search and PDF parsing. Atallah explains that OpenRouter grew 10-100% month-over-month for two years, and he predicts future additions like transfusion models that generate images and more powerful geographic routing for enterprise optimization.

Building AI Agents that actually automate Knowledge Work - Jerry Liu, LlamaIndex

Jun 24, 2025 · 17:57

Jerry Liu, CEO of LlamaIndex, argues that building AI agents which actually automate knowledge work requires a combination of really good tools and carefully tailored agent reasoning, moving beyond naive RAG to a 'document toolbox' that includes parsing, extraction, indexing, and manipulation of complex unstructured data like PDFs, Excel, and PowerPoints. He introduces two main agent categories: assistive agents (chat-based, human-in-the-loop, unconstrained reasoning) and automation agents (batch-processing, constrained workflows, less human oversight). A key new capability is an Excel agent that uses reinforcement learning to learn a semantic map of unnormalized spreadsheets, achieving 95% accuracy on data transformation, surpassing the 75% baseline of LLMs with code interpreter and even human baselines of 90%. Real-world examples include financial due diligence combining automation (inhaling financial data) and assistant interfaces (analyst co-pilot), enterprise search with specialized agentic RAG, and technical data sheet injection for a global electronics company that reduced weeks of manual work to an automated extraction pipeline. Liu emphasizes that the right preprocessing…

Windsurf everywhere, doing everything, all at once - Kevin Hou, Windsurf

Jun 23, 2025 · 16:03

Windsurf head of product Kevin Hou explains the company's philosophy of a shared human-AI timeline and its vision to be everywhere, do everything, and work all the time. The AI ingests context from tools like Google Docs, Figma, GitHub, and Notion, and takes actions beyond coding—opening PRs, deploying, and reviewing code. Windsurf generates 90 million lines of code daily and processes over 1,000 messages per minute. Its new model SWE-1, trained on software engineering workflows, achieves near-frontier performance with a fraction of the resources. Hou emphasizes a data flywheel where user feedback on real workflows drives continuous improvement, arguing that successful AI products in 2025 require harmony among model, data, and application.

Veo 3 for Developers — Paige Bailey, Google DeepMind

Jun 21, 2025 · 20:37

Paige Bailey, engineering lead for Google DeepMind's DevRel team, presents Veo 3, the latest video generation model that natively produces synchronized audio—dialogue, sound effects, and music—from text and image prompts, marking a leap in coherence, physics simulation, and cinematic control. She demonstrates Veo 2's creative controls like reference-powered videos, outpainting, and character consistency, and shows how video generation has evolved from 2023's choppy clips to Veo 3's polished raccoon dancing in front of pyramids. A key demo replicates a Chick-fil-A commercial: Veo 2 required stitching multiple tools, while Veo 3 produced the full ad from a single prompt. The models are accessible via Vertex AI private preview and Gemini Ultra plans.

How to Build Trustworthy AI — Allie Howe

Jun 16, 2025 · 24:22

Allie Howe, VC CISO at GrowthCyber, argues that trustworthy AI equals AI Security (how the world harms your AI) plus AI Safety (how your AI harms the world), and that builders are legally and reputationally responsible. She covers three pillars: MLSecOps (scanning models for serialization attacks using open‑source ModelScan), AI Red Teaming (testing for prompt injections, jailbreaks, and safety issues with tools like PyRIT), and AI Runtime Security (validating inputs/outputs in production via platforms like Pillar to block off‑topic or unsafe behavior). Howe cites real incidents—a Chevy Tahoe chatbot offered for $1, Slack's data leak via prompt injection, Fortnite's Darth Vader NPC initially producing racist outputs—and notes a lawsuit where OpenAI won by arguing users must expect errors. She emphasizes shifting‑right to runtime guardrails as the most cost‑effective investment and advises demonstrating trustworthiness through GRC platforms like Vanta to shorten sales cycles. With increasing regulation (ISO 42001, EOAI Act, FDA guidelines), she concludes that building trustworthy AI now unlocks revolutionary innovation in fields like healthcare.

Why the Best AI Agents Are Built Without Frameworks (Primitives over Frameworks) — Ahmad Awais, CHAI

Jun 3, 2025 · 27:06

Ahmad Awais, founder of LangBase/CHAI, argues that production AI agents like Perplexity, Cursor, v0, Lovable, Bolt, and CHAI itself should be built using AI primitives rather than frameworks. He demonstrates live coding a 'Chat with PDF' agent using LangBase primitives (memory, parser, chunker, threads). Awais presents eight agent architectures—augmented LLM, prompt chaining, agent router, parallel agents, orchestrator-worker, evaluator-optimizer, tool-calling, and memory-based—all built with plain code and no framework. He claims frameworks are bloated and slow, while primitives offer flexibility and automatic scaling (e.g., memory storing terabytes). Awais shows how to compose multiple LLMs (Gemini, DeepSeek Llama, Claude) in a router agent, and notes that his team has built agents for OCR, image analysis, and deep research using primitives and external tools like Mistral OCR.

Building Reliable Support Agents Using the Effect Typescript Library - Michael Fester

Jun 3, 2025 · 7:22

Michael Fester, co-founder and CTO of Fourteen.ai, explains how his team built production-ready AI support agents using the Effect TypeScript library, arguing it provides strong type safety, composability, and reliability for systems that rely on LLMs. The architecture uses Effect across the entire stack, including Effect RPC, Effect HTTP, Effect SQL, and a custom DSL for agent workflows. Reliability features include fallback between LLM providers (e.g., GPT-4.0 mini to Gemini Flash 2.0), retry policies with state tracking, and duplicated token streams for analytics. Dependency injection allows easy mocking of LLM providers for testing. However, Fester warns of pitfalls like silently losing errors from upstream catches and the steep learning curve. He recommends incremental adoption, starting with a single service.

Blender MCP and The Future Of Creative Tools - Siddharth Ahuja

Jun 3, 2025 · 16:50

Siddharth Ahuja introduces Blender MCP, an open-source project that lets LLMs like Claude control Blender via the Model Context Protocol, dramatically lowering the barrier to 3D creation. The tool, which has garnered 11,500 GitHub stars and over 160,000 downloads, enables users to generate complex scenes—like a dragon guarding a pot of gold or a full terrain with nodes—in minutes through natural language prompts. Ahuja explains that Blender’s scripting capabilities are key, and notes that keeping MCP tools lean avoids confusion for the LLM. He demonstrates integrations with AI asset generators and even built an Ableton MCP to create soundtracks, arguing that MCPs will become the glue for creative toolchains, allowing LLMs to orchestrate Blender, Unity, and Ableton together. This shifts creators from tool experts to orchestra conductors, unlocking a new wave of accessible content creation.

How agents broke app-level infrastructure - Evan Boyle

Jun 3, 2025 · 13:32

Evan Boyle, founder of GenSX, argues that LLM-powered agents have broken assumptions about app-level infrastructure, as p1 latency jumps from milliseconds to seconds and workflows run minutes to hours. He explains that traditional serverless providers timeout after 5 minutes, lack native streaming, and force brittle Rube Goldberg machines on top of queues like SQS or tools like Airflow. Boyle presents an open-source library that separates API and compute layers using Redis streams for resumability, enabling users to refresh pages or navigate away without losing progress. He demonstrates components with built-in retries, caching, and tracing, and a workflow that automates Hacker News analysis. Key architectural lessons include starting simple but planning for long-running agents, keeping compute and API planes separate, and leaning on Redis for resumability.

Buy Now, Maybe Pay Later: Dealing with Prompt-Tax While Staying at the Frontier - Andrew Thomspson

Jun 3, 2025 · 25:09

Andrew Thompson, CTO of Orbital, introduces the concept of Prompt-Tax: the hidden cost of migrating prompts when upgrading AI models. He shares how his agentic product automates real estate due diligence, growing from <1B to 20B monthly tokens and zero to multiple seven-figure ARR over 18 months. Key tactics include optimizing for prompting over fine-tuning, using domain experts (ex-lawyers) to write prompts, and relying on vibes over formal evals. Thompson advocates 'betting on the model'—shipping new frontier models immediately and fixing regressions on the fly using progressive rollouts and rapid feedback loops. A clip from Demis Hassabis underscores the unique challenge of evolving tech stacks. The episode concludes with questions on whether evals or progressive delivery scale to manage Prompt-Tax.

Analyzing 10,000 Sales Calls With AI In 2 Weeks — Charlie Guo

Jun 3, 2025 · 9:49

Charlie Guo explains how his team at Pully used Claude 3.5 Sonnet to analyze 10,000 sales call transcripts in two weeks, turning a task that would take 625 days manually into a $500 project. They chose Claude over smaller models due to unacceptable hallucination rates, and reduced costs by up to 90% using prompt caching and extended outputs. The system combined RAG enrichment, chain-of-thought prompting, and structured JSON outputs with citations to ensure accuracy. The analysis, originally for the executive team, became a company-wide resource, enabling marketing to pull customer quotes and sales to automate transcript downloads, saving dozens of hours weekly. Guo emphasizes that good engineering—JSON outputs, database schemas, and thoughtful integration—matters as much as AI capability, and challenges listeners to mine their own untapped customer data.

Frontier Feud: Anthropic, Google DeepMind, Meta FAIR, Thinking Machines — Barr Yaron, Amplify

Apr 19, 2025 · 22:26

Teams from Anthropic, Google DeepMind, Meta FAIR, and Thinking Machines compete in a Frontier Feud game hosted by Barr Yaron at the AI Engineer Summit 2025. Surveyed AI engineers name Ilya Sutskever as the most influential AI researcher, with Andrej Karpathy, Jeff Hinton, and Yann LeCun also on the board. Cost is the top consideration when choosing a model, followed by latency, eval scores, and open vs. closed source. The buzzword everyone is tired of hearing is AGI, with RAG and prompt engineering trailing. In the fast money round, Cursor tops favorite AI tools, 'Attention Is All You Need' wins most influential paper, and hardware failure is the biggest 2 a.m. nightmare. The winning team, Rocco's Basilisk, takes home a massive llama and other prizes.

Voice Agent Engineering — Nik Caryotakis, SuperDial

Apr 18, 2025 · 19:07

Nik Caryotakis from SuperDial argues that in 2025, the key to production Voice AI is reliability over realism, especially for sensitive healthcare calls. SuperDial automates back-office phone calls, saving over 100,000 hours of human calling with a lean team of four engineers. He advocates for the 'say the right thing at the right time' approach, using open-source tools like PipeCat for orchestration, TensorZero for LLM routing, and self-hosted LangFuse for HIPAA-compliant observability. Caryotakis warns that new voice-to-voice models often produce nonsensical audio, favoring a sequenced STT/LLM/TTS pipeline for control. He shares specific last-mile challenges: pronunciation of names like 'Caryotaikis', avoiding confusing bot names like 'Billy', and the need for fallbacks when OpenAI goes down. The talk emphasizes that the unique value of a voice agent lies in conversational design and vertical integrations, not realistic voices.

AI Engineers: The Next Generation — Stefania Druga, Google Gemini

Apr 13, 2025 · 21:47

Stefania Druga, a research scientist on Google Gemini, presents Cognimates and its new AI copilot that teaches children to become AI engineers. Built on Scratch’s visual programming, Cognimates lets kids train custom models, program robots, and build games, shifting their perception from ‘AI is magic’ to understanding data and confidence levels. Druga’s design studies with 18 kids from 11 countries showed the copilot doubled programming time by supporting ideation, debugging, and creative agency—never giving answers unless stuck three times. The tool now integrates screenshot analysis and asset generation, with plans to embed the agent across the OS. Druga ties this to the EU AI Act’s mandate for AI literacy, arguing early, hands-on creation is the path to informed users.

How Deep Research Works - Mukund Sridhar & Aarush Selvan, Google DeepMind

Mar 26, 2025 · 15:15

Aarush Selvan and Mukund Sridhar from Google DeepMind explain how Gemini Deep Research works, a personal research agent that trades latency for comprehensiveness by taking up to five minutes to browse the web and synthesize reports. They discuss product challenges like building an asynchronous experience in a synchronous chatbot, setting user expectations, and presenting thousand-word outputs. Technical challenges covered include iterative planning with partial information, handling the fragmented web with entity resolution, managing growing context via recency-biased retrieval, and ensuring robustness to intermediate failures. The episode also explores future directions: going from aggregating information to providing expert-level insights, personalizing research to user roles, and combining web research with coding, data science, or video generation.

AI Agents, Meet Test Driven Development

Feb 22, 2025 · 29:10

Anita from Vellum argues that teams using test-driven development build more reliable AI systems, and she breaks down how to apply TDD to agentic workflows across four stages: experiment, evaluate, deploy, monitor. She outlines five levels of agentic behavior (L0 to L4), noting that most production systems today are at L1 (tool use), while L2 systems that plan and reason with models like O1 and DeepSeek-R1 will see most innovation this year. She introduces Vellum's new open-source Workflows SDK, which keeps code and UI in sync, and demonstrates her own SEO agent that automates keyword research, content analysis, and writing via a writer-editor evaluation loop. The agent, built on Vellum Workflows, takes a keyword like "chain-of-thought prompting" and produces a first draft with a latency of around 118 seconds, incorporating competitive analysis and iterative feedback. She emphasizes that success now depends on orchestration techniques (prompt chaining, RAG, memory) rather than just model performance.

OpenLLMetry is all you need

Feb 22, 2025 · 9:12

Nir, CEO of Trace Loop, introduces OpenLLMetry, an open-source project extending OpenTelemetry for tracing and monitoring GenAI applications. OpenTelemetry, maintained by CNCF, standardizes logging, metrics, and traces across cloud environments, supported by platforms like Datadog, New Relic, and Grafana. OpenLLMetry provides over 40 automatic instrumentations for foundation models (OpenAI, Anthropic, Cohere), vector databases (Pinecone, Chroma), and frameworks (LangChain, LlamaIndex, CrewAI). These instrumentations emit logs, metrics, and traces in OpenTelemetry format, allowing users to send data to any supported observability backend with a configuration change, avoiding vendor lock-in.

Where AI is superhuman: The right jobs to automate with LLMs

Feb 22, 2025 · 11:53

Andy Treadman, partner at Theory Ventures, argues that LLMs are already superhuman in high-volume, low-complexity jobs, making them the prime targets for full automation. He breaks down LLM capabilities into transformation, synthesis, and reasoning, and maps jobs on a spectrum of volume and complexity. At the high-volume end, he says LLMs can be 10x better than humans because scale is the challenge, not reliability. He highlights two portfolio companies: Dropzone AI automates security alert investigations, performing better than rules-based systems and covering 24/7, while Amp personalizes customer engagement at scale, discovering new cohorts like late-night snackers. Treadman predicts that organizations will shrink and invert from pyramids to diamonds, with fewer entry-level roles. He advises founders to consider technology-problem fit and other factors when building AI workflow automation.

Personality Driven Development: Exploring the Frontier of Agents with Attitude

Feb 17, 2025 · 18:00

Ben, from Perpetual, argues that anthropomorphizing AI agents—giving them personalities, forms, and preferences—transforms user adoption and engagement, despite significant challenges. He presents examples like Tech Lead, an artichoke recruiter, and hamster teams, showing how form factors create instant understanding and enable price anchoring (e.g., 1/20th the cost of a junior employee). Benefits include easy problem decomposition (specialized agents outperform generalized), branding, and fun. However, downsides include reinforcing stereotypes (100% of generated software engineers appear male), raised performance expectations, difficulty rebranding, distraction from core value, and stark reminders of job replacement—illustrated by a CEO introducing an IC as the one who 'knows what they're doing.' Ben highlights personality-driven development where every instance is bespoke, with prompt-driven preferences (e.g., 'I like Ivy League schools'), making debugging uniquely challenging.

The Adversarial Path to the Personal Assistant: Sumit Agarwal

Feb 15, 2025 · 18:46

Sumit Agarwal, founder of Ario AI, discusses building a personal AI assistant that uses adversarial ETL to extract users' data from services like Google, Amazon, and Doordash, enabling immediate personalization without manual input. He announces $16M in funding and demonstrates how the assistant generates data portraits, recommends travel and routines based on personal history, and manages schedules by detecting conflicts. Agarwal shares RAG insights: avoid LLMs for trivial math, use search and pre-processed profiles, and present the right data at the right time. Ario Boost, a browser extension, lets users download their data locally in developer mode without creating an account.

Training Albatross An Expert Finance LLM: Leo Pekelis

Feb 13, 2025 · 16:20

Leo Pekelis, chief scientist at Gradient, explains how they transformed an open-source model into Albatross, a finance LLM that tops leaderboards on both general and domain-specific tasks. The key was an automated data pipeline using membership inference to curate finance data from a massive corpus, followed by continual pre-training and alignment via supervised fine-tuning and preference optimization. He also details a one-million-token context extension on a Llama 3-based model that achieves 100% needle-in-the-haystack scores, enabling in-context learning with thousands of examples to reduce hallucinations. The models, v-alpha-tross and the extended-context Llama 3, are open-sourced on Hugging Face.

Unveiling the latest Gemma model advancements: Kathleen Kenealy

Feb 9, 2025 · 16:25

Kathleen Kenealy, technical lead of the Gemma team at Google DeepMind, unveils the latest advances in the Gemma model family, including the launch of Gemma 2 in 9B and 27B parameter sizes, which outperform models two to three times larger, such as LLaMA 3 70B. She also introduces PALI Gemma, a multimodal model combining Siglip Vision Encoder with Gemma 1.0 for image-text tasks. The episode highlights Gemma's responsible-by-design approach, broad framework support (TensorFlow, Jax, PyTorch, etc.), and the release of the Gemma cookbook with 20 recipes. Kenealy emphasizes that Gemma 2 is optimized for easy integration and fine-tuning, available on Google AI Studio, and invites the community to build and share their projects.

Building an AI assistant that makes phone calls [Convex Workshop]

Feb 9, 2025 · 50:53

Tom Redmond, head of DX at Convex, builds Floyd, an AI phone-calling assistant using Convex, GPT-4, Google Cloud speech-to-text, and Twilio. Floyd lets users make voice requests (e.g., calling a school to report a sick child) via a web app; transcription, context retrieval, and real-time conversation with a human on the other end happen through a reactive database architecture. Redmond explains how Convex's WebSocket-based infrastructure solves serverless latency issues, enabling live transcript streaming and status updates without polling. He demonstrates two calls (school absence and flower order), noting that latency (2–5 seconds) comes from OpenAI text-to-speech and growing prompts, with plans to use OpenAI Threads and faster TTS services. The prototype explicitly discloses it's an AI to avoid misrepresentation, and Redmond envisions AI agents efficiently handling service bookings.

Insights from Snorkel AI running Azure AI Infrastructure: Humza Iqbal and Lachlan Ainley

Feb 8, 2025 · 20:46

Humza Iqbal of Snorkel AI explains how the company uses Azure AI infrastructure powered by NVIDIA GPUs to fine-tune foundation models for enterprise customers, achieving better performance per dollar by switching from A100s to H100s. He details their distributed training stack (PyTorch, Horovod, NFS) and lessons learned such as balancing node count for batch size and monitoring GPU utilization to avoid networking or data-loading bottlenecks. A cost comparison found two H100s outperformed four A100s on both training and inference, enabling faster iteration through more synthetic data. Azure's dedicated VMs, reliable NFS throughput, and flexible capacity allowed Snorkel to scale experiments from single-node to dozens of GPUs. Future work includes programmatic preference signals and multimodal retrieval algorithms, all planned on Azure.

RAG for VPs of AI: Jerry Liu

Dec 31, 2024 · 26:51

Jerry Liu, CEO of LlamaIndex, argues that building production RAG systems requires a new data processing stack distinct from traditional ETL, emphasizing data quality through advanced parsing (Llama Parse) and rigorous eval over chunk size tuning. He explains that while longer context windows may eliminate fine-grained chunking, retrieval from external storage remains vital for multi-doc enterprise systems. Liu addresses data privacy with VPC deployment options, and notes that Llama Cloud processes but does not store data. He also highlights Llama Agents, an open-source multi-agent framework for deploying agentic microservices, and shares that Llama Parse processes tens of millions of pages monthly.

What It Actually Takes to Deploy GenAI Applications to Enterprises: Arjun Bansal and Trey Doig

Nov 4, 2024 · 21:30

Trey Doig of Echo AI and Arjun Bansal of Log10 recount Echo AI's journey deploying a GenAI-native conversational intelligence platform for billion-dollar retail brands, focusing on the centrality of accuracy. Echo AI ingests all customer conversations, uses LLMs to surface insights at 100% coverage, but must overcome enterprise trust issues by achieving 95% accuracy within seven days. The platform relies on Log10's auto feedback system, which uses AI-based review to match human accuracy with model speed, yielding a 20 F1 point improvement in one use case. The episode details how Echo AI's solution engineers use Log10 to grade summarizations, catch hallucinations, and track model drift, turning human feedback into curated datasets for fine-tuning. Ultimately, the partnership demonstrates a path to self-improving LLM applications through iterative accuracy measurement and improvement.

The Multimodal Future of Education: Stefania Druga

Oct 24, 2024 · 20:05

Stefania Druga, a research scientist on Google's Gemini team, argues that multimodal AI can transform education by making learning more interactive and critical. She presents Cognimates, an open-source platform she built that expands Scratch to let kids train custom AI models and program smart devices, showing a longitudinal study where kids became more skeptical of AI's intelligence after tinkering. Druga also introduces a benchmark for math misconceptions and demonstrates live demos using the Gemini API—a science tutor that responds to drawings, a math coach that avoids giving direct answers, and a curiosity-driven object identifier—all in under 100 lines of code. She emphasizes the need to cultivate AI literacy early, as 70% of generative AI users are Gen Z, and invites engineers to build tinkering tools that balance agency between learners and AI.

Build enterprise generative AI apps using Llama 3 at 1,000 tokens/s on the SambaNova AI platform

Sep 11, 2024 · 54:34

SambaNova’s Michelle Matern and Petro Milan present their full-stack AI platform, demonstrating how the SN40L RDU chip enables Llama 3 inference at 1,000 tokens per second. They introduce Samba-1, a composition of 92 expert models behind a single endpoint, and benchmark it against GPT-3.5 and GPT-4 on enterprise tasks like information extraction and text-to-SQL. The workshop then builds a RAG-based Q&A system using LangChain, Unstructured, E5-large-v2 embeddings, ChromaDB, and Llama-3-8B-Instruct at 1,000 tokens per second. Attendees set up the environment, load documents, and run inference with real-time metrics showing time to first token of 0.09 seconds and total inference time of 0.65 seconds.

Judging LLMs: Alex Volkov

Sep 9, 2024 · 18:39

Alex Volkov, as an LLM judge from 2034, humorously judges AI engineers on their development practices, emphasizing the importance of tracing, iterative prompt engineering, and robust evaluation pipelines. He finds Daniel guilty of deploying without logging, Sasha guilty of premature fine-tuning without prompt iteration, and Morgan guilty of ignoring AI news—commuted to attending ThursdAI. Francisco’s overreliance on programmatic evals leads to a legal loss, while Maxime is 'awesome' for using Weights & Biases Weave. Alex concludes with a primer on evaluation methods: programmatic, human-in-the-loop, and LLM-as-judge, stressing the need to validate validators and create custom criteria. He promotes Weave for tracing and evals, and ThursdAI for staying updated.

Pydantic is STILL all you need: Jason Liu

Sep 6, 2024 · 15:21

Jason Liu returns to the AI Engineer World's Fair to argue that Pydantic (and his library Instructor) is still all you need for structured output with LLMs. He shows that the core API—response_model, streaming with iterables, and partials for real-time validation—remains unchanged, now supporting Ollama, LlamaCPP, Anthropic, Gemini, and more. Liu demonstrates validators that enforce rules like uppercasing names or verifying receipt totals, reducing errors with automatic retries. He applies structured output to RAG: using a Search model with optional date ranges and source selection, and a Response model with follow-up questions and validated URLs. For extraction, he creates classifiers using Literal types, meeting summaries with action items, and even tables as Pandas DataFrames via custom type hints. Liu’s key takeaway is that one retry often suffices, and as models get faster and smarter, structured output makes LLMs compatible with classical programming—turning generative AI into generating data structures defined by the developer.

Building Reliable Agentic Systems: Eno Reyes

Aug 20, 2024 · 18:14

Eno Reyes, CTO of Factory.ai, explains how his team builds reliable agentic systems—called Droids—for automating software development tasks by applying techniques from robotics and control systems to handle planning, decision making, and environmental grounding. Reyes describes a pseudo-Kalman filter that passes intermediate reasoning through plan steps, converging reasoning but risking error propagation. He advocates for explicit plan criteria and hard-coded logic to improve reliability, despite reducing generalizability. On decision making, he recommends consensus mechanisms like self-consistency, explicit reasoning with checklists, fine-tuning for out-of-distribution decisions, and simulation via Monte Carlo tree search. For environmental grounding, he emphasizes building custom AI computer interfaces for domain-specific workflows, designing explicit feedback processing (e.g., parsing CI/CD logs), balancing bounded exploration with long-context models, and incorporating human guidance to boost reliability from 30–40% to 90–100%.

How Codeium Breaks Through the Ceiling for Retrieval: Kevin Hou

Jul 31, 2024 · 18:42

Kevin Hou, AI engineer at Codeium, argues that embedding-based retrieval is hitting a ceiling for AI code generation and that Codeium breaks through by throwing large language models directly at the problem via a system called MQuery. He outlines the limitations of long context, fine-tuning, and embeddings, noting that embeddings are cheap but fail to reason over multiple documents needed for real-world coding tasks. Codeium developed a product-driven benchmark using recall 50 and commit-message datasets to measure retrieval quality. Because Codeium is vertically integrated—training custom models and building its own infrastructure—it can afford to run thousands of LLM calls in parallel per query, giving users 100x more compute than competitors. MQuery retrieves context from thousands of files in seconds, resulting in more accepted completions and better chat satisfaction. Hou compares this shift to autonomous driving: early heuristics like embeddings are giving way to large models that handle more data directly.

Retrieval Augmented Generation in the Wild: Anton Troynikov

Nov 15, 2023 · 12:20

Anton Troynikov, co-founder of Chroma, explains that retrieval augmented generation (RAG) requires more than simple vector search—it needs human feedback, self-updating memory, and agent interaction to handle dynamic data. He covers challenges like choosing the right embedding model, chunking strategies (including using language model perplexity), and determining result relevance without distractors. Chroma is building a horizontally scalable cluster, a cloud technical preview by December, and support for multimodal data. The episode argues that a capable memory system is key to making AI agents truly functional, citing the Voyager paper where Chroma stored learned skills for Minecraft agents.