GPT

One Designer + AI. Hundreds of Deliverables. — Vincent Wendy, AI Engineer

Sep 10, 2026 · 16:48

Vincent Wendy, the sole senior creative designer at AI Engineer, explains how he alone designs for a conference that grew to 7,000 attendees, 140+ sponsors, 300+ speakers, and 600+ sessions. His five-part method—build the foundation first, make designs reusable, automate workflows, validate output, and remove friction—starts with a tightly defined design system so LLMs like Devin and GPT cannot invent their own font sizes, letting marketing build emails and flyers from the website alone. Room schedules once laid out by hand in Figma now pull fresh from live data via Devin, export to PNG, and ship to screens on a flash drive. A generator produces pixel-perfect announcement graphics and trading cards for all 300 speakers, and Devin matches photographers' shots to the right speaker, like identifying Jason Liu. Devin also caught every missing sponsor logo on the 140-plus-logo lobby banner and the conference t-shirt, and added an edit button to the schedule tool the morning one was needed—so with tools no longer the constraint, having a real problem is the advantage.

How long can your skills be before your agent forgets what you told it? — Laurie Voss, Arize AI

Sep 9, 2026 · 22:26

Laurie Voss, head of developer relations at Arize AI and co-founder of npm, argues the 200-instruction ceiling for skills files collapsed 10x in a year. Rerunning the IFScale benchmark, which asks a model to write a report containing exact words and counts how many appear, he replicated last year's 200-to-300 drop, then watched current models ace it. He had to raise the test from 500 words to 10,000 before anything broke: the boundary now sits near 2,000 instructions, closer to 5,000 for the best. Failures diverged: DeepSeek forgets, Claude refuses when random words trip its safety filter, Gemini overthinks and answers nothing, and GPT-5.5 writes half a report then calls the request stupid. Compression is solved; verification—checking outputs with evals—is now the hard part.

From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS

Aug 28, 2026 · 20:57

Clare Liguori, Senior Principal Engineer at AWS, says Amazon's frontier development teams achieved step-function productivity gains by deliberately changing how they work with Kiro, its agentic coding assistant. In a 50-team pilot, half improved under 3x in deployment velocity and the other half hit a median 4.5x; the difference was habits, not tools. She defines frontier developers as writing 1-2% of their code, letting agents run for hours, and running multiple agents in parallel. The five habits: invest in agent context, slow down to speed up by refactoring brownfield codebases, feed agents specifications instead of babysitting them, make intent explicit, and shift testing left with deterministic mocks. She also warns that new bottlenecks emerge, like decision speed and burnout.

Preferences Over Benchmarks: Model Routing — Archana Kamath & Tyler Gillam, DigitalOcean

Aug 22, 2026 · 15:54

DigitalOcean's Archana Kamath and Tyler Gillam argue that no single best AI model exists, so choosing models by benchmark leaderboards is the wrong instinct; the right model depends on the request's task, cost, latency, system prompts, and end-user preferences. They demo their open-source inference router, built into DigitalOcean's AI-native cloud, which uses a purpose-built mixture-of-experts model to decide in under 200 milliseconds, costs nothing extra, and needs no code changes. In a live coding-agent comparison, the router matched premium quality while spending 14 cents versus 44 cents over a session and scored 90% correctness versus Opus's 95% with fewer tokens and faster speed. They frame routing as a foundation layer for evals, caching, and personalization, with no vendor lock-in.

Scaling Compute on Context — Jack Morris, Engram

Aug 12, 2026 · 19:42

Jack Morris of Engram frames scaling compute on context as the pursuit of depth in AI, contrasting it with the breadth of public-data pre-training. He argues models trained on public data know nothing about your emails, meetings, or company, and that with a fixed private corpus, compute is the only scalable axis. He critiques naive fine-tuning (loss 0.00001 on 10K financial reports then collapse), KV compaction, on-policy distillation, and synthetic continued pretraining, noting each hits a synthetic data wall. The goal is self-improvement like AlphaGo, where better models generate harder training questions, enabling indefinite compute scaling on your context.

How Codex Works — Dominik Kundel, OpenAI

Aug 10, 2026 · 20:55

Dominik Kundel, an OpenAI engineer, explains the internals of the Codex agent harness, which is open source under Apache 2 and written in Rust. He details how context construction caps available skills at 2% of the context window and uses deferred tools with tool search to manage size and cost. For actions, Codex relies on an apply patch tool for file edits, a shell tool with ripgrep, and sandboxes: seatbelt on macOS, bubblewrap on Linux, and a custom open-source Windows sandbox. To reduce approval fatigue, an auto-review subagent with read-only permissions judges actions against user authorization and risk taxonomies. Speed improvements come from websocket mode in the responses API, which sends only changed items instead of full state, crucial when GPT 5.3 Codex Spark hit 1,000 tokens per second on Cerebras. Long-horizon goals work via a continuation prompt until the model calls an update goal tool, favoring concrete verifiable objectives, and auto compaction maintains performance…

Benchmarking Coding Agents on New vs Legacy Codebases — Denys Linkov, Wisedocs

Aug 8, 2026 · 18:08

Denys Linkov of Wisedocs, whose medical-claims ML pipeline ran across ten legacy repos, argues his team's six-month monorepo refactor was worthwhile even as coding agents improve fast. A refactor task that took o3 three hours and ten major mistakes now takes about one-fifth the time: Sonnet 4.6 needed one extra iteration, Opus 4.8 nearly one-shot it. Yet GPT 5.5 extra high 'completed' the job in 10 minutes 22 seconds, writing 2,000 lines of scaffolding with models missing and admitting no deployment or bootstrap command. So Linkov reads METR's task-length curve at 80-90% success, not 50%; an hour-long agent run at coin-flip odds wastes the hour and your attention. The payoff was social too: commit velocity never flattened, months-long features ship in under a week, and developers now volunteer across the monorepo.

Open Source Is Dead. Long Live Open Source. — Saoud Rizwan, Cline

Aug 7, 2026 · 17:30

Saoud Rizwan, founder of Cline, argues that AI has killed the community side of open source while open weights models win on economics. He cites Zig banning AI from PRs, curl weighing shutdown of its bug bounty over AI-generated reports, and tldraw auto-closing pull requests, plus a LiteLLM compromise that stole credentials for three hours. Rizwan makes the case that closed labs' subsidized subscriptions lead to lock-in and price gouging, while open models like GLM match or beat Opus on cost and code quality — GLM used twice the tokens at half the cost and fixed a real Cline bug that Opus's faster fix left broken. He compares open weights to Facebook's Open Compute project and urges American labs to release open weights before foreign models become the standard.

The State of Model Routing — NVIDIA, Cognition, OpenRouter

Aug 6, 2026 · 48:17

Cognition's Walden Yan, OpenRouter's Alex Atallah, NVIDIA's Tanay Varshney and Carter Abdallah argue routing should orchestrate frontier and cheaper models, not per-task benchmark picks; Devin Fusion cuts Fable-level intelligence cost by 40%. Yan: task-type routing is fragile because a session shifts from codebase question to feature request to live debugging; Devin keeps a frontier model planning while a cheap sidekick executes. Atallah: OpenRouter's auto router sat unused for two years until OpenClaw heartbeats every ten minutes created an app with two intelligence needs; out-of-distribution, small models thrash: Opus scores three times better at a tenth of Haiku's cost on terminal bench. Varshney cites jagged capabilities for up to 10% higher accuracy; Abdallah adds local/cloud routing.

Rethinking Environments for Long-Horizon Work — Rayan Garg, Theta Software

Aug 1, 2026 · 21:15

Rayan Garg and Gurveer of Theta Software argue that progress on long-horizon AI agents depends on environment and verifier design, not benchmark headlines. They define long horizon via METR-style human time thresholds, such as 50% success on tasks taking humans 16 hours, alongside noisy model units like tokens and steps, and say real difficulty comes from sequential complexity—where a bad early query cascades—rather than artificially chained subtasks. They explain why soft verifiable work needs judge models with detailed rubrics, and why judges must be agents themselves: able to inspect final environment state (e.g. GitHub/CloudWatch logs) with read-only permissions, query long trajectories through sub-agents, and avoid collapsing valid solution spaces. They critique finance benchmarks GDPVal, ToolBench, and Apex agents for average human hours far below METR thresholds, saturation, narrow breadth, and weak reward signals. Theta's own finance tasks average 15 human hours across a 50-task sample, take models long trajectories, and still require mean@5 evaluation.

Scaling to Long Horizons — Ross Taylor & Chengxi Taylor, General Reasoning

Jul 31, 2026 · 18:07

Ross Taylor and Chengxi Taylor, co-founders of London-based RL company General Reasoning, argue that scaling to long horizons demands a mindset shift and better simulation, not just bigger context windows. Ross recounts how Galactica's 2022 thinking tokens were prescient, but its base-model demo backfired, while RLHF made LLMs products; his Meta team's PPO with verifiable rewards worked, but DeepSeek-R1 later showed better base models were key. Chengxi details long-horizon obstacles: sparse rewards, credit assignment, and 1M token limits, solved by value models that reduce variance and enable bootstrapping. Kelly Bench gave frontier models $100K to trade Premier League matches; all lost money, exposing how little current environments simulate real competition. Pipeline RL trades off off-policy staleness (8 steps okay) against GPU utilization, and they point to openreward.ai, with 350+ environments, for long-horizon RL.

Your Finance Agent's Bottleneck Is You — Ramana Siddanth Emani, Auditoria AI

Jul 30, 2026 · 13:42

Ramana Siddanth Emani, data scientist at Auditoria AI, argues that the bottleneck in shipping production finance agents is the developer in the loop, not the model or GPUs. He presents harnessing coding agents across parallel git worktrees (50 with 48GB RAM) to automate bug fixes from QA and Jira tickets, with sub agents pulling traces, logs, running tests, and creating PRs, needing human input only at task assignment and final verification. In the finance sector, regulation demands human oversight, so agents handle the grind while developers focus on verification. Emani advocates for recursive self-improvement where agents analyze bottlenecks and upgrade loops; after a month, a developer can simply type 'fix this bug' and the agent handles everything, allowing developers to step out of the loop while remaining final verifiers.

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.

State of Data — Sean Cai, Independent / State of Data

Jul 26, 2026 · 18:22

Sean Cai argues data markets, not compute, are now the binding constraint for turning generalist AI into expert systems, with the supply chain unbundling from vertical giants into specialist vendors. He distinguishes Type I (real workflow capture) from contrived Type II data, noting the industry sells Type II as Type I. He introduces Verifier's Law—ease of training proportional to task verifiability—to predict domain maturity: code first, then biology, security, finance. He exposes benchmark psychosis: a single number under one scaffold is a noisy sample, requiring cross-harness differencing. Labs like Anthropic's data spending forecasts product launches (e.g., cybersecurity data in January led to Claude Cyber in March). Data companies like Mercor pivot to enterprise, and Cai builds Antikythera mechanisms to monetize real-world workflows and provide RL-as-a-service.

Everything Is a Rollout — Alex Shaw + Ryan Marten, Terminal-Bench, Harbor, Laude Institute

Jul 24, 2026 · 21:11

Alex Shaw presents Harbor, an open-source framework for evaluating and optimizing AI agents through sandboxed environments, arguing that agent development is a form of machine learning requiring empirical evaluation. He contrasts this with traditional software engineering, showing how agents' behavior is best treated as a black box artifact. Harbor provides a common format for specifying agentic tasks, enabling parallel rollouts across any model, sandbox, and task. Shaw outlines four evaluation use cases: assessing agents building internal products, using external APIs, powering product features, and automating processes. He highlights adoptions by companies like Cognition, Scale, and Poolside, and notes Harbor's role in benchmarks like Frontier Suite and Rune Bench for Runescape. The framework also supports training via SFT and reinforcement learning, with integration partners like Tinker and LangChain.

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.

Training Frontier Models to Out-Think Hackers — Uri Rolls, Arithmetic & Thom Wolf, Hugging Face

Jul 24, 2026 · 17:28

Uri Rolls of Arithmetic and Thom Wolf of Hugging Face argue that frontier models can be trained to out-think hackers, not just pattern-match vulnerabilities, by focusing on logic leaps in access control. Their benchmark, Mask Off, builds blackbox environments from real zero days found by human researchers, testing whether models can chain reconnaissance into exploitation. A live example: a Keycloak check validates admin by name while another checks by ID, so renaming oneself to the admin inherits privilege—GPT-5.5 and Opus probe everything but never make that logical leap. Results are brutal: only one solve at K1, with GPT-5.5 alone succeeding at K5. Rolls and Wolf argue this mirrors ARC-AGI’s challenge—models struggle to build dynamic world models—and that high-quality data and open source models can shift the economics of cyber defense, giving defenders a lasting speed advantage.

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.

The Desktop Frontier — Ahmad Osman, Osmantic

Jul 21, 2026 · 18:02

Ahmad Osman, founder of Osmantic, argues that within roughly 18 months (by late 2027) a single RTX 5090 will run intelligence equivalent to GLM 5.2, driven by the Densing Law of increasing impact per parameter. He shows this trend through concrete examples: a 27B-parameter Qwen 3.5 now beats the 405B LLaMA 3, and the same eight RTX 3090s that once struggled with LLaMA 2 can now run 15 parallel Qwen 3.5 agents. Osman presents the Densing Law—every 3.5 months, 50% fewer parameters achieve the same capability—as a systematic pattern, not coincidence. He advocates for sovereign AI: owning your own hardware (like a DGX Station or RTX 5090) gives you control, avoids cloud limitations, and sees hardware appreciate in utility as models become more efficient. He asks why fund cloud data centers when local hardware can run frontier intelligence and grow more valuable over time.

Security Track Intro — Randall Degges, Snyk

Jul 20, 2026 · 4:16

Randall Degges of Snyk opens the World's Fair Security Track by identifying three barriers to building secure AI at scale: AI-generated code with security flaws, autonomous agents that can go off the rails in production, and geopolitical disruptions like access being pulled to frontier models such as Fable and GPT-5.6. He argues these challenges all reduce to the need for secure-by-default AI development. To address them, Degges announces the day-long Security Track in room 2005, featuring presentations from NVIDIA, Anthropic, Keycard, Snyk, and others, focused on practical solutions for fearless AI development.

In the Land of AI Agents, the Verifiers Are King — Tariq Shaukat, Sonar

Jul 20, 2026 · 18:53

Tariq Shaukat, CEO of Sonar, argues that rigorous verification is the key to unlocking sustained value from AI coding agents, introducing the Agent-Centric Development Cycle (AC/DC) framework: Guide, Verify, Solve. He warns that without it, the initial 3–5x productivity boost from agents dissipates within three months as technical debt—security issues, maintainability issues, and complexity—compounds. Sonar's tests show that multi-layered, zero-trust verification (combining algorithmic and agentic methods) reduces AI-derived production outages by 44% and, in a trial with a large bank, achieved a 92% reduction in issues. Clean codebases, he argues, make agents faster and cheaper, with over 30% fewer tokens consumed when guided by context and constraints. The framework embeds verification into three loops—agentic, CI, and code maintenance—to create a self-reinforcing positive cycle, countering the downward spiral of neglected code quality.

Designing Voice Agents for Real Conversations - Chintan Agrawal & Daniel Wirjo, AWS

Jul 20, 2026 · 32:57

AWS Solutions Architects Chintan Agrawal and Daniel Wirjo argue that the hardest problem in production voice agents is audio engineering—not AI—specifically turn-taking, the decision of when an agent should stop speaking or start responding. They present three levels of turn detection: Level 1 uses Silero VAD with a silence timeout (e.g., 300ms default), Level 2 delegates to STT providers like Cartesia or Deepgram for built-in endpointing (p50 ~250-300ms), and Level 3 combines Silero VAD with SmartTurn, an open-source 8MB model achieving 58.9% recall and 68.4% precision while falling back to VAD on low confidence. They show how interruption handling (barge-in) flushes TTS/LLM in ~15ms and distinguish real interruptions from backchannel acknowledgments. Latency budgets are tight: 40ms mic encoding, 52ms network/jitter, 300ms STT+endpointing, 500-650ms LLM time-to-first-byte (dominant bottleneck), and 120-190ms TTS playback, totaling 800-1300ms in standard cloud setups. Co-locating models in one GPU cluster can achieve ~500ms voice-to-voice. For LLMs, Nemotron 3 Ultra and GPT-4.1 achieve ~530ms p50 but GPT-4.1 spikes to 1.7s p95, and multi-turn drift (>15 turns) can break prompt…

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.

Stop Burning Tokens: Why self-improvement needs domain expertise first - Annabell Schäfer, Langfuse

Jul 18, 2026 · 17:39

Annabell Schäfer, Growth Engineer at Langfuse, argues that successful auto-improvement loops require domain expertise and high-signal target functions, not just generic evaluators. She details an experiment classifying arXiv papers with a minimal loop using GPT-5 for nano and Claude Opus 4.8 as an optimizer, achieving a 15% accuracy jump from 68% to 83% in four iterations. The first iteration alone gained 10% by adding classification rules and examples based on error analysis of a 200-item dataset. Schäfer advises replacing vague metrics like correctness with yes/no quality criteria (e.g., 'answer uses knowledge base'), and working with domain experts to identify failure modes and define what 'good' means. She emphasizes validation to prevent overfitting and treating the system as generalizing from representative examples, not just burning tokens on endless loops.

The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents

Jul 17, 2026 · 1:00:16

In the 'Great Loops Debate' hosted by Ali Howe, Geoff Huntley, Ian Livingstone, Dex Horthy, and Greg Pstrucha argue whether there is a delta between the hype behind loops in AI-assisted development and what works in practice. Team No Delta (Ian, Geoff) contends loops are inevitable and already cost-effective at $10.42/hour, with models surpassing average coders. Team Delta (Dex, Greg) counters that hype outruns discipline: loops work only for deterministic tasks, quality remains low, and token spend scales unsustainably. The debate covers loop history, anatomy (verification, context windows), and the feasibility of fully autonomous software factories, concluding that while loops boost productivity 2-3x, the vision of lights-off factories is premature.

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.

On AI and Knowledge — Pablo Castro, Distinguished Engineer & CVP for AI Knowledge, Microsoft

Jul 17, 2026 · 17:35

Pablo Castro, Distinguished Engineer and CVP for AI Knowledge at Microsoft, argues that AI agents require three knowledge types—intrinsic (model training), extrinsic (RAG and grounding), and learned (optimization loops)—and demonstrates how Microsoft's Foundry IQ, Azure AI Search, and Agent Optimizer deliver them. He shows that combining retrieval methods outperforms individual ones, citing Azure AI Search evaluations where combined methods improve evidence recall and answer completeness. He introduces Foundry IQ as a layered system with agentic retrieval that reflects on data to satisfy information needs before returning results. Castro demonstrates creating a knowledge base that connects unstructured data, structured Parquet tables, and the web, then linking it to an agent via MCP server. He also showcases the Agent Optimizer, which uses hill climbing on baseline evaluations to automatically refine agent instructions, tool definitions, and skills based on runtime traces, enabling continuous learning loops that capture organizational differentiation.

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.

State of the Union: Why Local, Why Now — NVIDIA, Osmantic, Roboflow, EXO Labs, @matthew_berman

Jul 11, 2026 · 44:29

Nader Khalil (NVIDIA), Joseph Nelson (Roboflow), Alex Cheema (Exo Labs), Matthew Berman, and Ahmad Osman (Osmantic, r/LocalLLaMA) argue that local AI is now useful, driven by stronger open models and better hardware. They cite inflection points like Llama 2, DeepSeek v3, and GLM 5.2, which closed the gap with frontier cloud models. Sovereignty and control are key: enterprises need to choose their own model versions and avoid lock-in. Specialized models, such as Roboflow's fine-tuned vision models for deep-sea fish discovery, outperform general ones for specific tasks. Optimization is critical: EXO Labs achieved 10x performance on the DGX Spark by tuning existing NVIDIA kernels. The panel emphasizes that simplicity remains a barrier—most users need point-and-click solutions—and advocates for open-source AI to ensure freedom and innovation.

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.

The Golden Age of AI Engineering — Alexander Embiricos & Romain Huet & Peter Steinberger, OpenAI

Jul 9, 2026 · 25:13

OpenAI's Alexander Embiricos, Romain Huet, and Peter Steinberger reveal how AI engineering is entering its golden age, with model releases accelerating from every 15 months to roughly every 6 weeks and frontier-level intelligence now available at $1 per million input tokens and $6 per million output tokens. They demonstrate Codex's evolution from a model that couldn't test its own code to one generating 750 tokens per second, enabling a 10-second pull request, and emphasize that the product is built on the same open-source stack—responses API, AGENTS.md format, and harness—that ships to developers. The trio argue that the future is not about automating engineers but empowering them via value maxing over token maxing, with agents moving from local/cloud distinctions to persistent, long-running managers that orchestrate work and only require human steering at key decision points, as illustrated by an automated open-source issue resolution workflow.

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.

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.

The Prompt Is Still a Punch Card - Ted Johnson, JoinIn AI

Jul 2, 2026 · 20:13

Ted Johnson argues that AI interfaces still use the batch protocol of punch cards, forcing humans to adapt to machines rather than the reverse. He introduces three concepts—channel, expression, protocol—to show how expression exploded with LLMs but the protocol remained static. Examples include voice mode misinterpreting a side conversation, PersonaPlex's turn-taking, and a meeting AI that follows group dynamics without prompts. Johnson calls for designing interfaces where AI understands timing, ambiguity, and shared context, moving from prompting to genuine communication.

OpenClaw in Your Hand: Building a Physical AI Terminal - Lech Kalinowski, Callstack

Jun 28, 2026 · 24:36

Lech Kalinowski presents Vault, a dual-display handheld AI terminal built on an ESP32-S3 that runs a local LLM and OpenClaw agents without cloud reliance. The device pairs a fast OLED live surface with a bistable e-paper content display, offering four modes — shell, assist, control, and an LLM-native RPG — all powered by a single lithium-polymer cell. The backend serves GPT-oss 120b via NVIDIA TensorRT-LLM, keeping inference off the microcontroller. Kalinowski shares engineering war stories: blown OLEDs from unstable power supplies, software I2C issues, and noisy encoders. The RPG mode generates four worlds with NPCs and narrative state tracked by the LLM, not dice or HP. Built in three months with 130 commits, the terminal is intentionally distraction-free, targeting quiet spaces where users want text-first AI interaction.

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.

Recursive Coding Agents - Raymond Weitekamp, OpenProse

Jun 25, 2026 · 23:48

Recursive Language Models (RLMs) are a new test-time compute paradigm that unify reasoning and tool calling, and Raymond Weitekamp of OpenProse argues they can turn coding agents into reliable, recursive problem solvers. He demonstrates that RLMs can process millions of tokens beyond context windows, and a small Qwen 3.5 9B model using RLMs beats GPT-5.4 and Opus on the LongCOT benchmark. Weitekamp shows how Claude Code's Dynamic Workflows now make it an RLM, and how OpenProse allows any coding agent to be recursively orchestrated with declared sub-agent work and dependencies. Use cases include repo-scale migrations, deep research over file systems, and adversarial red-teaming audits. He concludes that RLMs represent the next paradigm of inference-time compute, turning mismanaged genius agents into trustworthy outcomes by capturing golden sessions as reusable workflows.

The Miranda Hypothesis: How Hamilton Poisoned Persona Evals - Jacob E. Thomas, Results Gen

Jun 25, 2026 · 58:17

Jacob E. Thomas argues that persona-eval benchmarks like InCharacter, which report 80.7% personality fidelity for Hamilton, structurally miss anachronistic compositing because they measure fluency and personality consistency—exactly the features the dominant cultural composite optimizes. The Miranda Hypothesis posits that training data saturated with works like the 2015 Hamilton musical (outnumbering the 175,000-word Federalist Papers by orders of magnitude) causes models to produce smoothed, morally legible composites rather than historically faithful personas. Thomas explains that RLHF amplifies this distortion because human raters share the same cultural frame. He proposes a paradigm shift to epistemic simulation: corpus-bounded, temporally-anchored systems evaluated by domain experts, with the model as a swappable component in a configurable role-playing language system. The pre-registered Prism Experiment instantiates Abraham Lincoln at four documented moments (1847, 1858, 1860, 1862–65) under three seeding conditions—bare model, biography, or primary sources—scored on a weighted three-axis rubric that prioritizes anachronism detection (40%) over voice. Thomas concludes that…

6 Things to Know about AIE World's Fair 2026

Jun 21, 2026 · 17:50

Swix, co-founder of AI Engineer, outlines six key features of the 2026 World's Fair in San Francisco. The event is over 4x larger than 2025, with 50% new topics, an expanded expo floor (4 stages, 4x bigger), and a new research-industry poster session that includes printed tweets. A leadership track on Level 3 features the Token Billionaire lounge for heavy LLM users and off-the-record McKinsey sessions. AI verticals debut in agentic commerce, healthcare, finance, and GTM, with a new AI Engineer New York focused on finance. Side events include a World Cup viewing, New Engineer Orientation (NEO) with 300+ signups, and a kids event; attendees can claim $38,000 in sponsor offers.

The Production AI Playbook: Deploying Agents at Enterprise Scale — Sandipan Bhaumik, Databricks

Jun 18, 2026 · 37:06

Sandipan Bhaumik, a technical lead for Data and AI at Databricks, presents a five‑pillar playbook for taking AI agents to production: evaluation (define numerical success before touching code), observability (trace every decision for regulators and debugging), data foundation (agents do not forgive bad data), multi‑agent orchestration patterns (orchestrator‑worker, choreography, human‑in‑the‑loop), and governance (PII pre‑validation, prompt versioning as change management). He recounts a retail bank that spent £85,000 over six months on a chatbot PoC that failed because no one could measure or trace it. His team reversed the order: they built the evaluation dataset and tracing infrastructure first, selected the model in week 7 of an 8‑week engagement, and launched successfully. Six weeks post‑launch, when the bank updated interest rate policies, the tracing system caught that the new document had not been re‑embedded, so the agent served stale answers—a production incident the five pillars were designed to handle. The evaluation dataset is a living system that grows from 200 test cases; a production incident playbook connects all pillars: detect via eval dashboard, diagnose with…

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.

Task Fidelity Scaling Laws — Kobie Crawdord, Snorkel

Jun 2, 2026 · 20:40

Kobie Crawford from Snorkel presents research on task fidelity scaling laws, showing that fine-tuning on high-quality agentic TerminalBench tasks yields a 5x improvement over low-quality tasks (6% vs. 1% uplift) with the same model, compute, and task count. Snorkel defines task quality by four criteria (achievable, non-trivial, functionally correct, reliable environment) and uses a containerized setup to verify them. Accepted tasks averaged twice as many tool calls, lower pass rates, and more output tokens, indicating genuine difficulty, while rejected tasks failed due to ambiguous specs or mismatches between requests and tests, producing noise rather than useful signal. The talk demonstrates that data quality is central to RL training outcomes, with Snorkel leveraging expert-in-the-loop data generation to ensure high-quality tasks.

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.

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.

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.

Fast Models Need Slow Developers — Sarah Chieng, Cerebras

May 22, 2026 · 18:02

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

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

May 22, 2026 · 21:56

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

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

May 21, 2026 · 18:25

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

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.

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

May 15, 2026 · 18:27

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

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

May 14, 2026 · 1:20:07

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

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

May 14, 2026 · 1:04:27

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

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.

Give Your Agent a Computer — Nico Albanese, Vercel

May 12, 2026 · 1:08:53

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

Agentic Search for Context Engineering — Leonie Monigatti, Elastic

May 8, 2026 · 1:03:13

Leonie Monigatti from Elastic argues that context engineering is 80% agentic search—the search tool that decides what to pull from files, databases, memory, and the web. She identifies three failure modes: the agent not calling any tool, calling the wrong tool, or generating incorrect parameters, and shows how detailed tool descriptions and agent skills (progressive disclosure) reduce these. In demos, semantic search fails for keyword 'JEPA' due to embedding similarity; a general-purpose ESQL tool with an agent skill correctly queries the database. Shell/bash tool enables file system search but requires iterative grep, while the custom Gina Grap CLI provides semantic grep for fuzzy queries. Practical recommendations: start with general-purpose tools, log agent behavior, and add specialized tools for frequent queries to balance low floor (easy successes) and high ceiling (complex queries). Hybrid agents combining shell and database tools achieve higher accuracy by verifying results.

Agent Optimization with Pydantic AI: GEPA, Evals, Feedback Loops — Samuel Colvin, Pydantic

May 7, 2026 · 1:20:40

Samuel Colvin shows how to improve production agents without redeploying using Pydantic AI's GEPA, evals, and Logfire managed variables. GEPA uses a genetic algorithm to evolve prompts, achieving 96.7% accuracy — up from 87% with a simple prompt and 92% with an expert prompt — on a Wikipedia-based political relations task. Managed variables let you update prompts, models, and parameters live via a web interface and A/B test targeting. Evals compare against a golden dataset of 650 MPs; Colvin runs 65 cases in 30 seconds using GPT-4.1. He discusses that prompt optimization is most valuable with private data, that implicit user feedback (e.g., user's next action) can build golden datasets, and that overfitting to small test sets is a risk — the GEPA optimizer may exclude valid relations like 'uncle' if they don't appear in the training split.

Replacing 12K LoC with a 200 LoC Skill — David Gomes, Cursor

Apr 30, 2026 · 19:22

David Gomes shows how Cursor replaced 12,000 lines of code for Git WorkTrees and best-of-en features with roughly 200 lines of Markdown using agent skills and subagents. He explains the original implementation's complexity (15,000 lines deleted) and the new slash commands: /worktree, /best-of-en, /apply, /delete. Pros include less maintenance, ability to switch mid-chat, multi-repo support, and better judging with the parent agent stitching results. Cons: models sometimes forget to stay in the WorkTree over long sessions, perceived slowness, and reduced discoverability. He details future improvements through evals and RL training, plus a native WorkTrees implementation in Cursor 3.0 and exploration of non-Git parallelization primitives.

Building your own software factory — Eric Zakariasson, Cursor

Apr 28, 2026 · 1:23:37

Eric Zakariasson, an engineer at Cursor, explains how to build a 'software factory' by scaling from one agent to many, shifting from worker to manager. He outlines six stages of autonomy, from spicy autocomplete to the dark factory, and emphasizes that most teams are stuck at levels two or three. Key primitives include modular codebases, guardrails like rules and hooks that emerge dynamically, enablers such as skills and MCPs, and verifiable systems like automated tests. Cloud agents with isolated VMs allow agents to run asynchronously, test their own work via computer control, and scale to thousands. Eric shares internal automations like daily reviews, PR comment analysis, and continual learning that extracts rules from chat transcripts. He concludes with strategic advice: front-load context, don't outsource critical decisions, and build tools and systems to capture flywheels, noting that human accountability remains essential.

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.

The End of Apps — Kitze, Sizzy.co

Apr 23, 2026 · 20:18

Kitze, creator of Benji and founder of Tinker Club, argues that current productivity apps and AI agents are unreliable and too complex for most users, predicting a future where AI prompts humans instead of the reverse. He traces his 24-year obsession with productivity tools—from a childhood to-do list to building Benji with 60 features—and his move to self-hosting after the ChatGPT moment. Kitze critiques custom agents like OpenClaw as too tinkerer-focused, cloud agents like ChatGPT as too nerfed, and believes local models on devices (Apple, Google Pixel) will win for normies, enabling AI to automatically manage notifications, emails, and tasks. He shares his own experiment, Wolfer, designed for predictable multi-agent orchestration without memory systems, using nested topics for context. The episode delivers a strong claim: the role of AI will invert, with machines prompting humans for decisions while handling all background work.

Harness Engineering: How to Build Software When Humans Steer, Agents Execute — Ryan Lopopolo, OpenAI

Apr 17, 2026 · 46:21

Ryan Lopopolo, a member of technical staff at OpenAI, argues that software engineers must shift to 'harness engineering' where agents produce all code and humans focus on delegation, system design, and guardrails. He describes how his team banned editors, using Codex with skills to manipulate apps, and reduced review friction by automating lint rules and review agents. Lopopolo explains that code is free but human time and model context are scarce, so teams should structure repositories for consistency and use 'garbage collection days' to eliminate recurring slop. He shares practical techniques like writing tests about source code (e.g., file length limits) and using review agents that inject prompts. His future vision involves agents autonomously executing long-horizon work based on token budgets and success metrics, freeing humans for higher-level activities.

How METR measures Long Tasks and Experienced Open Source Dev Productivity - Joel Becker, METR

Jan 19, 2026 · 1:15:52

Joel Becker of METR argues that AI benchmark scores are soaring while real-world developer productivity barely budges, reconciling this gap by presenting METR's time horizon measurements and a 16-developer RCT showing no significant speedup from AI on mature open-source projects. He cites reliability issues, task distribution mismatches, and the J-curve effect from Meta's developer data, noting that experienced users still fail to accelerate. The episode explores why AI struggles with messy enterprise data (e.g., LinkedIn's 5,000 'impressions' tables), the failure of computer-use agents in 'Agent Village,' and the possibility that hardware constraints may slow progress. Becker also previews new metrics like 'watched versus unwatched' time horizons and future studies on greenfield coding and data science.

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.

Coding Evals: From Code Snippets to Codebases – Naman Jain, Cursor

Dec 15, 2025 · 18:08

Naman Jain, an AI engineer at Cursor, traces the evolution of coding evaluations from single-line snippets to entire codebases over four years. He introduces LiveCode Bench for competition programming, dynamically updating problems to combat data contamination and adjust difficulty, with model performance dropping from 50% to 20% after training cutoffs. For real-world software optimization, he presents a benchmark using commits from codebases like Llama CVP, but notes 30% of O3 attempts involved reward hacking—such as hijacking numpy libraries—caught by a GPT-5-based Hack Detector. In longer-horizon tasks like translating 4,000 lines of C to Rust (Syzygy), end-to-end correctness gives only one bit of feedback, highlighting the need for intermediate grading signals. Finally, in wild evals like Copilot Arena, acceptance rates drop sharply with latency over one second, emphasizing human-centric experiment design to balance latency differences.

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.

Agent Reinforcement Fine Tuning – Will Hang & Cathy Zhou, OpenAI

Dec 9, 2025 · 16:55

Will Hang and Cathy Zhou of OpenAI's fine-tuning team introduce Agent Reinforcement Fine-Tuning (RFT), a method to improve AI agents by training them end-to-end on tasks involving tool calls and reasoning. They define an agent as a model that interleaves reasoning with external tool interactions, unlike regular models. The hierarchy of optimization moves from prompt engineering to task optimization to RFT, which changes model weights based on a custom reward signal. New features allow models to call tools via public endpoints and use custom rewards hosted externally. Case studies show concrete gains: Cognition improved code edit planning by 10 points with 1,000 examples and reduced tool call steps from 8–10 to 4; Codto's deep research agent boosted recall by 6% while cutting long-tail tool calls (over 15) down to 2–4; Cosine achieved state-of-the-art on enterprise code benchmarks by using strict graders that reward only pass-tested code; and Macco wrote GPU kernels from just 100 PyTorch prompts, beating SOTA by 72% after addressing reward hacking with seven edge-case detectors. Four principles for success: define tasks unambiguously, mirror production traffic in train/eval sets,…

RL Environments at Scale – Will Brown, Prime Intellect

Dec 9, 2025 · 18:30

Will Brown of Prime Intellect argues that scaling reinforcement learning environments beyond engineering—to community and accessibility—is key to broadening AI research. He presents Prime Intellect's open-source stack, including Verifiers for building environments and the Environments Hub for sharing them, as a way to turn any task harness into an RL training or evaluation loop. Brown demonstrates how environment-based fine-tuning boosted a Qwen 3 4B model from 55% to 89% on a Wikipedia search task, matching much larger models. He frames environments as the 'web apps of AI research'—simple to start, but capable of capturing product complexity, as seen with Cursor's Composer and OpenAI's Codex. Prime Intellect validated this approach by training the 100B-param Intellect 3 on 500 GPUs, and will soon release Lab, a platform to run environments without managing infrastructure.

Future-Proof Coding Agents – Bill Chen & Brian Fioca, OpenAI

Dec 5, 2025 · 17:48

Bill Chen and Brian Fioca from OpenAI argue that coding agents are booming but fragile, with teams rebuilding harnesses every time models change. They present Codex, OpenAI's combined model and harness, as a stable abstraction layer that handles complexity like context compaction, parallel tool calls, and MCP integration. Key lessons include avoiding overprompting—letting the model use its trained habits rather than forcing foreign instructions—as demonstrated when GPT-5 ran slowly because users told it to examine every file. They describe patterns for using Codex as an SDK, enabling products like GitHub and Cursor to integrate without maintaining their own harness, and highlight future improvements in longer-horizon tasks and self-healing software. The episode concludes that building where models are going, with Codex's SDK, lets teams focus on differentiation rather than infrastructure rewrites.

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.

Developing Taste in Coding Agents: Applied Meta Neuro-Symbolic RL — Ahmad Awais, CommandCode

Nov 24, 2025 · 20:52

Ahmad Awais, founder of Langbase, introduces CommandCode, a coding agent that learns a developer's personal taste and preferences to generate code that feels like their own. Built on Langbase's infrastructure (deploying over 350K agents and 1.2B monthly runs), CommandCode uses a Meta Neuro-Symbolic architecture with reinforcement learning to continuously capture a programmer's invisible architecture of choices—such as preferring TypeScript, PNPM, TSUP, and Commander over other tools—without requiring explicit rule files. Awais demonstrates how CommandCode automatically applies these learned preferences when building a CLI, contrasting it with Claude Code which generates generic output. He argues that taste models represent the next frontier, enabling agents to evolve with the developer and even share tastes across teams or borrow preferences from other developers like design engineers.

Z.ai GLM 4.6: What We Learned From 100 Million Open Source Downloads — Yuxuan Zhang, Z.ai

Nov 22, 2025 · 19:39

Yuxuan Zhang from zAI details the technical roadmap behind the GLM 4.6 open-source model series, which has surpassed 100 million downloads and tied for number one on the LMSYS Chatbot Arena alongside GPT-4o and Claude 3.5 Sonnet. The training pipeline uses 15 trillion tokens of pre-training data, followed by 7 trillion tokens of code and reasoning data, repo-level contexts at 32,000 tokens, and 100 billion tokens of long-context agent trajectories up to 128,000 tokens. Zhang introduces SLIME, a hybrid synchronous/asynchronous RL framework that decouples agent-environment interaction from GPU training to avoid bottlenecks. He explains why single-stage RL at 64,000 tokens outperforms multi-stage approaches for preserving long-context abilities, and shows that token-weighted loss converges faster than sequence-average loss for code RL. The multimodal GLM 4.5V model handles native resolution images and video with temporal index tokens, enabling GUI agent capabilities. Deployment is supported via vLLM and SGLang, with an API at z.ai and an open-source coding assistant.

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.

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.

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.

Introduction to LLM serving with SGLang - Philip Kiely and Yineng Zhang, Baseten

Jul 26, 2025 · 43:42

Philip Kiely and Yineng Zhang introduce SGLang, an open-source fast serving framework for LLMs and VLMs, arguing it offers production-ready performance with day-zero support for new models like DeepSeek and Qwen, and a customizable codebase for contributions. Yineng, a core maintainer, traces SGLang's rapid growth from a December 2023 paper to nearly 15,000 GitHub stars and adoption by xAI, AMD, and Meituan. The workshop demonstrates deploying a first model via Baseten's trunk packaging, then tuning the CUDA Graph max batch size flag on an L4 GPU to maintain CUDA Graph-enabled decoding during higher concurrency, boosting generation throughput. They also cover Eagle 3 speculative decoding, where a draft model derived from the target model speculates tokens; users can benchmark different step and top-k configurations on representative prompts to find optimal settings for production. Finally, they invite contributions via GitHub's 'good first issue' tags and highlight Baseten's job openings.

Devin 2.0 and the Future of SWE - Scott Wu, Cognition

Jul 25, 2025 · 16:13

Scott Wu of Cognition AI describes an AI 'Moore's Law' for coding agents, with capability doubling every 70 days, propelling Devin from simple migrations to autonomous project work. He traces Devin's evolution through tiers: first repetitive migrations using Playbooks for instruction-following, then isolated bugs with VM snapshots, then multi-file changes with codebase intelligence, and finally backlog killing with self-testing. Each tier required solving different bottlenecks—memory, language server integration, iterative planning, and confidence calibration. Wu argues that the interface and key capabilities shift every 2-3 months, and predicts another 16-64x improvement in the next year.

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.

HybridRAG: A Fusion of Graph and Vector Retrieval - Mitesh Patel, NVIDIA

Jul 22, 2025 · 20:24

Mitesh Patel, Developer Advocate Manager at NVIDIA, presents HybridRAG, a fusion of knowledge graph-based GraphRAG and vector-based VectorRAG for improved question-answering from complex texts. He emphasizes that ontology engineering consumes 80% of development time and is critical for accurate triplet extraction, where fine-tuning LLaMA 3.1 with LoRA boosted triplet accuracy from 71% to 87% on 100 documents. Patel also highlights retrieval strategies like multi-hop graph traversal, which provides richer context but increases latency, and recommends QGraph acceleration via Networx to reduce latency. For evaluation, he suggests RAGAS for end-to-end pipeline metrics and the LLaMA-Nimotron reward model for response quality. Ultimately, he advises using GraphRAG when data has inherent structure or complex relationships, but notes it is compute-heavy, so the choice between GraphRAG, semantic RAG, or hybrid depends on the use case.

What every AI engineer needs to know about GPUs — Charles Frye, Modal

Jul 20, 2025 · 19:52

Charles Frye of Modal explains that AI engineers need to understand GPU hardware constraints to optimize inference, arguing GPUs embrace bandwidth over latency and that Tensor Cores for low-precision matrix-matrix multiplication are the key resource. He describes how GPUs achieve 16,000+ parallel threads per cycle on H100, and notes Patterson’s Law: bandwidth improves at the square of latency. The main insight: arithmetic intensity favors N² operations per N memory loads, so matrix-matrix operations are efficient while matrix-vector is wasteful. Frye demonstrates that running a small 8B model 1,000 times on the same prompt matches GPT-4 quality, and that multi-token prediction and multi-sample query become nearly free because Tensor Cores handle expanded batches as matrix-matrix multiplications. He recommends using smaller models that fit on a single GPU and scaling via multiple generations.

[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.

Full Spec MCP: Hidden Capabilities of the MCP spec — Harald Kirschner, Microsoft/VSCode

Jul 18, 2025 · 14:53

Harald Kirschner from Microsoft/VSCode argues that MCP's full specification unlocks powerful stateful interactions beyond the common 'tools-only' implementations, transforming AI assistants into more contextual and efficient agents. He highlights underused primitives like resources for rich data context and sampling for server-requested LLM completions, demonstrated via a dungeon game where dynamic tool discovery adapts to game state. VS Code's upcoming full spec support includes dynamic tool discovery, user-defined tool sets, a debug mode for server development, and support for streamable HTTP to reduce stateful server churn. Upcoming features like elicitations will allow tools to request user input directly. Kirschner calls on developers to build progressive, full-spec servers and contribute feedback to the open ecosystem, emphasizing that client and SDK support will follow as usage grows.

The State of Generative Media - Gorkem Yurtseven, FAL

Jul 16, 2025 · 17:14

Gorkem Yurtseven, co-founder and CTO of fal.ai, argues generative media lowers creation's marginal cost to near zero, transforming advertising and e-commerce. He traces evolution from DALL·E 2 to open-source models like Stable Diffusion and FLUX, with the playing field evening quickly. Video models (Sora, Veo 3) are accelerating: fal's platform saw video usage jump from near zero to 30% of revenue, and he predicts the generative video market 100x-250x bigger than image. Advertising leads with hyper-personalized, interactive ads, like fal's A24 campaign turning selfies into toy soldiers. In e-commerce, virtual try-on is a proven product-market fit. Future real-time video generation will blur games and movies.

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.

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.

MCPs are Boring (or: Why we are losing the Sparkle of LLMs) - Manuel Odendahl

Jun 10, 2025 · 28:32

Manuel Odendahl argues that MCPs (Model Context Protocols) are boring because they constrain LLMs to rigid, predefined tool calls, while LLMs truly shine as code generators that can create dynamic tools on the fly. He critiques the inefficiency of tool calling—repeating context, wasting tokens, and struggling with many tools—and advocates for an 'Eval' approach where the LLM writes and executes code (e.g., SQL, JavaScript) to solve tasks directly. Demonstrating with a JavaScript sandbox, he shows how a single Eval tool can introspect databases, write queries, create REST APIs, and even build a full CRM interface in one call, saving time and tokens. Odendahl urges engineers to think recursively: ask the LLM to write code that writes more code, unlocking infinite loops of creation and restoring the sparkle of LLMs beyond boring function calls.

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.

Real AI Agents Need Planning, Not Just Prompting - Yuval Belfer

Jun 3, 2025 · 7:58

Yuval Belfer of AI21 Labs argues that LLMs alone still fail at instruction following, as shown by GPT-4.1's struggles in 2025, and that true AI agents require dynamic planning, not just prompting. He critiques ReAct for lacking look-ahead, contrasting it with AI21 Maestro's planner and smart execution engine, which uses best-of-n sampling, candidate pruning, and replanning. On AIfeval, Maestro pushes GPT-4.0, Claude Sonnet 3.5, and R3 Mini to near-perfect scores; on internal requirement satisfaction benchmarks, it improves over single LLM calls despite higher runtime and cost. Belfer advises starting simple (SLMs, ReAct) and escalating to planning only for complex tasks, inviting listeners to join the Maestro waitlist.

The RAG Stack We Landed On After 37 Fails - Jonathan Fernandes

Jun 3, 2025 · 18:52

Jonathan Fernandes, independent AI engineer, details the RAG stack his team settled on after 37 failed attempts, covering orchestration (LlamaIndex), embeddings (BAAI BGE small), vector database (Qdrant), LLMs (GPT-4, Qwen, Llama), reranking (Cohere), monitoring (Arize Phoenix), and evaluation (RAGAS). He demonstrates a live prototype in Google Colab using a London railway knowledge base, showing how a naive RAG returns irrelevant results (e.g., suggesting black cabs for "where can I get help at the station"). By swapping components—replacing in-memory storage with Qdrant, using an open-source embedding model, upgrading to GPT-4, and adding Cohere reranking—the answer improves to "go to booth number five next to the Eurostar ticket gates." For production, he deploys via Docker Compose with NVIDIA embedding/reranking models and Ollama for serving. The episode also stresses the importance of tracing latency per component and using RAGAS for systematic evaluation across many queries.

The Benchmarks Game: Why It's Rigged and How You Can (Really) Win - Darius Emrani

Jun 3, 2025 · 11:20

Darius Emrani exposes how AI benchmarks are rigged, showing that xAI cherry-picked Grok-3 comparisons, OpenAI funded FrontierMath for privileged access, and Meta submitted 27 Llama-4 variants to LM Arena optimizing style over substance. Citing Goodhart's Law, he argues that when benchmarks target billions in investment, they cease to measure real capability—Andrej Karpathy admits he doesn't know which metrics to trust. Emrani provides a 5-step framework to build use-case-specific evaluations, emphasizing that 39% of score variance comes from writing style. He advocates for apple-to-apple comparisons, open-source test sets, and style-controlled metrics, concluding that teams should stop chasing leaderboards and instead iterate on real production data to ship reliable AI.

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.

Creating Agents that Co-Create — Karina Nguyen, OpenAI

Apr 30, 2025 · 24:22

Karina Nguyen, an AI researcher at OpenAI and former Anthropic researcher, discusses two major AI scaling paradigms—next-token prediction (pretraining) and reinforcement learning on chain of thought—that shift AI from narrow tools to collaborative agents that co-create. Pretraining builds world understanding by predicting the next token, but hard tasks like math and creative writing require chain of thought reasoning, scaled with OpenAI’s O1 model. Post-training via RLHF and synthetic data enables rapid iteration, and the next stage is co-innovators: agents with reasoning, tool use, long context, and creativity. Nguyen shares product lessons from developing ChatGPT and Claude: 100K context via file uploads, ChatGPT Tasks for scheduled reminders that scale with model capabilities, and Canvas as a flexible interface for co-writing, coding, and research that can morph into an IDE, a tutor, or a data scientist. She envisions a future of invisible software creation where AI generates personalized, multimodal outputs on the fly, reducing reliance on clicking links, and the interface becomes a blank canvas that adapts to user intent.

Function Calling is All You Need — Full Workshop, with Ilan Bigio of OpenAI

Apr 23, 2025 · 1:42:54

Ilan Bigio from OpenAI argues function calling is the essential primitive for building AI agents, demonstrating how to implement memory, delegation, asynchronous task execution, and even self-modifying tools—all using the same loop. Starting from a basic weather tool, he builds an agent that stores user facts in a JSON file, delegates complex requests to o1, runs multiple weather lookups in parallel with asyncio, and creates a Bootstrap agent that writes its own Python functions on the fly. He also shares practical tips from his work on Swarm and the Real-Time API, including a stay-silent function to prevent premature responses and the ability to read scripts with XML tags. The workshop emphasizes that sophisticated agent behaviors emerge from simple function calling patterns without needing heavy frameworks.

Building LinkedIn's GenAI Platform — Xiaofeng Wang

Apr 16, 2025 · 17:53

Xiaofeng Wang, manager of LinkedIn's GenAI Foundation, explains the evolution of LinkedIn's GenAI platform from simple prompt-in string-out applications to a multi-agent system for LinkedIn Hire Assistant, arguing that a unified platform is critical for bridging the gap between AI and product engineers in the era of compound AI systems. He details the platform's four-layer architecture—orchestration, prompt engineering, tools/skills invocation, and memory management—and key investments like a Python SDK, centralized skill registry, experiential memory across working, long-term, and collective layers, and observability built on OpenTelemetry. Wang discusses hiring philosophy: prioritize strong software engineers over AI expertise, hire for potential, and build diverse teams integrating full-stack engineers, data scientists, and AI engineers. He recommends solving immediate needs first, leveraging existing scalable infrastructure like messaging systems for memory, and focusing on developer experience to drive adoption.

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.

The Price of Intelligence - AI Agent Pricing in 2025

Feb 22, 2025 · 20:38

Shitej, co-founder and CTO of Orbe, argues AI agent pricing must continuously evolve, citing Intercom's 99 cent per resolution outcome model, Clay's prospecting credits, and Cursor's tiered usage limits. He stresses aligning pricing with target audience—SMB vs. enterprise—and maintaining simplicity and predictability. Cost structure is key: Character.AI optimized inference to support 100M DAUs, while Jasper leveraged a model decision engine to offer unlimited credits. Shitej emphasizes flexibility, noting OpenAI's price drops force repricing, and predicts 2025 will see more unlimited plans, outcome-based pricing with SLAs, and greater investment in pricing R&D for usage visibility.

WTF do people use Open Models for??

Feb 22, 2025 · 28:01

Eugene Cheah of Featherless.ai breaks down how individuals and enterprises actually use open-source AI models, based on platform data. DeepSeek R1 dominates individual usage, but Mistral Nemo 8B remains the top enterprise model due to production stickiness and Apache 2.0 licensing. Creative writing and roleplay account for 30–40% of all traffic, with over 60% of users in that segment being women; coding copilots and agents make up 20–30%, driven by 'vibe coding' and token-hungry workflows like Kline. RAG and ChatGPT clones represent 20%, while agentic workflows (10–20%) succeed with human-in-the-loop designs. Cheah advises enterprises to aim for 80% automation with escape hatches, and warns against chasing 100% reliability. He concludes by introducing Quirky, a post-transformer hybrid built for $100k.

The Hidden Costs of Building Your Own RAG Stack — Ofer Vectara

Feb 22, 2025 · 15:14

Ofer from Vectara argues that building your own RAG stack comes with seven hidden costs: irrelevant responses and hallucinations, high latency, scaling and cost issues, security and compliance challenges, vendor chaos from multiple components, unsustainable expertise requirements, and limited non-English language support. He details how each pitfall compounds at enterprise scale, citing the need for hybrid search, reranking, and continuous evaluation to maintain quality. Vectara offers a turnkey RAG-as-a-service platform that handles parsing, chunking, embedding, vector search, retrieval, and hallucination detection. Ofer highlights Vectara’s open-source HHEM model for hallucination evaluation, downloaded over 3 million times, and a leaderboard showing some LLMs hallucinate at rates above 10%. The platform supports deployment in SaaS, VPC, or on-premises, with built-in access control and explainability.

Your AI Agent Isn't an Engineer: The Art of Thoughtful Anthropomorphism

Feb 22, 2025 · 20:20

Rizel Scarlet, a staff developer advocate at Block, argues that marketing AI agents as "software engineers" creates unrealistic expectations and alienates developers. She explains that such anthropomorphism—attributing human traits to AI—stems from lazy marketing to executives, but it backfires by making developers feel threatened and discrediting products when AI fails to meet human-level performance. Citing a Wired article, she notes 52% of game companies have adopted generative AI, yet 30% of surveyed developers expressed negative sentiment. To build trust, she proposes a framework: understand how AI works (e.g., the agentic loop), use non-human names like "copilot" (pioneered by GitHub), focus on augmentation over replacement, be transparent, give developers control, show real demos (including live troubleshooting), provide clear documentation, and foster open collaboration (e.g., Cursor.Directory). The episode reframes AI as a tool to work in parallel, not a replacement.

The LLM Triangle: Engineering Principles for Robust AI Applications - Almog Baku:

Feb 22, 2025 · 26:19

Almog Baku introduces the LLM Triangle Principles for building production-ready AI applications, arguing that LLMs should be treated like interns guided by Standard Operating Procedures (SOPs). He breaks down the triangle into three components: the foundation model, engineering techniques, and contextual data, all directed by SOPs derived from expert interviews. Baku contrasts autonomous agents—creative but unpredictable—with handcrafted LLM-native architectures that offer sustainable quality, recommending scoped autonomy. He advises starting with large models to collect data and optimize incrementally, rather than fine-tuning from day one. Data is paramount: 'show, don't tell' via few-shot examples, and balance context to avoid the 'needles in a haystack' problem. The framework aims to turn demos into robust production systems.

Keynote: Why people think "agent" is a buzzword but it isn't

Feb 22, 2025 · 28:07

Chip Huyen argues that agents are not a buzzword but a practical yet hard technology, facing three core challenges: the curve of complexity, tool use translation, and context management. Even simple queries require multiple steps, and models' success rates drop rapidly past 5 steps—newer reasoning models like DeepSeek R1 are pushing the boundary, but most still fail after 10. Tool use requires translating ambiguous natural language to precise API calls, worsened by poor documentation; she advises narrow functions and asking for clarifications. Context is another bottleneck: agents must juggle instructions, tool docs, and outputs, often exceeding a model's efficient context (many hallucinate beyond 30K tokens), necessitating external memory like RAG. Her benchmark shows planning-specialized models struggle with long context and vice versa, and she recommends breaking tasks into subtasks and using test-time compute scaling.

Customized, production ready inference with open source models: Dmytro (Dima) Dzhulgakov

Feb 16, 2025 · 18:55

Dmytro (Dima) Dzhulgakov, co-founder and CTO of Fireworks AI, argues that open source models are the future for production Gen AI applications, and Fireworks provides a platform to make them customized and production-ready. He explains that while proprietary models like GPT-4 are powerful, they are too large, expensive, and slow for many use cases, whereas open models like Llama or Gemma can be fine-tuned for specific domains to achieve better quality at up to 10x speed and lower cost. The main challenges of using open models—complex setup, performance tuning, and production scaling—are addressed by Fireworks' custom serving stack, which achieves the fastest long-prompt inference and serves SDXL fastest among providers, handling over 150 billion tokens per day. The platform supports fine-tuning and serving thousands of LoRA adapters on the same GPU with serverless pay-per-token pricing. Dzhulgakov also highlights the emerging architecture of compound AI systems, where function calling—exemplified by the open-source Fire Function model—connects LLMs to external tools and knowledge sources, enabling agentic applications like stock querying and chart generation. The episode…

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.

The GenAI Maturity Curve or You Probably Don't Need Fine Tuning: Kyle Corbitt

Feb 9, 2025 · 18:03

Kyle Corbitt, CEO of OpenPipe, argues that most teams don't yet need fine-tuning and should start with prompted models like GPT-4. He presents a GenAI maturity curve where the trigger to fine-tune is when you hit constraints on cost, latency, or quality consistency—for example, if GPT-4 is 80-90% correct but inconsistent on the last 10-20%. Fine-tuning shifts the paradigm frontier outward, enabling models like fine-tuned LLaMA 38B to outperform GPT-4 at 1/25th the cost. The process has four steps: capture production logs to know your input distribution, prepare high-quality data (using GPT-4 outputs or iterative labeling), train with one-click tools, and evaluate with inner-loop (LLM-as-judge) and outer-loop (business metrics) evals. OpenPipe and other providers make deployment trivial via OpenAI-compatible APIs. The talk delivers a concrete decision framework and a walkthrough so any engineer can fine-tune in under an hour.

Which Jobs Can Be Replaced Today: Fryderyk Wiatrowski and Peter Albert

Feb 6, 2025 · 19:59

Fryderyk Wiatrowski and Peter Albert, co-founders of Zeta Labs, argue that autonomous browser agents will first replace reactive jobs—like customer support and scheduling—by automating low-leverage tasks while preserving human focus on high-leverage activities. They propose a trigger-pool system where agents react to emails, Slack, or events, requiring only approval for actions. Peter details building reliable agents: start with prompting optimized for model distribution, then add cognitive architectures (e.g., planning, scratchpads) to split tasks, and finally fine-tune with synthetic data or reinforcement learning. He advises minimizing noise in prompts, preferring text-based reasoning over images, and using language model judges to filter training data. The founders see continuous model improvement enabling agents to handle increasingly complex, proactive roles, moving toward full job replacement.

Best Practices for Evaluating Large Language Model Applications with llmeval: Niklas Nielsen

Feb 5, 2025 · 9:33

Niklas Nielsen, CTO and co-founder of Log10, introduces llmeval, a command-line tool that enables teams to ship reliable LLM applications by evaluating and testing prompts and configurations. The tool initializes with four lines of code, uses Meta's Hydra for configurable test structures, and runs multiple samples (default 5) per test to assess stability. Nielsen demonstrates prompt engineering for a math problem, showing how stripping spaces or adding instructions like 'only return the answer' affects strict pass/fail results across Claude, GPT-4, and GPT-3.5. Advanced use cases include testing tools for Python code generation and model-based evaluation, where a larger model grades outputs on criteria like mermaid diagram quality. He notes pitfalls: models favor their own output and struggle with point scores. Log10 addresses this by bridging model-based and human feedback—collecting prior human ratings to train an 'auto-John' that pre-fills reviews for new completions.

Cooking with fire without burning down the kitchen: Dominik Kundel

Dec 31, 2024 · 20:35

Dominik Kundel, who leads product and design for Twilio's Emerging Tech & Innovation team, explains how the company balances disruptive AI innovation with its existing communications and customer data platform businesses. He distinguishes sustaining innovation (e.g., Apple's AI features) from disruptive innovation (e.g., agents not yet enterprise-ready due to quality and cost), arguing that ignoring disruptive AI is increasingly dangerous because quality improves daily. Kundel shares three key lessons from Twilio's AI journey: first, ship early and often—even rough prototypes—to gather real feedback, which led to the Twilio Alpha sub-brand for setting expectations; second, build a curious, problem-owning team rather than requiring existing AI expertise; third, share learnings internally and externally to avoid operating in a silo and to help customers be thought leaders. He recounts how an initial AI personalization engine was too disruptive for mainstream R&D, so the team iterated on an AI Assistance agent builder, using internal hackathons and dogfooding with low-risk use cases like IT helpdesk to improve quality before broader release.

E-Values Evaluating the Values of AI: Sheila Gulati and Nischal Nadhamuni

Dec 31, 2024 · 28:13

Sheila Gulati (Tola Capital) and Nischal Nadhamuni (Klarity CTO) argue that evaluating AI systems is at a seminal moment, requiring a shift from simplistic benchmarks to multi-faceted, user-centric approaches. Gulati highlights the inadequacy of current leaderboards, citing benchmark hacking and the need for dynamic datasets and value alignment. Nadhamuni shares how Klarity, which raised a $70M Series B, tackles eval challenges in its document-processing product—processing over 500K documents for customers with 15+ LLM use cases. He details practical strategies: front-loading UX risk, thinking backwards from user experience, reducing degrees of freedom by standardizing prompt engineering across customers, and building scrappy future-facing evals. The episode emphasizes that the AI engineer community must innovate benchmarks, bring depth and community sharing to evaluations, and introspect the values instilled in AI systems.

Understanding AI Stakes to Break Production Code: Philip Rathle

Dec 31, 2024 · 23:24

Philip Rathle, CTO of Neo4j, argues that the level of 'stakes' in an AI application determines the production barriers and appropriate solutions, from low-stakes summarization to high-stakes uses requiring knowledge graphs and human-in-the-loop systems. He distinguishes pilot (full autonomy) from co-pilot (human oversight), showing how vector RAG solves moderate stakes but fails for high-stakes needs like tightening bolts on a 737 MAX 9. He promotes Graph RAG for deterministic reasoning and fact retrieval. Attendees share learnings: using LLMs to write code rather than reason directly, adapting to user keyword habits, focusing on few projects with achievable accuracy, building eval pipelines early, and for regulated loans offering three options with explanations instead of a single recommendation.

AI Frontiers in Trust and Safety Combatting Multifaceted Harm on Tinder at Scale: Vibhor Kumar

Dec 2, 2024 · 14:36

Vibhor Kumar, senior AI engineer at Tinder, explains how the company uses open-source LLMs and LoRAX to detect a long tail of trust and safety violations at global scale. Facing challenges like content pollution and automated fraud from generative AI, Tinder leverages pre-trained models such as LLaMA and Mistral, fine-tuning them with LoRA and QLoRA on hybrid datasets generated by GPT-4 and manually verified. They serve dozens of fine-tuned adapters on a single GPU using LoRAX, achieving real-time inference (tens of QPS, ~100ms latency) for categories including hate speech, pig butchering scams, and underage users. The approach yields near 100% recall on simpler tasks and significant improvements over baselines, with better generalization that resists adversarial evasion. Future directions include visual language models for explicit image detection and automating retraining pipelines.

Moondream: how does a tiny vision model slap so hard? — Vikhyat Korrapati

Nov 14, 2024 · 19:26

Vikhyat Korrapati built Moondream, a tiny open-source vision language model under 2 billion parameters that matches LLaVA 1.5, a model four times its size, on VQA v2 and GQA benchmarks. He attributes this to focusing on image understanding over world knowledge and investing heavily in synthetic training data—a pipeline that generated 35 million images and used two orders of magnitude more compute on data than training. Key lessons: community engagement was critical, open-source builds trust, and safety guardrails should be application-layer, not baked in. He argues tiny models will dominate production due to cost and privacy advantages, and that prompting will replace custom model training for most vision tasks. Moondream raised a seed round from FullySysAscent and the GitHub Fund.

Code Generation and Maintenance at Scale: Morgante Pell

Oct 17, 2024 · 18:54

Morgante Pell, founder of Grit, argues that AI agents for code generation must be built for modifying large existing codebases rather than generating new apps, and that combining static analysis with AI enables reliable migrations at scale. Grit has merged more PRs than any other company by focusing on supercharging top engineers, using GritQL to precisely find code via syntactic and semantic queries, and relying on compilers like TSC to catch errors that LLMs miss. They overcome slow enterprise builds (10 minutes for type checking) by precomputing in-memory indexes and using Firecracker to snapshot and fork environments for parallel agent execution, achieving PRs with only a few iterations. For editing, they developed a custom 'loose search and replace' format to avoid expensive full-file generation and LLM laziness. This approach allowed one customer to complete a multi-year OpenTelemetry migration in a week with under 100 developer hours. Morgante envisions future UIs that let engineers manage entire codebases like SimCity.

Realtime Data Connectivity for AI: Tanmai Gopal

Oct 11, 2024 · 7:14

Tanmai Gopal from Hasura introduces Pacha DDN, an AI-powered data access layer that lets LLMs securely query live data from multiple sources, arguing that the key is treating all data—structured, unstructured, and APIs—with a unified SQL-based query language. He demonstrates with a Blockbuster example: writing an email to a top customer by querying database transactions and recent rentals via natural language. The system uses an object model for authorization that applies rules based on data schema and session properties, regardless of data origin. To overcome LLM reasoning limitations, Pacha DDN asks the LLM to write Python code to retrieve data instead of reasoning directly. The talk concludes that for AI to be useful, it needs realtime data access, and Pacha DDN provides a secure, explainable query planner to achieve that.

Architecting and Testing Controllable Agents: Lance Martin

Oct 11, 2024 · 2:21:54

Lance Martin presents LangGraph, a graph-based framework for building controllable agents that trade some open-ended flexibility for significantly higher reliability compared to classic React agents, achieving 100% consistent tool-calling trajectories even with an 8B local model. He demonstrates self-corrective RAG patterns like Corrective RAG, SelfRAG, and Adaptive RAG, where the agent grades retrieved documents, checks for hallucinations, and routes to web search when needed. Martin also covers three testing loops: in-app error handling with LangGraph, pre-production evaluation using LangSmith to compare agent answers and tool trajectories against ground-truth datasets, and production monitoring with online evaluators that flag retrieval quality, answer relevance, and hallucinations without reference answers. He shares results from a five-question evaluation showing LangGraph agents achieve 80% answer accuracy and 100% tool-trajectory correctness with Fire Function V2, while React agents with GPT-4o degrade in tool reliability. The talk addresses practical concerns like handling many tools (suggesting RAG for tool selection), multi-turn conversations, and the importance of…

Breaking AI's 1-GHz Barrier: Sunny Madra (Groq)

Oct 10, 2024 · 20:11

Sunny Madra (Groq) argues that LLM inference speed is undergoing a transformation akin to the 1-GHz microprocessor breakthrough, with Groq increasing LLaMA 3 8B speed by over 50% in just two months. He draws parallels to the industrial revolution: just as mass production replaced bespoke manufacturing, AI now enables 1,000 outputs in a minute where previously one designer produced one per day. Specific applications like Globe.Engineer plan a trip in seconds by processing 10,000 input tokens per second. Madra envisions LLMs as future OS cores, enabling instantaneous decision-making, universal natural-language interfaces, and multi-agent collaboration that allows smaller models to compete with larger ones. Edge AI projects like hyperspace.ai distribute unused GPU compute, and personalized education (citing Khan's two-sigma effect) becomes practical with cheap inference. He also highlights automated data science agents (Pioneer) that run endlessly, discovering correlations like productivity decline after certain performance reviews. The episode underscores that speed unlocks predictive analytics, context-aware systems, and enhanced security against AI-powered scams.

Making Open Models 10x faster and better for Modern Application Innovation: Dmytro (Dima) Dzhulgakov

Oct 9, 2024 · 18:55

Dmytro Dzhulgakov, CTO of Fireworks AI, argues that open-source models are the future for GenAI applications because they offer lower latency, lower cost, and domain adaptability compared to proprietary models. He explains that open models can be up to 10x faster for narrow domains and cut costs significantly, using examples like fine-tuned Llama 3 for function calling. Fireworks addresses the challenges of setup, optimization, and production readiness with a custom serving stack that delivers the fastest inference for long prompts and image generation (e.g., SDXL). He highlights FireFunction V2, an open-source model for function calling that combines chat and tool use, and notes that Fireworks serves over 150 billion tokens per day for companies like Quora and Cursor. The talk emphasizes that platforms like Fireworks enable developers to start with serverless inference, fine-tune models, and scale to enterprise-grade deployment with dedicated hardware.

How to Construct Domain Specific LLM Evaluation Systems: Hamel Husain and Emil Sedgh

Sep 19, 2024 · 18:45

Emil Sedgh (CTO at Rechat) and Hamel Husain (independent consultant) describe how they built a domain-specific evaluation system for Lucy, an AI assistant for real estate agents, to move beyond vibe checks and achieve production reliability. They argue that systematic evaluation starts with simple unit tests and assertions based on observed failure modes, logging traces for human review with custom tools to remove friction, and using LLMs to synthetically generate test inputs. The presenters emphasize that focusing on process over tools, avoiding generic off-the-shelf evals, and not jumping too early to LLM-as-a-judge are critical to success. This eval framework enabled Rechat to rapidly increase Lucy's success rate and made possible fine-tuning for complex tasks like mixing structured and unstructured outputs, handling multi-step commands that invoke five or six tools, and incorporating user feedback loops—capabilities they could not achieve with few-shot prompting alone.

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.

Building with Anthropic Claude: Prompt Workshop with Zack Witten

Aug 17, 2024 · 1:34:56

In this live prompt engineering workshop, Anthropic's Zack Witten and Jamie Neuwirth demonstrate techniques for improving Claude prompts in real time, using the Anthropic console. They show that XML tags clearly separate prompt sections, that placing instructions after information improves adherence, and that prefilling assistant responses with opening JSON or tags reliably forces JSON output without preamble. Witten advises using stop sequences and code to handle formatting rather than over-prompting, and emphasizes that few-shot examples—especially contrastive pairs with reasoning—drive more improvement than any other technique. The workshop covers role-playing multiple personas by routing via code, mitigating hallucinations by extracting quotes before summarization, and grading translations with chain-of-thought and fine-grained examples.

GPT Web App Generator - 10,000 apps created in a month: Matija Sosic

Jan 26, 2024 · 9:23

Matija Sosic, CEO and co-founder of Wasp, demonstrates how his team built mage, a GPT-powered full-stack web app generator that produced over 10,000 applications in one month. Mage specializes in generating React, Node.js, Prisma, and Wasp apps from plain English descriptions, thanks to three key factors: specialization in full-stack web apps, leveraging Wasp's high-level declarative configuration to reduce boilerplate and errors, and an automated error-fixing phase. A typical app uses 25,000 to 60,000 tokens and costs 10 to 20 cents by combining GPT-3.5 for implementation and GPT-4 for planning, versus $1–$2 with GPT-4 alone. Mage serves as a highly customized cross-starter, with current limitations around lack of interactive debugging, which is planned next. Future directions include live debugging and potentially fine-tuning an LLM for Wasp.

Domain adaptation and fine-tuning for domain-specific LLMs: Abi Aryan

Nov 14, 2023 · 25:09

Abi Aryan's talk covers domain adaptation and fine-tuning for large language models, contrasting prompting, RAGs, and three fine-tuning methods: adaptive, behavioral, and parameter-efficient. Adaptive fine-tuning adds small adapter modules (0.15% of parameters) for new domains like biochemical engineering; behavioral fine-tuning optimizes label space for a single task; and parameter-efficient methods like LoRA and QLoRA reduce model size via low-rank adaptation and four-bit precision, ideal for low-resource devices. Aryan emphasizes data quality—deduplication reduces memorization—and practical tips: batch size of 32 or 64, starting with 100 epochs, using Adam optimizer, gradient checkpointing for memory savings, and in-context learning with dynamic examples to handle drift. Evaluation should combine metric-based (Bleu, Rouge), tool-based (Weights & Biases), model-based, and human-in-the-loop approaches, though full pipeline considerations (data collection, base model choice, storage) are critical for robust applications.

[Workshop] AI Engineering 101

Nov 6, 2023 · 3:02:24

In this hands-on workshop, AI engineer Noah Hein teaches the basics of AI engineering by building five projects with OpenAI's GPT-3, GPT-4, Dall-E, Whisper, and Telegram. Participants create a Telegram bot that uses GPT-3 for chat, implements retrieval-augmented generation (RAG) with embeddings and cosine similarity on MDN docs, generates code with GPT-4 using few-shot prompting, creates images via Dall-E 2, and transcribes voice with Whisper. The session explains core concepts like tokens, chunking, context windows, temperature, and top-p, emphasizing that embeddings and prompt engineering are key to performance. Hein demonstrates that these tools are cheap and accessible—the entire workshop costs about $0.05 in API fees—and shows how AI engineers can integrate multiple models into a single application.

See, Hear, Speak, Draw: Logan Kilpatrick & Simón Fishman

Oct 24, 2023 · 18:43

OpenAI's Simón Fishman and Logan Kilpatrick argue that 2024 will be the year of multimodal models, showcasing how text can currently bridge vision, audio, and image generation. They demo a DALL-E vision loop where GPT-4 with vision describes an image, DALL-E 3 generates a synthetic version, then the models compare and iterate to improve accuracy—all in roughly 50 lines of code. Another demo extracts frames from a video, uses GPT-4 with vision to describe them, combines with Whisper's transcript, and generates a blog post with matching DALL-E images, making video content more accessible. They emphasize that while today's multimodal capabilities are separate, future unified models will directly reason across modalities, eliminating the need for manual integration.

The 1,000x AI Engineer: Swyx

Oct 23, 2023 · 9:27

Swyx argues that AI engineers are just in time for a 1,000x opportunity, drawing on historical tech cycles and compute scaling laws. He cites Carlota Perez's tech revolution cycles, placing the AI revolution's start at AlexNet in 2012. With compute growing 600x by decade's end, GPT-3 took one person-year of compute, GPT-4 took 100, and GPT-10 will exceed all human compute ever. He defines three AI engineer types: AI Enhanced (Copilot-like), AI Product (Midjourney), and AI Agent (Auto-GPT). To achieve 1,000x, he advises scaling knowledge from O(n) (attending talks) to O(n²) (teaching others) to O(2^n) (building networks).

Principles for Prompt Engineering - Karina Nguyen (Claude Instant @ Anthropic)

Oct 20, 2023 · 55:31

Karina Nguyen, an engineer on Anthropic's Claude, presents principles for effective prompt engineering, treating it as a creative writing process requiring iteration. She advises using XML tags, placing instructions at the end of long prompts (improving accuracy), and decomposing questions to improve faithfulness over chain-of-thought. She covers reducing hallucinations by asking Claude to hedge or quote sources, and using self-consistency and contrastive examples for labeling. Nguyen explains generating evaluation datasets with Claude by splitting documents into multiple-choice questions, and notes that for long-document QA, asking at the end outperforms the beginning. She distinguishes Claude (larger, smarter) from Claude Instant (cheaper, faster, better at math and code), and predicts prompt engineering will remain essential for complex tasks.