Anthropic

The Design-Code Roundtrip That Isn't — Jonathan Gordon, ReWeaver AI

Sep 10, 2026 · 18:37

Jonathan Gordon, founder of ReWeaver AI, argues the design-code roundtrip still doesn't exist: thirty years of developer tooling never closed the loop between design and engineering, and AI didn't fix it. After a vibe coding session where he caught an agent writing a risky innerHTML statement, he tested five tool setups for a bidirectional code-design loop and found every one lossy, with dropped bindings or design changes surviving while code didn't. He demos ReWeaver publicly for the first time, scanning generated code and a Figma canvas across nine dimensions including design consistency, performance, tokens, and accessibility, flagging issues like missing ARIA live regions that leave screen reader users with no announcement. In a 12-iteration experiment, pure model output started near 30% fidelity and decayed, while deterministic guardrails held quality up; it never reaches 100 because the last stretch is human judgment. His name for drift accumulating unwatched: the new tech debt.

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked

Sep 9, 2026 · 14:09

Brandon Waselnuk of Unblocked argues that AI-generated code should feel like it was written by someone who has been on your team for years, and that the gap is no longer intelligence but context. He traces how bad context compounds as teams move from tab completion to parallel and background agents, producing correction doom loops, wasted search tokens, and a review tax. Two common fixes stall: the curated context trap, where markdown files rot and someone must curate them for everyone, and the MCP plateau, where an agent may never call the server or stops at the first plausible answer due to satisfaction of search bias, missing last night's Slack correction. A context engine must resolve conflicts between an old architecture diagram and a fresh CTO Slack thread, personalize relevance, enforce permissions, and deliver token-optimized context. Running the same prompt with and without context cut tokens from 21 million to 10.8 million and finished about two hours sooner. He closes by demoing three open source tools, including a workshop that builds a relational context engine from scratch.

500 Skills, Zero Fine-Tuning: LinkedIn's Playbook for AI Agents — Ajay Prakash, LinkedIn

Sep 9, 2026 · 20:25

Ajay Prakash, senior staff software engineer at LinkedIn, explains how Contextual Agent Playbooks make coding agents reliable at enterprise scale, turning an on-call alert into a mitigated incident in minutes. Early vibe coding failed: agents trained on open source hallucinated across LinkedIn's 1,000 internal repos. An internal MCP server with code search, docs, and Jira fell short: tribal knowledge sat in stale wikis, context overloaded, and sessions started from scratch. Playbooks, instructions published as tools, work when self-contained and split into small referenced pieces, and agents open PRs to refresh stale ones. Since MCP degrades past 30 or 40 tools, everything surfaces behind three meta tools: search, get schema, execute, now 1,300 tools, 600 playbooks, 8,000 daily users.

It’s Tokens All The Way Down: How RLMs are Different — Kevin Madura, AlixPartners

Sep 9, 2026 · 20:48

Kevin Madura, director of advanced technology at AlixPartners, argues that recursive language models (RLMs) mark a fundamentally different way for LLMs to handle context: instead of attending to every token, the model treats its context as a variable in a Python REPL and delegates subtasks to sub-LMs, including itself. He traces RLMs to early work by Omar Khattab and Alex Zhang, citing the Oolong and BrowseComp benchmarks, where an RLM beats GPT-5 tool calling at lower cost, and the long chain of thought benchmark, where accuracy jumps from 2.6 to 45.4 percent. Unlike RAG, which stuffs the context window, or agents that pass JSON strings back and forth, an RLM keeps logic, execution, and results in one environment, avoiding context rot. Madura demonstrates a cohort retention analysis on three data frames where the model reasons in its own REPL and decides when to submit a typed answer. Case studies include Trampoline AI consolidating long invoices without chunking or embeddings, an AWS engineer surfacing patterns in raw logs, Halo optimizing an agent harness from its own traces, and a security report generated across 500,000 lines of code. His closing bet: models post-trained to…

When AI Agents Pay and Sellers Monetize: Building x402 Apps on AWS — Anil Nadiminti, AWS

Sep 1, 2026 · 20:41

Anil Nadiminti, Senior Solutions Architect at AWS, presents AgentCore Payments — a service that lets AI agents autonomously discover, authorize, and execute payments for premium content over the x402 protocol. He explains how AgentCore handles paywalls through wallet support via Coinbase, with KMS-secured secret storage keeping private keys safe. Bot detection verifies trusted agents while blocking malicious ones, and per-session budgets with spend limits keep settlement instantaneous at internet speed. Real-time traffic analysis and observability throughout the stack ensure payment connectors, MCP5 integration, and web scraping all operate without exposing credentials — no centralization required, no SDK change, and no friction for developers building agentic applications.

The Half Life of Agent Infrastructure — Ben Kus, Box

Aug 29, 2026 · 19:26

Ben Kus, CTO of Box, explains why AI agent infrastructure has a half-life of months, not the three-to-five years typical of enterprise software. He retracts his own graph-based agent approach from last year's talk, and recounts asking an engineer to rebuild working agentic search twice in quick succession. At Box's scale — over an exabyte of data and around a trillion tokens — models, agent design, and retrieval have each shifted repeatedly. His advice: prepare teams to expect change, build abstractions that let underlying layers be swapped, and switch only when eval sets show measurable gains in cost, speed, quality, or capability. Box now reviews every AI technology on a six-month clock, and he suggests judging vendors by how well they handled past changes.

AI-Native Organisations Run on Skills: How to Structure and Scale Them — Imad Touil, QuantumBlack

Aug 28, 2026 · 20:31

Imad Touil of QuantumBlack argues AI-native organizations run on skills, where know-how lives, and ungoverned skills become technical debt. Most engineers create skills but few share or maintain them, so workflows are nondeterministic; hooks fire on events, subagents protect context windows, and teams rarely write MCPs. Using microservices design, he prescribes reusable, modular, discoverable, composable skills, citing Anthropic's standard and a skills bench where deterministic skills beat models alone. His centralized platform—searchable catalog, MCP/CLI access, dependencies, versioning, access control, evaluation—counters duplication, decay, ownership gaps, and insecure skills; governance falls to architecture, infra, and cyber leads; a 15-team simulation shows convergence once governed.

How to avoid disaster when vibe-coding a billing engine — Andrew Garvin, Stripe

Aug 28, 2026 · 17:49

Andrew Garvin, co-founder of Metronome, the usage-billing platform Stripe acquired this year in its largest deal ever, argues that billing engines carry deep business logic, so a coding agent should build a test environment while a human stays in the loop — demonstrated by a Stripe Projects workflow replicating Lovable's pricing model. He demonstrates a billing sandbox that provisions a customer, metered usage, scoped credit pools for builds, plan mode, cloud and gateway calls, and a draft invoice, using portable skills files and verbose errors so the agent can self-correct. He separates agent as product, buyer, and user, pointing to HubSpot's move from seats to credits as one agent does the work of many logins. Stripe's CLI use by coding agents has risen exponentially.

How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic

Aug 27, 2026 · 26:11

Instagram co-founder Mike Krieger, now an individual contributor at Anthropic's Labs, argues for being 'unreasonable' with Claude—he had it port a few hundred thousand lines of Python to TypeScript over a weekend. He attributes timid asks to first-gen AI's boxed tools; cites Instagram-era habits (pre-measure everything, knobs); and explains tagging Claude in Slack as multiplayer delegation. Labs runs two-week 'persevere or pivot' reviews, bet leads manage nobody, and code review is bottlenecked by comprehension, so 2,000-line PRs travel with artifacts explaining intent and tradeoffs. He also sketches Claude Design's future, urges unship of product complexity, and advises startups to bet on verticals like finance. On burnout: no job is so important you cannot be offline for two days.

Reverse-Engineering the AI Buyer — Aliisa Rosenthal, Acrew Capital

Aug 26, 2026 · 19:10

Aliisa Rosenthal, who helped take OpenAI's enterprise business from a couple million to several billion in revenue, argues founders should build the automated sales machine before hiring humans. ChatGPT launched with no enterprise features; nine months later they shipped an expensive product, but self-serve cannibalized it four months on. Advice: capture phone numbers at signup, reply to every inbound (10,000 a day), never give buyers homework, avoid pilots via reference calls, data evals, or 90-day opt-outs. $60 per user per month was too high; a low base fee plus usage spread. Automate security, don't pull up-market, hire AI-native sellers when buyers need contact, and use forward deployed engineers sparingly—scarce but sticky. First 10 customers should be handpicked design partners, and POCs aren't self-serve.

Agent Frameworks Considered Harmful — Rémi Louf, .txt

Aug 22, 2026 · 20:29

Rémi Louf, CEO of .txt, argues agent frameworks are harmful because they keep agents trapped in code; he built a runtime where agents are markdown files triggered by events. Taking two weeks away from his 15-person company, he wanted a morning briefing that processes voice notes, market news, and CRM updates. Each failure in the first week led to infrastructure: an append-only log, a real queue, and content-addressed prompts stored as hashes, enabling diffing and replaying runs. He insists typed tool calls and typed events are non-negotiable boundaries, since 20% of his events were malformed and rejected. After deploying it, 20 agents now run, and he replaced third-party APIs with open-source models. His advice: build before you buy.

Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic

Aug 22, 2026 · 19:53

Sachin Malhotra of Anthropic's CI team argues agents deserve budgets, not tokens, citing an agent that deleted 200 workloads in 90 seconds using his token, hitting 20 engineers. A token is a boolean; a budget has four dimensions: how much, how fast, what can be undone, and who notices. He proposes asymmetric verbs — let agents unskip tests (fails loudly) but keep humans on skip (fails silently) — plus refilling rate limits on every write and trip wires that watch aggregate counts rather than stale allow lists. The undo test decides the rest: if the agent can't roll back and blast radius matters, require a second key held by a human. And identity must be stamped by a proxy, not claimed by the caller, or the agent changes its header and every limit resets.

Unlock Agent Autonomy: The Runtime for AI-Native Systems — Tushar Jain, Docker

Aug 20, 2026 · 22:50

Tushar Jain of Docker argues safety, not intelligence, is the blocker to agent autonomy, proposing a runtime beneath every model and harness. His evidence: a nightly agent that posted a private report as a PR, and an incident agent that widens access from logs to Slack to GitHub. The runtime has three pillars: containment with controls outside the agent's boundary, just-in-time tools scoped per task, and intent-based access that refuses off-task asks like email. Docker's new SPX tool runs agents in micro-VMs with injected stub credentials and scoped sandboxes locally, in the cloud, or in a VPC. Demos split a PR-review and Notion-writing job across two sandboxes, fan out to six parallel sandboxes, and show an early prototype auto-creating a scoped sub-sandbox for GitHub.

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End

Aug 20, 2026 · 16:39

Dan Bjornn, senior data scientist at Lease End, explains why his team's fine-tuned LLM for customer intent—despite bringing in $12 million at a 50x ROI—became tech debt. The fine-tuning pipeline took a week per retrain, with training itself the shortest step, and each fix caused regressions, so bugs were triaged by tolerable customer pain. He calls this the calcification tax: the model locked them into one provider and an outdated architecture, preventing upgrades. The rebuild swapped the tuned model for skills, prompts, and context on a model-agnostic framework, letting fixes ship in under an hour as uploaded files. Accuracy went up, cost per message rose, but total cost fell. Bjornn concludes fine-tune only when you cannot call a frontier model, and even then the decision must beat the tax.

Prototyping as Leadership: How a CTO Ships with AI Agents — Hursh Agrawal, The Browser Company

Aug 20, 2026 · 18:18

Hursh Agrawal, CTO and co-founder of The Browser Company, argues AI coding agents let leaders keep building: despite 15+ meetings, 7 direct reports, and a toddler, he ships 2–10 PRs/week. He says frontier models turn over every three months, so hands-on building is the only way to judge them and show engineers working prototypes. His method is an overnight loop: a coworker agent gathers Slack/Jira/Notion context into a prompt at 5pm, coding agent runs for hours, and a morning hour reviews tests, CI, and AI code review. He details three overnight uses: building features, hill-climbing evals from feedback JSONs, and training custom models like a PII classifier on AWS. He warns leaders to avoid critical path work and to rely on trustworthy CI, feature flags, a prototype branch, and readable PRs.

Your Agent Evolved. Your Evals Didn't. — Ameya Bhatawdekar, Braintrust

Aug 20, 2026 · 24:13

Ameya Bhatawdekar, Field CTO at Braintrust, argues that evals are the durable asset across AI replatformings and must move with each architectural generation. He traces five generations—single prompt, retrieval chain, ReAct loop, workflow graphs, and the return of loops with newer models—grounded in a site reliability agent, showing how each added failure surfaces: parsers, retrievers, branch logic, node contracts, classifier misfires, and trajectory variance. New metrics like pass@k (succeeds at least once in k attempts) measure capability, while pass^k (how many of k succeed) measure reliability. He urges harvesting production data into evals via the flywheel, and says Braintrust's Topics clusters production data to surface unanticipated failure modes.

Why Your Enterprise Tech Stack Isn’t Ready for AI Agents — Christopher Lovejoy & Saul Howard

Aug 19, 2026 · 19:15

Christopher Lovejoy of Anthropic and Saul Howard of Anteria argue that enterprise stacks aren't ready for AI agents; regulated industries need primitives, not bolted-on compliance. An audit trail isn't a developer log: under HIPAA it must record every action, data access, and authorization, so they use an immutable append-only event log. Patient data lives in schema-driven object storage referenced by events, letting devs debug without PHI, enabling zero trust against prompt injection. Escalation treats humans and models as equivalent agents, enabling the same actions by either. These primitives make privacy-preserving evals a byproduct, enabling replay of production data and evaluation in customer environments without exposing data; take constraints first and rebuild toward POC accuracy.

Trading Desks to Clinical Trials: Parallels in Applied Vertical AI — Ayush Bhardwaj, Allos AI

Aug 19, 2026 · 20:02

Ayush Bhardwaj, who applied AI at a hedge fund before pharma tech startup Allos AI, argues vertical AI projects die from not being able to judge whether they work. His seven-step recipe: narrow tasks, proprietary data, expert-modeled prompts, observability, then hiring the user—a domain expert—because using LLM-as-judge is a "stupid mistake" that jargons its way out. Verifiable rewards fail in finance and pharma: no answer keys, and data is withheld—30% of firms never disclose clinical trials, and the FDA publicly reminded over 2,000 sponsors in 2026. He says 89% of enterprise AI agents never reach production; the fix is endless expert-in-the-loop learning, starting with error analysis as highest ROI. Moat is never model or infra; only curated domain expertise and proprietary data matter.

Intelligence + Continual Learning = Expertise — Yu Su, NeoCognition

Aug 12, 2026 · 19:43

Yu Su, professor at Ohio State and CEO of NeoCognition, argues that the AI field conflates intelligence with expertise, and that scaling raw intelligence alone yields the 'world's smartest novice'—brilliant at isolated problems but accumulating nothing between them. He explains why coding agents succeed while other digital work remains brittle: code is a language-native, symbolic world with tests as rewards, whereas modern society is 'millions of micro worlds' with idiosyncratic local physics too heterogeneous for a static model to compress. Expertise, he contends, is accumulated, situated competence that compresses search space through learned shortcuts, and continual learning—defined as 'adaptive compression of experience into reusable structures'—is the bridge from intelligence to expertise. He presents a figure plotting raw intelligence against expertise as largely orthogonal, and proposes the goal of 'unbounded expertise from bounded intelligence': once intelligence crosses a…

Claude Managed Agents and Evolution of Agentic Surfaces — Gagan Bhat & Isabella Kai He, Anthropic

Aug 11, 2026 · 31:24

Gagan Bhat and Isabella Kai He of Anthropic's Applied AI team explain how agentic surfaces evolved from the Messages API to the Claude Agent SDK and now Claude-managed agents, arguing that harnesses encode assumptions about model limits that go stale as models improve. They detail decoupling the brain (agent loop) from the hands (tool execution sandbox), which cut time to first token by 60% at P50 and over 90% at P95, and made failures recoverable via durable session logs. The session log also powers observability, context recovery, and 'dreaming,' a batch process that rewrites agent memory for self-improvement. They cover production lessons: keeping credentials in vaults, self-hosted sandboxes for VPC control, MCP tunnels for private servers, and the 'outcomes' feature that uses a grader agent to enforce success criteria.

Multiplayer agentic engineering — Arjun Singh, Superconductor

Aug 9, 2026 · 18:44

Arjun Singh explains how Superconductor enables multiplayer agentic engineering by making agents model-agnostic, cloud-isolated, and reachable from Slack, desktop, and GitHub as one shared session. He argues agents should run in a configurable network sandbox for least privilege, letting non-technical staff trigger real work without dev setups; a meeting bot left in a Google Meet at their expo booth picked up a passerby's idea, opened a ticket, and added acceptance-criteria fields. He advises benchmarking agents on your own codebase because SWE-bench is Python while they are Ruby on Rails, citing one month: 10.5 billion tokens, 3,300 Claude Code runs worth about $10,000, and Codex running four times as many sessions for less money. Takeaways: sandbox your code, integrate agents into human interfaces, stay model-agnostic.

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.

Anthropic's CCA Exam as a Field-Guide for Agentic Engineering — Frank Coyle, UC Berkeley

Aug 8, 2026 · 20:08

Frank Coyle uses Anthropic's Claude Certified Architect exam as a field guide for agentic engineering: anti-patterns—knowing what not to do—are the key to agent design. In a customer support loop, the anti-pattern is calling the model and using its response directly; the model cannot execute tools, only hands back parameters, so branch on the stop reason, which also flags partial answers when tokens run out. For multi-agent research, loading one agent with every tool is the carpenter with plumbing gear; instead specialize subagents with one or two tools and give each only its own slice. A critic agent gets the claim and evidence but not the reasoning, to avoid groupthink, and subtask output is forked so only summaries return, with compaction past 150,000 tokens. Batch mode runs the same work at 50% lower token cost if you can wait 24 hours.

The New Primitives: Building AI Native Software — Kwindla Kramer, Daily

Aug 7, 2026 · 21:14

Kwindla Hultman Kramer (Daily, Pipecat) argues that agents are the web pages of 1995—a primitive, not a destination—and the next target is AI-native software. He grounds this in 80 years of computing: Vannevar Bush's 1945 As We May Think predicted OCR, speech to text, and hypertext; the 1950s brought programming languages, the 1960s interactivity, the 1970s databases, then the personal computer. VisiCalc, he says, didn't eliminate accountants; it multiplied accounting work and created new roles, a counter to AI unemployment fears. He cites Apple's 1987 Knowledge Navigator and Tavas's real reimagining as prototypes. He closes with Gradient Bang, a multiplayer game he built with LLMs at the core of every interaction, showing asynchronous non-blocking context compression, long-running subagents, progressive skills loading, dynamic UI generation, and conversational voice.

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.

Local Models: Trust, Control, Optimization — Carter Abdallah, NVIDIA

Aug 7, 2026 · 43:21

NVIDIA's Carter Abdallah, Prime Intellect's Vincent Weisser, Arcee's Lucas Atkins, and NVIDIA's Chris Alexiuk argue open-weight models are the trustworthy foundation for enterprise and local AI. Atkins separates trust from safety: when Anthropic pulled Fable, enterprises chose Chinese open models for guaranteed availability, and open models are inspectable unlike closed APIs. Arcee pretrained a 400B model in six months; Weisser cites a customer that specialized an open model for finance in a week or two, beating Opus at a fraction of Haiku's cost. Alexiuk calls open weights the fix for 'mismanaged genius' and expects capable local models on MacBooks within a year; the panel predicts Fable-level open models within a year and hopes local-model use rises from a rounding error to 10–15%.

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.

MCP Apps: Extending the Frontier — Ido Salomon & Liad Yosef

Aug 2, 2026 · 18:38

Ido Salomon and Liad Yosef, creators of MCP UI and co-creators of the MCP Apps spec, explain how MCP Apps lets servers ship interactive branded UI instead of text into any supporting host. The official MCP extension, built with Anthropic and OpenAI and supported by Claude, VS Code, ChatGPT, Copilot, Cursor and Slack, links a tool call to a resource; the host renders returned HTML as a sandboxed web component and clicks flow back through a callback to the model. Early adopters include 11 Labs, Shopify and Postman; the payoff is distribution: with ChatGPT at 800 million weekly users, you write once and run everywhere. The spec is still evolving, with an open working group meeting every three weeks and live work on reusable views, AppTools/ViewTools for host-to-app control, and interoperability with generative UI standards like A2UI.

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

Aug 1, 2026 · 27:17

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

Verifiable Environments for AI in Biology — Kenny Workman, LatchBio

Jul 31, 2026 · 17:42

Kenny Workman, LatchBio's CTO, argues biology's data pipelines are a verifiable substrate for agentic AI, like code for software, so measurement drives progress. He grounds this in single-cell runs yielding 2-6 terabytes, explains LatchBio adapted coding models into biology tools, and found frontier models untrustworthy for real science. Workman details Spatial Bench's 146 problems split into verifiable chunks, and human verification exposed ambiguity that makes benchmarks uninformative. He covers long-horizon tasks like reconstructing a metastatic tumor niche—none solved yet—and rubrics at invariant chokepoints. He closes on biosecurity red-teaming, where routine questions are refused more often than sinister ones, framing it as a flywheel of better benchmarks, tools, and drug programs.

How Kepler Built Verifiable AI for Financial Services — Vinoo Ganesh

Jul 29, 2026 · 22:30

Vinoo Ganesh, CEO of Kepler, argues that AI in financial services must be augmented with a deterministic substrate to produce verifiable work product, because language models are probability machines unreliable for arithmetic. Kepler's three tenets—atomic provenance (every number ties to its source and stripped if unverifiable), scope determinism (model plans but never computes; deterministic tools handle math), and derivation chains (every number's origin replayable)—ensure numerical accuracy. The system treats each extracted number like a pull request, with reconciliation ensuring entities are caught and nothing invented. Ganesh contrasts citations (after-the-fact audit) with verification (deterministic proof), and notes that compliance with regulators like the SEC requires traceable decision-making. Customers are most excited about reclaiming analyst time from tasks like reading earnings transcripts and building financial models, rather than replacing portfolio managers.

Skills are new features: Building Skill-Centric Harness — Yogendra Miraje, FactSet

Jul 29, 2026 · 17:24

Yogendra Miraje, Principal AI Engineer at FactSet, argues that skills are the new features in agentic products, replacing traditional UI buttons and screens. He describes a minimal skill registry with name, description, and path, using progressive disclosure to load only relevant skill bodies. Trigger words in descriptions act as routing signals, with the example of 'PDF' directing the agent to the correct report skill. He warns that skills without evals drift when models change, citing a case where a new model ignored instructions at the end of a skill. Beyond ten skills, embeddings and similarity search are needed; past a hundred, governance becomes non-negotiable, requiring admission, ownership, versioning, periodic audits, and allowlist tools for boundaries.

AI tools for Forward Deployed Engineering — Vasuman Moza, Varick Agents

Jul 28, 2026 · 20:23

Varick Agents CEO Vasuman Moza and head of engineering JD Pruitt explain how forward deployed engineers (FDEs) design AI agents that sit on top of existing enterprise systems like SAP or NetSuite rather than requiring migrations—one customer spent $5M and five years on NetSuite, so Varick drops agents onto those systems. The bottleneck is understanding each business’s unique, undocumented workflows (e.g., when AP fails, Sarah sends to Chris, adding four days of cycle time). FDEs map these processes, re-engineer them around AI (automating four of eight steps, keeping human-in-the-loop for three, fully human for one), then deploy using Varick OS. To scale FDEs without hiring exponentially, Varick built an AI FDE agent that ingests granola notes and Slack threads, uses a Postgres-based dependency graph as a single source of truth, and post-trains open-source models (Kimi K26) to extract the right context and strip redundancy. JD outlines three stages: an engagement agent for querying documentation, a workflow agent that shadows FDEs inside the platform, and a future autonomous agent that handles client change requests (e.g., rerouting a QC report) without FDE involvement.

The Dirty Secret of Forward Deployed Engineering — Natalie Meurer, Sierra

Jul 28, 2026 · 16:49

Natalie Meurer argues that forward deployed engineering (FDE) has become a meaningless label because it has stretched from DevOps at Palantir in 2008 to data integration, ontology work in Slate and Foundry, solution architecture, and enablement—but its durable core is customer accountability and outcome-based pricing. Tracing FDE's history at Palantir, she shows how the role evolved from keeping the platform stable (2008) to data integration (2012), custom dashboarding in Slate (2016), and finally customer enablement in Foundry (2020). As coding agents make software cheap, she contends the lasting value lies in integrating data, understanding customers, and owning outcomes. Pricing tells the story: seat-based assumes a tool, while usage or outcome pricing puts the provider on the hook—exactly what FDEs have always done. She concludes agent engineering is FDE reborn, and that product, infra, and AI engineering are all trending toward the same customer-accountable model.

Forward Deployed Engineering 101 — Kevin Bai, Anthropic, ex Palantir & Rippling Founding FDE

Jul 28, 2026 · 17:48

Kevin Bai of Anthropic, formerly at Palantir and Rippling, argues that Forward Deployed Engineering (FDE) is the go-to-market motion for selling highly technical platforms to non-technical buyers, as Palantir did with its Foundry platform. The key is not building bespoke solutions from scratch but assembling outcomes on a reusable platform of shared primitives; otherwise it becomes a dev shop. FDE targets a specific quadrant: complex product + non-technical buyer, exemplified by Palantir's $4M average contract value vs. ServiceNow's $1.2M and Workday's $600K. Two questions determine need: is your product complex enough to require hand-holding, and do you have engineers who can carry that? AI has made building easy and nearly everything agentic, pushing FDE toward the center of software sales.

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.

Evals-Driven Development for a Mental Health AI Coach — Akele Reed & Dave Revere, SonderMind

Jul 25, 2026 · 21:17

SonderMind engineers Akele Reed and Dave Revere explain how they built Sonder, a clinically grounded Mental Health AI Coach, using eval-driven development and modular guardrails to balance effectiveness and safety. They designed input and output guardrails as separate LLM judges to avoid over-calibration and ensure correct triggers, not more triggers. Dave describes a clinical feedback loop where therapist annotations become typed evals that gate releases, turning clinician judgment into CI. They open-sourced 200 input and 100 output guardrail scenarios, clinically reviewed and calibrated. The system uses a Supervisor/Executor/Evaluator architecture, and they turned off built-in guardrails of frontier models due to over-calibration. Every architectural decision prioritized user safety, with modularity enabling iteration without compromising safety.

From Signal to PR: Anatomy of a Self-Improving Agent — Jason Lopatecki, Arize

Jul 24, 2026 · 20:36

Jason Lopatecki demonstrates how Arize's Signal agent transforms observability from human-clicked dashboards into telemetry for self-fixing systems. The key unlock is pulling production traces and logs as files into a repo—Claude Code works magically with files, not dashboards—so the agent sees the exact code path software took. Signal runs periodically or event-based in a sandbox (VPC-deployed for Uber, Booking), using composable skills to gather context, find root cause, and create a PR. Lopatecki argues you should trace and log ten times more because agents can read that smoke. For the question 'why not just point Claude Code at data?', he explains skills must be well-designed to fetch and format the right data into files. On evals, they run as LLM judges layered on production traces, pre-processing information for the agent to catch known failures and create new evaluators.

The Future of Evals: From LLM as a Judge to Agent as a Judge — Aparna Dhinakaran, Arize AI

Jul 24, 2026 · 6:06

Aparna Dhinakaran, co-founder of Arize AI, argues that as agents evolved from simple prompts to complex systems with tool calls, reasoning, and long-horizon tasks, evals must evolve too—from deterministic checks to LLM as a judge, and now to agent as a judge. She reveals that the top teams run over 3,800 different evaluators, yet classical LLM-as-judge evals fail to catch subtle failures in agents that generate unique trajectories per user. Arize's new tool, Signal, is a long-running agent that reads traces, discovers patterns like inefficient tool loops, and can even open a PR to fix issues. The episode traces this arc from static checks to adaptive analysis, emphasizing that the future of evals requires all three layers to handle the complexity of modern agents.

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.

CrabRAG: Why Automated Assistants Need Graph Memory, Not More Tokens — Stephen Chin, Neo4j

Jul 22, 2026 · 20:42

Stephen Chin of Neo4j introduces CrabRAG, a graph-based memory system that outperforms vector databases for AI agent reasoning. He demonstrates that markdown-based memory wastes over 100,000 tokens per round and that vector similarity fails at multi-hop questions. Using a home lab digital twin, he shows a graph agent correctly identifies his daughter's Minecraft server running outdated OS and exposed management ports, while the vector agent returns vague answers. Chin explains that graphs store relationships and enable precise, explainable, and auditable results, and that Claude can write Cypher queries for graph traversal. He announces his book 'GraphRAG: The Definitive Guide' and free training at Neo4j's Graph Academy.

Claude for Long-Horizon Tasks — Lance Martin, Anthropic

Jul 22, 2026 · 25:19

Lance Martin from Anthropic discusses how Claude's increasing task horizon enables asynchronous agents through decoupled architecture, verifier loops, and self-improving memory systems. He explains the shift from short task horizons (10–20 minutes) to 12+ hours, necessitating decoupling the brain (harness) from hands (sandboxes) for reliability and security. Verifier loops using separate contexts allow models to self-correct, demonstrated on the Parameter Golf benchmark with Opus 4.7. Memory systems inspired by human dreaming correct errors in-band, as shown in a Pokémon example where dreaming prevented repeated failures. Finally, org-level harnesses like Claude Tag provide shared identity and context for multiplayer proactive agents.

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.

Don't Let the LLM Drive - Ornella Bahidika & Joel Allou, Microsoft

Jul 20, 2026 · 6:08

Ornella Bahidika and Joel Allou of Microsoft present their voice tutor Ace, arguing that the LLM should never control the flow in multi-step agents. They built Ace with a state machine that confines the model to narrow contracts per step, letting the harness validate outputs and decide next actions. This design allows them to use a cheaper, faster model (Haiku 4.5) instead of a heavy reasoning model (Opus 4.7 Cloud). They identify three decisions the LLM must never own: when the lesson ends, whether the student answered correctly, and what comes next. By engineering these checks outside the model, Ace achieves reliability in production, avoiding loops and early terminations that plague prompted-only approaches. The pattern applies to any flow agent, including coding agents, runbooks, and onboarding flows.

Your Voice Agent Doesn't Need a Frontier Model - Joel Allou & Ornella Bahidika, Microsoft

Jul 20, 2026 · 5:45

Joel Allou and Ornella Bahidika from Microsoft present ACE, an AI voice tutor that deliberately uses a small model instead of a frontier model, arguing that latency—not intelligence—is the critical constraint in voice applications. They demonstrate that a frontier model's reasoning time of multiple seconds breaks conversational flow, while their system keeps model latency under 950 milliseconds by extracting all logic and planning into a deterministic state machine. This scaffolding handles lesson progression, student mastery tracking, and response generation, leaving the small model (Haiku 4.5) with only the task of speaking. The result: a 900-millisecond response time that feels instantaneous. They acknowledge that scaffolding requires strict rules to prevent drift, but call it a one-time code investment that unlocks cost-effective, real-time performance. The episode’s core lesson: pick the fastest model your latency budget allows, then invest in external scaffolding to make it smart.

When Agents Meet Physical Data: The Other Physics of Agent Harnesses - Dmitry Petrov, DataChain

Jul 20, 2026 · 27:33

Dmitry Petrov of DataChain argues that AI agents fail on unstructured physical data because their intuitions assume cheap recompute, while large-scale video, sensor, and robot data requires a different harness. He cites Anthropic's finding that agents achieve only 21% accuracy on data projects without specific data harnesses, and OpenAI's need for six layers of context even on structured data. Petrov demonstrates DataChain, an open-source Python framework that uses Pydantic schemas to turn messy binary files into queryable databases, an execution engine for distributed processing, incremental checkpoints to avoid recomputing on failure, and a knowledge base of datasets and source code so agents can answer follow-up questions in seconds instead of reprocessing terabytes. In a live demo with Claude Code analyzing 90 dashcam videos, the harness took 24 minutes to extract 100,000 object records, then instantly answered 'how many clips have people?' without rerunning inference. Petrov emphasizes that the key is organizing metadata into star schemas and sharing data lineage across teammates so no one pays the compute cost twice.

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…

Skills are the New SDKs - Elvin Aghammadzada, DataRobot

Jul 20, 2026 · 26:40

Elvin Aghammadzada of DataRobot argues that enterprise AI platforms must become 'teachable' through a skill layer—versioned, task-specific packages that encode operational knowledge for coding agents. He contends that context windows degrade after 25% usage (a phenomenon called 'context rot'), making progressive disclosure via skills critical for maintaining agent performance. Skills expose only metadata (<100 tokens) until activated, while MCP servers handle heavy resource isolation; skills can also self-modify and spawn MCP servers. With 26+ platforms (Claude Code, Codex, Copilot) supporting skills and 85,000+ published, the ecosystem is creating a 'fluency moat' where platform value compounds with each skill. However, LLM-generated skills currently hurt performance, and marketplaces lack verification controls, echoing early NPM risks. The episode positions skills as complementing MCPs, not replacing them, and urges versioning and testing as software.

Stop Renting Your Cognitive Infrastructure - Thiyagarajan Maruthavanan, Kalmantic Labs

Jul 18, 2026 · 7:52

Thiyagarajan Maruthavanan of Kalmantic Labs argues that AI teams should stop renting inference from providers like Anthropic and build their own infrastructure, coining "rent to learn, own to earn." He recounts his app UltraSuno costing hundreds of thousands of dollars in inference, a stolen key hitting $10,000, and moving to his own DGX Sparks hardware. Three enterprises—a fund, hospital, and tax practice—each hit walls with renting: control, audit redlining, and reproducibility. He open-sourced JustTokenMax (benchmarked better than Netflix's Headroom) and wrote the book "Peak Inference" on building your own inference infra. He notes the market's conflicting pitches (Jensen's token factory, Nadella's unmetered, NeoClouds' endpoints) but concludes owning is essential post-PMF.

Content Is Code - Matt Palmer, Conductor

Jul 18, 2026 · 10:53

Matt Palmer, head of developer experience at Conductor, argues that code is now the fastest way to produce technical content, shifting left to code as the source of truth. He outlines three eras of content creation—handcrafted, expensive code, and cheap code with AI—and claims that the scarce resource today is not code but structure and conscientiousness, meaning meticulous care in maintaining design tokens, brand guidelines, and clean codebases. AI rewards organizational excellence over raw technical skill, making the best communicating teams those that instill discipline and rigor into their software creation. Palmer predicts 2026 as the year of the creative technologist and 2027 as the year of the content engineer, with declarative pipelines that automatically generate documentation, walkthroughs, product tours, and updates from structured code.

Using LLMs to Secure Source Code — Eugene Yan, Anthropic

Jul 17, 2026 · 21:30

Eugene Yan of Anthropic details how frontier LLMs like Claude are reshaping software security, citing Mozilla's 20x surge in monthly fixes (to 400 in April 2025, two-thirds credited to Claude) and Anthropic's own scan of 1,000+ open source repos that uncovered 6,200 high/critical issues, 1,600 reported, and about 100 patched upstream. He argues that finding vulnerabilities is no longer the hard part; the bottleneck has moved to verification, triage, and patching. Yan outlines a six-step workflow: a written threat model (boosts true positive rate to 90%), an isolated sandbox for reproducibility, discovery optimizing for recall, a separate adversarial verification agent that detonates exploits in fresh containers, triage to prioritize engineer attention, and patching that closes the loop so bugs cannot recur. His advice: start this week on open source dependencies, keep hands on the wheel before automating, and recognize that scanning was never the bottleneck.

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.

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

Jul 15, 2026 · 51:30

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

"I've never seen anything scarier than an LLM with tool calls." — Erik Meijer aka @HeadinTheBox

Jul 13, 2026 · 21:13

Erik Meijer of Leibniz Labs argues that AI agents with tool calls are intrinsically dangerous and must be tamed through formal verification. He recounts how adding tool calls to LLMs turned harmless chatbots into agents capable of irreversible side effects, like deleting files or emptying bank accounts. His solution, implemented in Automind, uses proof-carrying code: the agent submits a plan as a program (Free Monad) together with a machine-checkable safety proof, and a small checker verifies the proof before allowing execution. This air-gaps the agent from its tools, ensuring policy compliance statically. Meijer demonstrates that elementary type systems and compiler techniques, such as taint analysis on program expressions, can provably prevent unsafe actions, turning agents from 'vibe-coding' risks into provably safe systems.

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

Jul 12, 2026 · 17:27

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

The AI bugpocalypse is here. Now what? - Jack Cable, Corridor

Jul 12, 2026 · 19:44

Jack Cable, Co-Founder and CEO of Corridor, argues that frontier AI models can now find and exploit software vulnerabilities at scale, creating an 'AI bugpocalypse' that demands fundamental security changes. He cites 84% of developers using AI coding tools, with models like Mythos outperforming humans in finding vulnerabilities. He notes that basic vulnerability classes like buffer overflows remain prevalent despite decades of known fixes, and that memory-safe languages like Rust can eliminate 60-70% of such bugs, as shown by Android's drop from 75% memory safety vulnerabilities in 2019 to 30% in 2022. He warns that even advanced models introduce vulnerabilities 20-40% of the time (backsbench.com) and points to an Opus 4.6 incident that lost $2M. His recommendations to Congress include preventing vulnerabilities in new code, hardening open-source software, and fostering American open-weight models, arguing that defenders need access to these models to stay ahead.

A Song of Types and Agents - Roberto Stagi, Ratel

Jul 12, 2026 · 14:16

Roberto Stagi (Ratel) argues that TypeScript is overtaking Python as the dominant language for building AI agents and applications, driven by the rise of coding agents like Lovable, Claude Code, and Cursor that default to TypeScript. He notes that Python still rules training, research, and GPU serving, but the application layer—where AI is shipped inside products—now belongs to TypeScript. Stagi highlights that TypeScript surpassed Python as the most used language on GitHub in August 2025, with GitHub attributing the shift to AI agents. He cites the Vercel AI SDK growing from 1.6M to 15.1M weekly downloads in one year and npm's rich ecosystem of authentication, payments, and UI packages as reasons to build agents in TypeScript. Consistent end-to-end typing via Zod and a unified codebase for agent loops, tools, backends, and UIs further strengthen the case. Stagi concludes by invoking Atwood's Law: any application that can be written in JavaScript will eventually be written in TypeScript, urging developers to build agents in TypeScript to avoid falling behind.

From Writing Code to Designing Systems: How the Developer Role is Changing — Chris Noring, Microsoft

Jul 11, 2026 · 23:05

Chris Noring from Microsoft argues that the developer role is shifting from writing code to designing systems and orchestrating AI agents, using tools like GitHub Copilot and Claude. He proposes a workflow starting with the CLI rather than the editor, employing agents.md for high-level guidance, skills for repeatable tasks, and custom agents for orchestration. Noring demonstrates scaling by delegating tasks via /delegate in the CLI or assigning issues to agents in the GitHub UI, allowing developers to become 20x more productive. He stresses that guardrails are essential to prevent agents from producing 'slop', and that human-in-the-loop oversight remains critical. The episode emphasizes that developers must encode standards and constraints into their workflows to maintain consistency and quality at scale.

Should AI Engineers Still Read Code in 2026? The Z/L Continuum — Alex Volkov, ThursdAI

Jul 10, 2026 · 21:35

Alex Volkov examines the debate sparked by Ryan Lopopolo's claim that 'code is free' and Mario Zechner's counter that engineers must 'read every fucking line' of critical code, arguing that the Z/L Continuum is about task-level proof rather than personality. Citing a Ferrous AI survey showing an 861% increase in code deletion per PR and a 242% rise in incidents, he notes Anthropic's recursive self-improvement essay admitting human code review is a new bottleneck. Volkov's routing table prescribes reading every line for authentication, money movement, and irreversible data, while letting agents handle less critical changes. He also introduces loops—cron-like agent systems that self-verify—as the next frontier, quoting Adi Osmani that automated loops don't remove judgment. Volkov concludes that capability drift moves where proof belongs, but every system still requires human judgment.

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

Jul 8, 2026 · 18:19

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

Your coding agent doesn't always follow your rules — Talha Sheikh, Checkout.com

Jul 8, 2026 · 10:08

Talha Sheikh from Checkout.com argues that the real value in AI coding agents lies not in the code they generate but in the verification layer that checks it. Drawing from his experience with Claude Code, he built Vector Harness—a tool using Claude hooks to deterministically test agent outputs against a config file, retrying failures automatically. He contends that model capability does not equal reliability, and that even with better specs or models, deterministic verification is essential. Sheikh observes that Anthropic, OpenAI, and CUDO are all adopting similar harness patterns, shifting the focus from instructing agents to enforcing rules. His central claim: work on the harness, not the code, and you can even use smaller, cheaper models with enough guardrails.

Your LLM Deception Monitor Is Broken. The Fix Is in the Training Data - Sachin Kumar, LexisNexis

Jul 8, 2026 · 13:58

Sachin Kumar (LexisNexis) presents his peer-reviewed IJCNN paper showing that standard LLM deception monitors—behavioral tests and joint cross-model features (crosscoders)—fail to detect sleeper-agent backdoors. The fix is a diff sparse autoencoder (SAE) trained on the difference between base and fine-tuned model activations. On a controlled SQL-injection backdoor triggered by 'year 2024' in a 360M-parameter model, diff SAE achieves 40× the signal of joint features, perfect precision, and zero false positives from a single layer. Recall is about 25%, so multiple features should be ensembled. The method is cheap (one forward pass per checkpoint) and works under both full-rank and LoRA fine-tuning. Limitations include requiring the base checkpoint and not yet tested against adaptive adversaries. Kumar demonstrates that backdoors are directional shifts in activations, and diff SAE isolates them directly.

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.

Field Guide to Fable — Thariq Shihipar, Anthropic

Jul 6, 2026 · 19:28

Thariq Shihipar of Anthropic discusses Fable and argues models improve in "spiky" ways: a chat model fails to list Pokémon ending in "aw" (Croconaw and Dreadnaw), but Claude Code fetches and filters the list in seconds – a gap he calls "capability overhang." He explains that to unlock Fable, Claude Code cut 80% of its system prompt because heavy instructions now constrain a more imaginative model, and the "ask user question" tool evolved from barely working under Opus 4 to generating embedded HTML questionnaires. He shares techniques like blind-spot passes and interviews to surface unknown unknowns, and reflects on the grief of moving from hand-coded programming to agentic workflows. Shihipar urges engineers to reject trade-offs – "good, fast, cheap: pick three" – and instead demand all three, citing a four-hour keynote deck built with Fable as proof that agents can deliver ambitious work faster.

MCP Apps: Primitives, discovery, and the Future of Software - Pietro Zullo, Manufact, Inc

Jul 5, 2026 · 28:54

Pietro Zullo, co-founder of Manufact, explains that MCP Apps are MCP servers that return interactive UI elements in sandboxed iframes, enabling bidirectional communication between the UI and the host. He details primitives like set-model-context and send-message, and shows how apps can stream tool inputs into the UI in real time. The ChatGPT, Claude, and Cursor stores now accept self-serve submissions, and Claude's dynamic discovery matches connectors to user intent. Manufact’s open-source SDK, mcp-use, has 8M+ downloads and provides a cloud platform for building, testing, and submitting MCP Apps.

AI System Design: From Idea to Production - Apoorva Joshi, MongoDB

Jun 28, 2026 · 28:53

Apoorva Joshi presents a structured framework for designing AI systems from idea to production, arguing that thorough product specification and evaluation are now more critical than coding itself. Using a health insurance claims review system for MDB Health as an example, she walks through four phases: defining business problems with measurable success metrics (e.g., reducing urgent claim processing from 2 days to 1 hour within 90 days), designing data strategy and architecture using patterns like RAG, control flow, and human-in-the-loop, establishing guardrails and evaluation metrics such as faithfulness and cost per recommendation, and optimizing for accuracy, cost, latency, and reliability before shipping. She emphasizes building evaluation in from the start and iterating from the simplest system.

Building an Autonomous Engineering Org - Angie Jones, Agentic AI Foundation

Jun 28, 2026 · 17:36

Angie Jones describes how she transformed Block's 3,500-person engineering org into an autonomous one using AI agents, starting with a maturity model and an AI champions program of 50 hand-picked engineers. She details making repos AI-ready with context and rules files, then enabling delegation from Slack, Jira, and GitHub, which boosted AI-authored code by 69% and automated PRs 21x. Multi-agent parallelism required cloud workspaces and a company world model across 25,000 repos, culminating in BuilderBot that allowed anyone to @mention it for fixes. However, the success led to layoffs, raising existential questions about the human cost of autonomous engineering.

Using Spec-Driven Development for Production Workflows - Erik Hanchett, AWS

Jun 28, 2026 · 17:47

Erik Hanchett (AWS) argues that spec-driven development—writing markdown specification files before any code—produces higher quality code by guiding AI coding assistants, which he compares to 'AI interns' that need explicit direction. He introduces Kiro, AWS’s new AI IDE and CLI, which offers a spec mode that generates requirements documents, design documents with mermaid diagrams, property-based tests using Fastcheck, and a task list. In a demo building a movie website, Kiro created an MVP-focused implementation verified by property tests. Hanchett also highlights integrating external data via the Model Context Protocol (MCP) and stresses the importance of human review. He advises balancing context in steering docs and using on-demand skills to control the workflow.

The 100-Tool Agent Is a Trap - Sohail Shaikh & Ankush Rastogi, Prosodica

Jun 28, 2026 · 28:27

Sohail Shaikh and Ankush Rastogi of Prosodica argue that the common 'Fat Agent' architecture—loading every tool schema into every prompt—causes latency, cost, and accuracy collapses as tool catalogs grow. Their benchmarks show tool selection accuracy dropping from 78% at 10 tools to 13.6% at 741 tools, while their Semantic Tool Router pattern stays above 83% across the same range. The router uses Just-in-Time Context Injection, embedding tool descriptions offline, retrieving 3–5 relevant tools per query at runtime, and injecting only those schemas into the model call. This reduces input tokens by up to 99% (from 127k to ~1k tokens) and cuts time-to-first-token latency by up to 90% in high-tool-density scenarios. They present a production checklist and emphasize that routing pays off once beyond 50 tools, with K=5 as a strong default, but warn of router misses and weak descriptions needing fallbacks and monitoring.

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…

Why MCP and ChatGPT Apps Use Double Iframes — Frédéric Barthelet, Alpic

Jun 15, 2026 · 20:11

Frédéric Barthelet, CTO of Alpic, explains why ChatGPT and other MCP hosts render third-party app UI inside a double iframe. He traces how simpler approaches fail: `srcdoc` shares the parent origin, letting CSP block scripts and risking data access; sandboxing removes origin storage; and `allow-same-origin` recreates the escape. The resulting double iframe—an outer iframe from a controlled subdomain loading app HTML via `srcdoc` into an inner frame—ensures isolation and prevents cross-app storage collisions. Barthelet warns developers must declare every external domain their view uses in MCP app metadata or face submission rejection, and demos Skybridge's CSP inspector that diffs declared domains against actual network calls.

Building Interactive UIs in VS Code with MCP Apps — Marlene Mhangami & Liam Hampton, GitHub

Jun 6, 2026 · 16:06

Marlene Mhangami and Liam Hampton from GitHub explain MCP Apps, which let server tools return rich interactive UI components inside VS Code Chat via sandboxed iframes, replacing plain text responses. They demonstrate a flame graph profiler that profiles a Go app running bubble sort and Fibonacci, rendering an interactive flame graph directly in the chat window. The MCP server returns data and a resource reference to bundled HTML; VS Code fetches and renders it, enabling live interaction like clicking and querying without leaving chat. Use cases include data exploration, e-commerce checkouts (Shopify), and interactive diagrams (Excalidraw). The iframe is sandboxed for security—like putting a hamster in a cage to prevent it from modifying VS Code settings or calling external APIs. Marlene and Liam walk through building an MCP App from scratch using a skill from the model context protocol repository.

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

Jun 6, 2026 · 19:04

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

Dark Factory: OpenClaw Ships Faster Than You Can Read the Diff — Vincent Koc, OpenClaw

Jun 5, 2026 · 16:44

Vincent Koc, a core maintainer at OpenClaw, explains how the open-source project ships code faster than humans can read diffs by running 60–70 autonomous coding agents across swim lanes. In a single night, he and Peter Steinberger executed 2,700 commits touching 82% of the core codebase, launching a plugin architecture and changing close to a million lines of code. Koc describes managing agents as managing people: the key skill is reading reasoning tokens to detect when an agent is bullshitting, gained through sheer volume of token maxing. He argues 2025 was about token maxing; 2026 is about not wasting them, with agent-in-the-loop processes and opinionated swim lanes replacing blind Ralph looping. The episode details his agent development environment using .skills files, Git work trees, and a semantic graph for triaging 60K PRs, emphasizing that the bottleneck shifts from engineering to taste and process.

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

Jun 3, 2026 · 16:58

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

Benchmarking semantic code retrieval on Claude Code — Kuba Rogut, Turbopuffer

Jun 3, 2026 · 16:08

Kuba Rogut from Turbopuffer benchmarks semantic code retrieval on Claude Code, finding that raw Claude Code wastes one in every three file reads (65% precision), windowed grep drops that to one in five, and adding semantic search cuts it to one in eight (87% precision). Semantic search wins on behavior-adjacent tasks where files share no keywords; grep wins on import tracing. Cursor's production numbers show a 24% relative improvement in answer accuracy from semantic retrieval plus a 2.6% increase in code retention in large codebases. Rogut explains Cursor's model knows when and why to call semantic search, while Claude Code treats it as just another tool, limiting gains.

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

Jun 1, 2026 · 24:29

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

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

May 26, 2026 · 18:54

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

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

May 25, 2026 · 18:54

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

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

May 24, 2026 · 25:13

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

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

May 24, 2026 · 16:17

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

Introducing WebMCP: Agents in the Browser — RL Nabors

May 23, 2026 · 23:08

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

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.

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

May 18, 2026 · 1:15:40

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

Fighting AI with AI — Lawrence Jones, Incident

May 17, 2026 · 17:29

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

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

May 15, 2026 · 18:27

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

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

May 15, 2026 · 21:49

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

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

May 14, 2026 · 2:04:18

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

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

May 14, 2026 · 1:20:07

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

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

May 14, 2026 · 1:04:27

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

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.

Vibe Engineering Effect Apps — Michael Arnaldi, Effectful

May 7, 2026 · 1:43:04

Michael Arnaldi demonstrates that cloning the Effect library's repository into a project, rather than relying on prompts, is the most effective way to give coding agents the context they need to build reliably with Effect. Starting from an empty repo, he sets up a Bun, Vitest, and TypeScript project, adds the Effect repo as a git subtree, and creates an agents.md to guide the agent. He then uses the agent to research patterns, resulting in a fully functional Todo HTTP API with OpenAPI docs, SQLite persistence, and tests — all from scratch in under two hours. The workshop stresses that treating the library code as part of the project, combined with strict diagnostics and pattern files, makes agents effective even in unfamiliar codebases. Arnaldi also discusses the importance of workflow systems like Effect Cluster for long-running AI processes, where server failures become likely.

Full Walkthrough: Writing & Using Skills — Nick Nisi and Zack Proser

May 6, 2026 · 1:21:03

Zack Proser and Nick Nisi, Developer Experience Engineers at WorkOS, teach how to write portable, composable skills — single markdown files with optional scripts — that train AI tools like Claude, Codex, and Cursor to perform specific tasks consistently. They demonstrate building a repo roast skill that uses deterministic Git commands via script interpolation and progressive disclosure to load targeted references only when needed. The workshop covers structuring skills with front matter (name, description for LLM routing), adding confidence scoring and constraints to improve output, and sharing skills as .skill files or through marketplaces. Advanced topics include using skills in non-coding workflows (e.g., Slack–Linear automation) and composing skills in the WorkOS CLI, which uses the Claude Agent SDK to install auth. Attendees learn to iterate skills by reflecting on past conversations and leveraging Claude's built-in skill builder for evaluation.

MCP UI: Extending the frontier — Liad Yosef and Ido Salomon, MCP Apps

May 6, 2026 · 22:21

In this episode, Ido Salomon and Liad Yosef explain MCP Apps, an MCP extension that lets tools send interactive, branded UI instead of plain text responses inside chat hosts like ChatGPT, Claude, VS Code, Cursor, and Copilot. They argue that text-based chat reduces companies to a wall of text, erasing identity, while MCP Apps preserves branding by returning HTML resources that hosts render as secure, interactive components. The architecture ensures every user click sends a message back to the host (not directly to the backend), keeping interactions in context—as demonstrated with a PostHog funnel analysis in Claude. Adoption includes Shopify, Hugging Face, GitHub, ChatGPT, and Claude, with ChatGPT recommending MCP Apps for building ChatGPT Apps. They note 800 million weekly ChatGPT users (10% of world population), calling this a once-in-20-years opportunity to rethink app distribution. Future work covers reusable views, model-UI interaction, and interoperability with generative UI protocols like A2UI and WebMCP, aiming to standardize UI in chat as the new web.

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

May 4, 2026 · 1:21:26

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

Skill Issue: How We Used AI to Make Agents Actually Good at Supabase — Pedro Rodrigues, Supabase

May 4, 2026 · 1:18:41

Pedro Rodrigues, AI tooling engineer at Supabase, demonstrates how to write, test, and iterate on Agent Skills to make agents actually good at real systems like Supabase's performance-review app. He explains progressive disclosure—skills load only a short description first, letting the agent decide when to pull in full instructions—and shows that combining skills with MCP tools gives agents both context and actions. In a live demo, Rodrigues reveals a common failure: creating a database view without a security invoker flag bypasses row-level security, letting all users see everyone's salary data. Adding a skill with security checklists guides the agent to include the flag, fixing the bug. He then introduces an eval-driven development cycle using an eval.json file and an LLM-as-judge to automate testing across conditions with and without the skill, cautioning that writing accurate evals is tricky because non-deterministic outputs can mislead. The session offers a practical framework for validating skills, avoiding pitfalls, and measuring what actually improves agent behavior.

Ralph Loops: Build Dumb AI Loops That Ship — Chris Parsons, Cherrypick

May 4, 2026 · 1:48:26

Chris Parsons argues that dumb loops—simple while loops where an AI agent repeatedly executes the same task, evaluates its output, and iterates—outperform complex multi-agent orchestration and planning graphs. In this hands-on workshop, he builds a Pomodoro timer using Claude Code, implementing tickets one by one in a loop that self-corrects with each pass. He demonstrates the 'loop' command in Claude Code for scheduled, continuous execution and shows how to use sub-agents for adversarial validation to avoid self-confirmation bias. The talk covers real-world applications such as a worker loop that processes project steps overnight and a morning loop that generates daily briefings, all designed to offload routine work while keeping human oversight for irreversible decisions. Parsons emphasizes that the bottleneck in AI-augmented teams is often the review process, not coding speed, urging teams to identify and fix their biggest constraint first.

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

May 3, 2026 · 1:41:25

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

Mastering AI Pricing — Mayank Pant, Stripe

May 1, 2026 · 24:19

Mayank Pant from Stripe explains that AI companies, growing 3x faster than traditional SaaS, face margin risk from power users and unpredictable compute costs, making hybrid pricing (base fee + usage fee) essential—56% of AI leaders now use it. He presents a five-step framework: define customer-perceived value (e.g., automation, augmentation, enhanced service, improved results), choose a charge metric (consumption, workflow, or outcome-based), adopt hybrid pricing with guardrails like usage caps and automated notifications, and iterate pricing frequently—84% agree fast adaptation is a competitive advantage. Pant illustrates with examples: Gamma charges per deck (not API calls), Intercom prices per resolved ticket. To keep customer-facing prices stable while changing features, he advises abstracting value with credits (e.g., 100 credits/month) that can be internally revalued. Stripe's billing infrastructure supports this iteration, with 78% of AI companies building on Stripe using its subscription, usage, and hybrid billing, plus Metronome for enterprise contracts.

Shipping complex AI applications — Braintrust & Trainline

May 1, 2026 · 1:38:34

Giran Moodley of Braintrust, joined by Trainline's Oussama Hafferssas and Mayank Soni, demonstrate how to ship production-grade multi-step AI agents by combining rigorous tracing, evaluation with golden datasets, and automated online scoring. They walk through building a support triage agent that progresses from a single prompt to a five-stage tool-calling pipeline, where tracing captures latency, tokens, and costs per step for deep debugging. Trainline shares using Braintrust to run offline evaluations before switching LLM models and to enable cross-functional self-service. The workshop covers identifying failure modes via production logs, tightening prompts, and re-evaluating to complete the feedback loop, emphasizing that observability and iterative evaluation are essential for moving from prototype to reliable production systems.

LLM codegen fails and how to stop 'em — Danilo Campos, PostHog

Apr 30, 2026 · 19:18

Danilo Campos, who builds the PostHog wizard, explains how to make LLM code generation reliable by sharing practical strategies from a system that helps 15,000 users per month. He identifies 'Model ROT'—models becoming stale—and counters it by shoving fresh Markdown documentation into context. To avoid weird architecture, he maintains 'model airplanes': thin, auth-shaped simulacra that provide correct integration patterns. He limits improvisation by breadcrumbing the agent step by step, starting with detecting business-value files before even mentioning PostHog. Campos stresses that human errors (contradictory instructions, missing tools) are the biggest threat, solved by asking the agent after each run what could be improved. He also details locking down tool usage to prevent shenanigans like reading .env files, replacing that with a limited key-check and write tool. The core shift: code is a depreciating asset, so 90% of the wizard's value is now in Markdown files and prose, which improve with better models.

One Login to Rule Them All: Cross-App Access for MCP — Garrett Galow, WorkOS

Apr 28, 2026 · 23:24

Garrett Galow from WorkOS introduces Cross-App Access (XAA) for MCP, solving the problem of repeated OAuth consent screens when connecting agents to multiple services. The flow leverages a three-way trust between the MCP client, server, and an Identity Provider like Okta: a single SSO login issues an IDJag token that is exchanged for short-lived access tokens across all MCP servers without manual intervention. A demo shows Figma automatically connecting after an Okta login. The approach improves security—if the IdP session is revoked, tokens cannot refresh—and requires minimal IT setup: granting permission for the client to request server access. Currently only Okta supports XAA; Azure/Entra does not yet. The session also notes that authorization scopes are not handled by default but are a future consideration.

Scaling GitHub for your Agents — Sam Morrow, GitHub

Apr 27, 2026 · 20:35

Sam Morrow, GitHub's MCP server lead, details the architectural challenges and solutions for scaling a remote MCP server to 7 million weekly tool calls. He explains how tool proliferation degraded agent performance—LangChain's research confirmed more tools confuse agents—leading to innovations like tool sets and dynamic discovery, though 100% of users stuck with defaults. To reduce context, GitHub cut tool descriptions by 49% and trimmed output tokens by 75% on list pull requests. Security is addressed via OAuth 2.1 with PKCE and step-up auth; they rejected dynamic client registration to avoid unbounded app databases and rate-limiting issues. The stateless server uses Redis for session storage and builds a fresh server instance per request, enabling horizontal scaling without session affinity. Metrics include 11 million Docker downloads, 30,000 stars, 4,000 forks, and 126 contributors. Morrow predicts compositional tools and automatic server discovery will make thousands of tools the norm.

Gateways are All You Need — Karan Sampath, Anthropic

Apr 27, 2026 · 17:48

Karan Sampath, an engineer at Anthropic, argues that enterprises face a 'three-headed hydra' of observability, access control, and security when adopting MCPs, and proposes that unified gateways are the solution. He explains that current decentralized MCP deployments create bottlenecks, limiting enterprises to single-digit MCPs due to opaque usage, lack of role-based scoping, and data exfiltration risks. The gateway, a middleware layer handling auth, proxying, routing, and tunnels, establishes a root of trust. Core components include OAuth integration, a developer CLI, and an internal sub-registry. Benefits include multi-surface integration (Claude.ai, Claude Code), standardized access control, faster iteration without repeated security reviews, and scalable credential management. Sampath envisions decoupling agent architecture from data layers, making gateways invariant as agent surfaces evolve.

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.

How AI is changing Software Engineering: A Conversation with Gergely Orosz, @pragmaticengineer

Apr 21, 2026 · 26:42

Gergely Orosz explains how AI is reshaping software engineering, from token maxing at Meta, Microsoft, and Salesforce—where engineers use AI tools to inflate token counts out of fear of layoffs and performance reviews—to the broader shift in the engineer's role toward orchestrating agents rather than managing people. He notes that big tech companies like Uber, Airbnb, and Shopify are building custom internal AI infra (MCP gateways, coding agents) to stay ahead, even tolerating high churn for a six-month competitive edge. Shopify secured GitHub Copilot a year early by offering feedback from 3,000 engineers. Gergely also shares how The Pragmatic Engineer hit product-market fit: 100 paid subscribers before publishing, reaching 1,000 in six weeks, and becoming the #1 paid tech newsletter by focusing on two deep-dive articles per week for two years.

Taste & Craft: A Conversation with Tuomas Artman, CTO Linear & Gergely Orosz, @pragmaticengineer

Apr 21, 2026 · 29:17

Tuomas Artman, CTO of Linear, warns that AI's ability to instantly ship features risks creating convoluted, low-quality software, arguing that taste and design must guide development. He explains Linear's culture of deliberate product decisions, including a 'zero bug policy' where bugs are fixed within hours, and 'Quality Wednesdays' where engineers find and fix one minute detail each week—resulting in over 2,500 quality fixes. Artman notes that AI lacks human 'taste' and cannot feel user experience nuances like animation timing. He predicts all software engineers will become product engineers, needing to focus on customer needs and UX, and advises aspiring product engineers to build for themselves, talk to customers, and study Apple's Human Interface Guidelines.

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

Apr 20, 2026 · 1:57:03

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

The New Application Layer - Malte Ubl, CTO Vercel

Apr 20, 2026 · 18:52

Vercel CTO Malte Ubl argues that AI engineering is the legitimate successor to web development and that the real value lies in the application layer, not the model labs. He identifies four effective agent archetypes—24/7 support, compressed research, surfacing existing information, and eliminating boring work—and reveals that over 60% of vercel.com page views now come from AI agents. Ubl predicts model companies will commoditize, driving costs down and empowering engineers, while citing Europe's leadership in AI engineering through Vercel's AI SDK, Pi (a coding agent from Austria), and OpenClaw. He stresses the need for open-mindedness toward paradigm shifts and new infrastructure, such as sandboxed agent runtimes, and warns of impending security challenges.

State of the Claw — Peter Steinberger

Apr 17, 2026 · 44:12

Peter Steinberger, creator of OpenClaw, presents a five-month update on the world's fastest-growing open-source project. He details the project's staggering growth—30,000 commits, nearly 2,000 contributors—and the immense security burden: 1,142 advisories (16.6 per day) with 99 critical, often AI-generated slop that demands human vetting. Steinberger refutes media fearmongering, citing how researchers ignore security docs to fabricate scary scenarios. He clarifies OpenAI did not buy OpenClaw; he joined the company while establishing the OpenClaw Foundation to remain vendor-neutral. He emphasizes the importance of local models for data sovereignty and describes his coding workflow of running 5-6 agent sessions simultaneously, iterating on taste and personality. Future visions include ubiquitous agents, 'Dreaming' for memory reconciliation, and modular plugins. For engineers, he champions taste, system design, and learning to say no.

Building pi in a World of Slop — Mario Zechner

Apr 16, 2026 · 18:25

Mario Zechner explains why he built pi, a self-modifying, extensible agent core, after growing frustrated with Cloud Code and Open Code for their buggy features, uncontrolled context management, and zero extensibility. pi strips away complexity, giving the agent just four tools (read, write, edit, bash) and a minimal system prompt, letting it adapt to the user's workflow rather than vice versa. Extensions are TypeScript modules that hot-reload, enabling users to build custom tools, chat rooms, or even play Doom without forking pi. He then attacks clankers — agent-generated pull requests and issues — that are destroying open source, sharing his own tactics like auto-closing PRs with a human-voice request and de-prioritizing OpenClaw interactions. In Act 3, Zechner argues that agents compound errors with zero learning, producing enterprise-grade complexity in weeks, and that long context windows and agentic search are hacks. His prescription: scope agent tasks, modularize codebases, cap generated code review, and always read every line of critical code yourself.

OpenRAG: An open-source stack for RAG — Phil Nash

Apr 8, 2026 · 15:52

Phil Nash introduces OpenRAG, an open-source RAG stack from IBM combining Docling, OpenSearch, and Langflow, arguing that RAG remains hard and custom despite claims it's dead — every business has unique data requiring more than simple vector search. Docling parses PDFs, audio, and more with specialized pipelines, outputting hierarchically chunked text. OpenSearch provides hybrid vector and keyword search using JVector for live indexing and disk-based ANN. Langflow enables visual agentic retrieval where the LLM decides searches with tools like a calculator and MCP servers. The stack supports local models via Ollama, cloud connectors for Google Drive and SharePoint, and an API. Nash demonstrates adding guardrails in Langflow and invites contributions to the open project.

Cognitive Exhaust Fumes, or: Read-Only AI Is Underrated — Šimon Podhajský, Head of AI, Waypoint

Apr 8, 2026 · 11:31

Šimon Podhajský argues that read-only AI systems that analyze personal digital exhaust without the ability to write back are more valuable than agentic AI that acts on users' behalf. He built a system ingesting six read-only sources (email, journal, tasks, CRM, browser sessions, notes) that surfaces insights like intention-action gaps, attention drift, and relationship decay via cross-source pattern detection—things no single source reveals. For example, a weekly reflection skill in Claude synthesizes a brutal review of his week, and a cross-source query maps his recent reading to contacts in his CRM using Vivaldi SQLite and Clay MCP. He emphasizes risk asymmetry: read-only errors cost nothing, while write errors can be unbounded. He also acknowledges security risks like the mosaic effect and Simon Willison's lethal trifecta, noting that shell access still allows exfiltration, but argues that examined risk is better than ignorance.

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.

Your MCP Server is Bad (and you should feel bad) - Jeremiah Lowin, Prefect

Jan 12, 2026 · 54:33

Jeremiah Lowin, CEO of Prefect and creator of FastMCP, argues that most MCP servers are poorly designed because they are simply REST API wrappers, leading to confused LLMs and wasted tokens. He presents a framework for agent-native product design based on three dimensions—discovery, iteration, and context—and offers five actionable principles: outcomes over operations, flatten arguments, treat instructions as context, respect the token budget, and curate ruthlessly. Lowin emphasizes that agents fail when given too many tools or complex arguments, citing a hard limit of 50 tools per agent for reliable performance. He shares real-world examples, including a company with 800 endpoints that could not be effectively exposed, and critiques client implementations like Claude Desktop for not respecting spec-compliant features. The central takeaway: MCP servers should be designed as user interfaces for agents, not as developer APIs.

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.

Claude Agent SDK [Full Workshop] — Thariq Shihipar, Anthropic

Jan 5, 2026 · 1:52:25

Thariq Shihipar of Anthropic presents the Claude Agent SDK, arguing that Bash and file-system-based agents outperform traditional tool-only approaches for autonomous tasks. He defines agents as systems that build their own context and trajectory, contrasting with structured workflows. The SDK, built on Claude Code, emphasizes the Bash tool as the most powerful primitive for composability and code generation, enabling non-coding tasks like data analysis. He demonstrates live-coding a Pokémon team advisor that dynamically fetches API data via scripts, and explains security through a 'Swiss cheese defense' of model alignment, AST parsing, and sandboxing. Shihipar also covers skills for progressive context disclosure, sub-agents for parallel work, and hooks for deterministic verification, stressing that agent building is an art of reading transcripts and iterating on context engineering.

Welcome to AIE CODE - Jed Borovik, Google DeepMind

Jan 5, 2026 · 4:10

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

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

Dec 29, 2025 · 1:02:44

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

AGI: The Path Forward – Jason Warner & Eiso Kant, Poolside

Dec 27, 2025 · 15:56

Jason Warner and Eiso Kant, co-founders of Poolside, present their vision and roadmap towards AGI-level capabilities for knowledge work, demonstrating their second-generation model Malibu Agent converting ADA code to Rust live on stage. They argue that next-token prediction paired with reinforcement learning is the key breakthrough, a contrarian bet they made two and a half years ago. The episode centers on their work in high-consequence code environments for defense and government, where agents must operate with tight permissions. They announce a large compute cluster of over 40,000 GB300s coming online and a public API release early next year via AWS Bedrock. Warner recounts meeting Kant through a failed GitHub acquisition, and Kant invites the audience to build with their models, emphasizing that future agents will handle tasks over days as intelligence scales.

Shipping AI That Works: An Evaluation Framework for PMs – Aman Khan, Arize

Dec 26, 2025 · 1:26:16

Aman Khan, AI PM at Arize, presents a framework for product managers to evaluate LLM-powered products beyond gut-feel 'vibe checks.' He demonstrates building an AI trip planner with multi-agent LangGraph, then using Arize's tracing and prompt playground to iterate on prompts. Khan shows how to create datasets from production traces, run A/B experiments on prompts, and use LLM-as-a-judge evals for friendliness and discount offers, comparing against human labels to refine evaluators. He argues evals are the new requirements docs, enabling PMs to own the product experience by writing acceptance criteria as eval datasets. The talk covers building eval teams, handling variance with temperature settings, and continuously improving golden datasets with hard examples, citing real-world analogies from self-driving cars at Cruise.

How Claude Code Works - Jared Zoneraich, PromptLayer

Dec 26, 2025 · 1:05:43

Jared Zoneraich from PromptLayer dissects how Claude Code works, arguing its success stems from a radical simplification: a single-threaded master loop with tool calls, relying on capable models rather than complex DAG-based architectures. He breaks down the core internal tools—Bash, FileEdit, Grep—and the to-do planning mechanism that is purely prompt-based and not deterministically enforced. Zoneraich contrasts Claude Code with other coding agents: Codex (Rust core, kernel-level sandboxing), Amp (handoff context management, model-agnostic), and Cursor Composer (UI-first, distilled model). He emphasizes that Bash is the most important tool, acting as a universal adapter, and that context management via sub-agents and summarization is critical. Key takeaways include trusting the model, simple design, rigorous tool testing, and that different agent philosophies (not one winner) will serve different use cases.

The 3 Pillars of Autonomy – Michele Catasta, Replit

Dec 22, 2025 · 24:42

Michele Catasta, VP of AI at Replit, argues that true autonomy for coding agents serving non-technical users rests on three pillars: verification, context management, and parallelism. Replit’s agent uses autonomous testing—writing Playwright code instead of browser-use tools—to catch broken features (over 30% initially) without human feedback, cutting cost and latency by an order of magnitude. Context management relies on sub-agent orchestration rather than massive context windows, boosting memories per compression from ~35 to 45–50. Parallelism, implemented via a core-loop orchestrator, dynamically decomposes tasks to avoid merge conflicts and keep users engaged instead of waiting hours. Catasta emphasizes that autonomy means scoped technical decisions, not just long runtimes, enabling knowledge workers to build software without needing a 'driving license.'

No More Slop – swyx

Dec 22, 2025 · 9:15

In this keynote at the AI Engineer Summit, host swyx declares war on slop — low-quality, inauthentic, inaccurate work produced by both humans and AI — arguing that the AI engineering community must elevate taste and accountability. He introduces Swix's law of anti-slop: the taste needed to fight slop scales with the plummeting cost of generating tokens. Swyx demonstrates how to combat slop using AI itself, citing examples like AI News (which tells readers to skip slow days), prompting techniques to avoid slop, and using sub-agents against context rot. He calls for rejecting autonomy without accountability and urges the audience to say "no more slop" to bosses demanding more lines of code, untested releases, and engagement bait.

Welcome to AIE LEAD - Alex Lieberman, Tenex

Dec 19, 2025 · 3:13

Alex Lieberman, co-founder of Morning Brew and Tenex.co, opens the AI Engineer Code Summit 2025 by polling the audience on their origins (New York, San Francisco, Austin, Ecuador, New Zealand) and explaining why a newsletter guy hosts an AI engineering conference: he wants to spend the next 20 years at the AI frontier. He describes co-founding Tenex, an AI transformation firm serving mid-market and enterprise companies, and notes that 2025 has been a banner year for AI. The summit will feature the labs, unicorn AI startups, academics, management consultants, and Fortune 50 brands. Lieberman thanks presenting sponsor Google DeepMind, platinum sponsor Anthropic, and all gold and silver sponsors available in the expo downstairs.

Don't Build Agents, Build Skills Instead – Barry Zhang & Mahesh Murag, Anthropic

Dec 8, 2025 · 16:22

Barry Zhang and Mahesh Murag of Anthropic argue that instead of building domain-specific agents, developers should build reusable Skills—organized folders of files that package procedural knowledge for agents. They explain that skills are progressively disclosed to protect the context window, use scripts as self-documenting tools, and have already grown to thousands in five weeks, including foundational, partner, and enterprise skills. Skills complement MCP servers by providing expertise while MCP handles connectivity. The future includes treating skills like software with testing and versioning, and enabling agents to create their own skills for continuous learning, ultimately creating a collective knowledge base that makes agents more capable and reliable.

2026: The Year The IDE Died — Steve Yegge & Gene Kim, Authors, Vibe Coding

Dec 6, 2025 · 24:59

Steve Yegge and Gene Kim argue that by 2026, traditional IDEs will be obsolete, replaced by AI-driven coding agents. Yegge claims current tools like Claude Code are too hard for most developers, with high cognitive overhead and a single-agent bottleneck akin to a solo diver running out of oxygen. He predicts next year will bring multi-agent systems, comparing the shift from manual tools to CNC machines, and provocatively states that engineers using an IDE after January 1st are bad engineers. Gene Kim introduces their 'Vibe Coding' book and shares case studies: Booking.com saw double-digit productivity gains, Travelopia replaced a legacy app in six weeks with a small team, and a Fidelity leader Vibe Coded an app in five days that previously was estimated to take five months. They present the FAFO framework (Faster, Ambitious, alone/autonomous, Fun, Optionality) and cite DORA research showing trust in AI grows with usage. The episode concludes that Vibe Coding will reshape organizations, enabling non-developers to ship features and potentially compressing team sizes.

Katelyn Lesse – Evolving Claude APIs for Agents, Anthropic

Dec 4, 2025 · 13:25

Katelyn Lesse, who leads the Claude Developer Platform team at Anthropic, explains how the platform is evolving to help developers build powerful agentic systems using Claude. She details three key areas: harnessing Claude's capabilities through features like extended thinking and tool use, managing context with MCP, a memory tool, and context editing (which combined to yield a 39% performance bump), and giving Claude a computer via the code execution tool and agent skills. The talk also covers challenges like container orchestration for Claude Code on web and mobile, and the importance of letting Claude work autonomously in a sandbox environment.

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

Nov 24, 2025 · 5:19

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

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.

Form factors for your new AI coworkers — Craig Wattrus, Flatfile

Aug 22, 2025 · 15:35

Craig Wattrus, AI design engineer at Flatfile, argues that designing AI interactions requires treating AI as a new coworker with distinct form factors — invisible, ambient, inline, and conversational — rather than traditional UI. He demonstrates how feeling the material by building tools like a 'chat tuner' to tune AI character shifts from helicopter-parenting to character coaching. Finding the grain involves designing tool UX where AI communicates visually, checks alignment, and hands back control. Courting emergence yields unexpected results: an agent combined two files without being asked and suggested the user contact HR for missing employee IDs. Looking forward, Wattrus explores auto-complete for data transformations, using LLMs to suggest fixes alongside human oversight.

Wisdom-Driven Knowledge Augmented Generation at Scale - Chin Keong Lam, Patho AI

Aug 22, 2025 · 18:43

Chin Keong Lam, founder and CEO of Patho.ai, argues that Wisdom-Driven Knowledge Graphs (KAG) significantly outperform traditional RAG systems for complex quantitative analysis and expert-level advice. He presents a wisdom-decision-situation feedback loop where knowledge, experience, and insight feed into wisdom, mapped to a practical competitive analysis chatbot for a marketing client. The system uses N8n and a multi-agent architecture with a supervisory Wisdom Agent overseeing insight, knowledge, and strategy agents, all updating a centralized knowledge graph. Lam cites five reasons knowledge graphs beat RAG: capturing complex relationships, improved accuracy, scalability, rich multi-hop query capability, and seamless data integration. He demonstrates how vector RAG fails on numerical reasoning (e.g., Apple revenue query) while KAG returns precise evidence-based answers. Lam recommends a hybrid graph extraction combining LLM extraction with expert pruning, and reports benchmark results of 91% accuracy, 85% flexibility, and strong traceability and scalability.

Designing AI-Intensive Applications - swyx

Aug 9, 2025 · 13:02

In this conference talk, swyx (host) proposes the search for a 'Standard Model' in AI engineering, analogous to physics' Standard Model, to guide practitioners. He examines candidate models: LMOS (LLM Operating System), LMSDLC (AI Software Development Lifecycle), and Anthropic's 'building effective agents' framework. Swyx introduces his own SPADE model (Sync, Plan, Analyze, Deliver, Evaluate), derived from building AI News, a daily tool that scrapes Discord, Reddit, and Twitter with thousands of LLM calls. He argues that the ratio of human input to AI output—ranging from 1:1 in ChatGPT to 0:n in ambient agents—is more useful than debating 'workflow versus agent.' The talk emphasizes that early SDLC stages (LLMs, monitoring, RAG) are becoming commodity, while real value comes from evals, security orchestration, and hard engineering. Swyx encourages attendees to identify and refine their own Standard Models to build products people want.

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

Aug 6, 2025 · 19:23

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

Full Workshop: Realtime Voice AI — Mark Backman, Daily

Aug 3, 2025 · 1:09:41

In this hands-on workshop, Mark Backman and Aleś from Daily demonstrate how to build real-time voice AI agents using Pipecat, their open-source Python framework, and Google's Gemini Multimodal Live API. They explain that Pipecat's modular pipeline orchestrates audio transport, speech-to-text, LLM, and text-to-speech services, allowing developers to plug and play vendors like Deepgram, OpenAI, or Cartesia. The session highlights how speech-to-speech models like Gemini Live simplify architecture by handling transcription, LLM logic, and voice generation in one step, reducing latency to under 800 milliseconds. Key topics include the critical role of voice activity detection (VAD) for natural turn-taking, strategies for managing context windows to maintain accuracy, and the trade-offs between speed and reliability when using tool calls in real-time. Despite conference Wi-Fi issues, the team live-codes a functional bot and demonstrates interruption handling and the Word Wrangler game, showcasing Pipecat's production readiness with hundreds of thousands of daily calls.

Real World Development with GitHub Copilot and VS Code — Harald Kirschner, Christopher Harrison

Aug 3, 2025 · 1:19:33

Harald Kirschner demonstrates three stages of Vibe Coding with GitHub Copilot and VS Code—YOLO, Structured, and Spectrum—arguing that developers can move from rapid prototyping to maintainable, scalable AI-assisted development. He shows how to use Agent mode, auto-approve settings, and new workspace scaffolding to build a hydration tracking app with React Vite and Material Design without looking at code. The talk covers custom instructions, MCP servers (Playwright, Jest Pad, Perplexity), and custom modes like TDD that enforce test-driven development by writing failing tests first. Kirschner explains how to constrain tools for deterministic behavior using tool sets and recommends committing often, pausing AI when needed, and iterating on instructions. He also discusses spec-driven development, critiquing specs with AI, and the importance of well-structured codebases for AI productivity.

Building Agents at Cloud Scale — Antje Barth, AWS

Aug 2, 2025 · 19:00

AWS Principal Developer Advocate Antje Barth demonstrates how to build and scale AI agents using cloud-native patterns, arguing that specialized agents will reinvent customer experiences. She showcases Alexa Plus, which orchestrates hundreds of expert systems across 600M+ devices and tens of thousands of services, and the Amazon Q Developer CLI agent, shipped in just three weeks. Barth introduces Strands Agents, an open-source Python SDK for building production-ready agents that supports multiple model providers (Claude, Llama, OpenAI) and over 20 prebuilt tools including memory, RAG, and multi-agent workflows. She demonstrates integrating MCP servers via Lambda with DynamoDB for session storage, and previews upcoming A2A protocol support and a future of personal agents connecting to agent stores.

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.

Agents vs Workflows: Why Not Both? — Sam Bhagwat, Mastra.ai

Aug 1, 2025 · 15:37

Sam Bhagwat, co-founder of Mastra and author of 'Principles of AI Agents', argues that the debate between agents and workflows is misguided—developers should combine both. He criticizes OpenAI's anti-workflow stance as 'being that guy' and LangChain's graph/node/edge APIs as harmful, advocating for fluent syntax over graph theory. Bhagwat defines agents as turn-based games and workflows as rules-engine dependency chains, noting that nondeterminism makes workflow tracing 10x more important in AI engineering. He demonstrates composition patterns: agents can be steps, workflows can be tools, and nested workflows handle dynamic tool injection. He recommends starting with agent power, then adding workflow control for reliability—e.g., breaking one LLM call into 12 for medical PDFs. Bhagwat concludes that practice trumps theory in this young field.

Why We Don’t Need More Data Centers - Dr. Jasper Zhang, Hyperbolic

Aug 1, 2025 · 14:18

Dr. Jasper Zhang, CEO of Hyperbolic, argues that the AI industry's focus on building more data centers is inefficient because GPUs already sit idle 80% of the time. Instead, he advocates for a GPU marketplace that aggregates supply from fragmented providers, cutting costs by 50–75%—Hyperbolic offers H100s at $0.99/hour versus $2–$11 from traditional clouds. His HyperDOS software connects any Kubernetes cluster in 5 minutes, enabling dynamic rental and release of GPUs. He illustrates with a startup that can reduce compute costs from $43.8 million to $6.9 million by flexibly scaling capacity and selling idle GPUs, effectively boosting productivity 6x on the same budget. Zhang contends that smarter allocation, not just more data centers, is key to sustainable and democratized AI infrastructure.

How we hacked YC Spring 2025 batch’s AI agents — Rene Brandel, Casco

Jul 30, 2025 · 17:33

Rene Brandel, CEO of Casco, explains how his team hacked seven of sixteen YC Spring 2025 batch AI agents within 30 minutes each, revealing three critical security flaws: cross-user data access via IDOR, arbitrary code execution through code tools, and server-side request forgery (SSRF) from tool endpoints. They extracted personal data by exploiting missing authorization checks, overwrote security controls by writing malicious files into code sandboxes, and stole Git credentials by manipulating a database-schema tool. Brandel emphasizes that agent security extends beyond LLM prompt injection, advises treating agents as users with proper authentication and authorization, and warns against rolling custom code sandboxes, recommending out-of-the-box solutions like E2B. The talk concludes with a Q&A on extracting system prompts and the dangers of local coding agents.

Why your product needs an AI product manager, and why it should be you — James Lowe, i.AI

Jul 28, 2025 · 18:37

James Lowe, Head of AI Engineering at the UK Government's Incubator for AI, argues that technical expertise makes AI engineers ideal candidates for the critical role of AI Product Manager, which balances business viability, technological feasibility, user desirability, and the core question of possibility. He shares three hard-won lessons from building products like CONSULT, Minute, and Redbox: resolve AI uncertainties early with evaluations and real-user tests (achieving 1,000x faster and 400x cheaper consultation analysis), experiment widely with features then cut back (streamlining a transcription tool from overwhelming options to a focused Justice Transcribe used for Prime Ministerial meetings), and pivot harder than ever as the landscape shifts (Redbox evolved from digitizing ministerial red boxes to a secure LLM chat client, then to an MCP-based tool provider when Microsoft Copilot Chat went free). The episode emphasizes that AI product management is a mindset, not just a title, and that engineers should step into this leadership gap to build impactful AI products.

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.

Why you should care about AI interpretability - Mark Bissell, Goodfire AI

Jul 27, 2025 · 21:11

Mark Bissell of Goodfire AI argues that mechanistic interpretability—reverse engineering neural networks—has moved from research to practical use cases that AI engineers can apply today, demonstrated through Goodfire's Ember platform for neural programming. He shows how Ember enables debugging and steering models at the neuron level, such as turning up a 'sensitive information' feature to make LLaMA refuse to reveal an email, or dynamically injecting a Coca-Cola recommendation when a beverage feature activates. For image models, the Paint with Ember demo (paint.goodfire.ai) lets users paint concepts like pyramid or lion face directly onto a canvas and steer sub-features (e.g., lion minus mane becomes tiger). Beyond interfaces, interpretability powers model diffs to detect unwanted changes after fine-tuning, guardrails for production systems, and scientific extraction: Goodfire works with the ARC Institute to uncover biological principles from the superhuman genomics model Evo2. Efficiency gains also emerge by pruning unnecessary weights for specialized tasks, making interpretability a critical tool for reliable AI engineering.

Human seeded Evals — Samuel Colvin, Pydantic

Jul 25, 2025 · 12:02

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

Structuring a modern AI team — Denys Linkov, Wisedocs

Jul 24, 2025 · 17:40

Denys Linkov, who leads ML at Wisedocs, argues that building a modern AI team hinges on identifying your company's bottleneck—shipping features, acquiring users, or scalability—rather than reflexively hiring AI researchers. He introduces Ampere's Wager: trading your entire domain-savvy team for five top-lab researchers is usually a losing bet. For early-stage AI strategy, generalists who blend model training, serving, and business acumen outperform specialists; Linkov lived this in 2021 building a custom MLOps platform for a conversational AI startup and again in 2024 using advanced open-source tools for medical record processing. He stresses reskilling existing teams through weekly learning cadences and moving domain experts from giving feedback to writing evaluations. Hiring should hold context and act on it, verifying trends like 'don't hire juniors' against YC's AI school drawing 2,000 young people.

The Rise of Open Models in the Enterprise — Amir Haghighat, Baseten

Jul 24, 2025 · 16:50

Amir Haghighat, CTO of Baseten, argues that enterprises are increasingly moving from closed frontier models like OpenAI and Anthropic toward open source models, driven by four specific cracks in the assumption that closed models will work indefinitely: quality for specialized tasks (e.g., medical document extraction), latency requirements (especially for voice), unit economics ballooning from agentic use cases where a single user action triggers 50 inference calls, and the desire for competitive differentiation. Drawing on conversations with over 100 enterprises, he explains that while most started with dedicated deployments on Azure/AWS for toying around in 2023, by 2024 about 40-50 had production use cases, and in 2025 the shift accelerated. However, adopting open models forces enterprises to build inference infrastructure, facing challenges like speculative decoding, prefix caching, guaranteeing four-nines reliability with hardware failures and VLM crashes, and scaling replicas—with one Fortune 50 soft drink company reporting an eight-minute spin-up time. Haghighat concludes by contrasting the simple API-call world with the complexities of mission-critical inference, where…

Monetizing AI — Alvaro Morales, Orb

Jul 23, 2025 · 18:18

Alvaro Morales, CEO of Orb, argues that traditional subscription-based SaaS pricing fails for AI products due to rapid cost fluctuations, margin pressures, and customer demand for clear ROI. He presents three frameworks: decide between direct monetization (add-on, bundled) or indirect (free to drive upsells) using examples like GitHub Copilot, Notion AI, and Expedia; select a value metric from resource-based tokens (Vercel's v0) to task-based (Zapier) to outcome-based pricing (Intercom's Fin at $0.99 per resolved ticket); and embrace continual experimentation, as AI pricing cycles shrink from years to months. To reduce pricing guesswork, Orb built Simulations, a tool that lets companies backtest alternate pricing strategies on real usage data from closed betas before launch, helping teams like Replit and Perplexity optimize revenue without risking customer trust.

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.

How Intuit uses LLMs to explain taxes to millions of taxpayers - Jaspreet Singh, Intuit

Jul 23, 2025 · 18:59

Jaspreet Singh, Senior Staff Engineer at Intuit, explains how TurboTax uses Anthropic's Claude and OpenAI models to generate personalized tax explanations for 44 million customers. The system, built on Intuit's GenOS platform, combines prompt-engineered static explanations with dynamic question-answering using RAG and graphRAG for tax-specific queries. Singh details their fine-tuning of Claude Haiku on AWS Bedrock, which improved quality but proved too specialized. A key focus is evaluation: manual reviews by tax analysts followed by automated LLM-as-a-judge scoring for accuracy, relevancy, and coherence, with a golden dataset and safety guardrails to prevent hallucinated numbers. He highlights challenges like latency spikes on tax day (3–10 seconds), vendor lock-in through expensive contracts, and the difficulty of upgrading models even within the same vendor. Singh emphasizes that evaluations are essential for launching any GenAI feature in a regulated domain like tax.

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

Jul 23, 2025 · 21:12

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

Excalidraw: AI and Human Whiteboarding Partnership - Christopher Chedeau

Jul 21, 2025 · 16:59

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

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.

Design like Karpathy is watching — Zeke Sikelianos, Replicate

Jul 19, 2025 · 19:26

Zeke Sikelianos of Replicate analyzes Andrej Karpathy's experience building and deploying MenuGen, a vibe-coded web app that turns menu photos into images, to argue that LLMs are now the primary audience for developer tools. He details Replicate's specific failures—rate limiting and outdated docs that blocked Karpathy—and the fixes they implemented: adding LLMs.txt files for Markdown-friendly documentation, promoting curl commands as the LLM-friendly interface, and launching an MCP server built on OpenAPI schemas. Sikelianos advocates for 'boring technology' like SQL and 'good API hygiene' to keep payloads small and information-dense for LLM context windows. He also calls for better payment acceptance and documentation discipline, stressing that unblocking power users like Karpathy (whose CEO intervened) should not require a viral blog post.

On Curiosity — Sharif Shameem, Lexica

Jul 19, 2025 · 18:35

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

The rise of the agentic economy on the shoulders of MCP — Jan Curn, Apify

Jul 18, 2025 · 18:08

Jan Curn, founder of Apify, argues that MCP (Model Context Protocol) enables a future agentic economy where AI agents autonomously discover and purchase tools from other agents or businesses (B2A/A2A). He explains that Apify's marketplace of 5,000 Actors (Docker-based tools) now integrates with MCP, allowing agents to dynamically discover and call any Actor via tool discovery — a key MCP feature. Curn demonstrates this with Claude Desktop, where an agent uses Apify's MCP server to find a venue, scrape Twitter, and even fill a form via a nested MCP server from Browserbase, all without prior configuration. He notes that Apify pays creators over $250,000 monthly, with total Actor revenue exceeding $1.5M/month, and that any developer can publish an Actor to monetize their tools instantly across the ecosystem. The talk closes with open questions about reliability, trust, and whether autonomous agent interaction can lead to AGI.

Survive the AI Knife Fight: Building Products That Win — Brian Balfour, Reforge

Jul 14, 2025 · 14:10

Brian Balfour, CEO of Reforge, argues that winning in today's AI knife-fight requires answering 'What do I build and why will it win?' by focusing on proprietary data, unique functionality, and unmet customer needs rather than building custom AI. He illustrates with Granola, which entered a crowded AI note-taker market by understanding users wanted help taking better notes, not full automation, and assembled off-the-shelf AI (DeepGram, Anthropic, OpenAI) with unique data (user notes plus transcription) and functionality (Mac app, calendar integration) to create a competitive edge. Balfour warns competitive advantages now last only 2-3 weeks, so teams must sequence smaller moats continuously, each buying time to execute faster. The talk emphasizes treating AI as Lego blocks—assembling pre-trained models, data, and product superpowers into a system that spins a data flywheel.

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

Jul 13, 2025 · 1:41:34

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

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

Jul 11, 2025 · 1:44:51

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

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.

Claude Code & the evolution of agentic coding — Boris Cherny, Anthropic

Jul 4, 2025 · 18:12

Boris Cherny, creator of Claude Code and Anthropic member of technical staff, argues that the product stays intentionally unopinionated and minimal because the model's coding capabilities are improving exponentially and the right UX remains unknown. He traces programming UX from 1950s punch cards to 1980s Smalltalk's live reload, Eclipse's static-analysis autocomplete, Copilot, and Devin's natural-language paradigm. Claude Code's terminal-first approach works in any terminal, over SSH, and inside VS Code or Cursor, with a GitHub integration that keeps data on user compute and a programmatic SDK for custom UIs. Key tips include using Claude for code-based Q&A (shortening onboarding from weeks to days), teaching it tools via `--help` and Claude MD files, leveraging TDD with visual iteration, and running multiple Claude instances in parallel via terminal tabs or GitHub Actions. Today's launch adds a plan mode triggered by Shift+Tab, which makes a plan and waits for approval before writing code.

The emerging skillset of wielding coding agents — Beyang Liu, Sourcegraph / Amp

Jun 30, 2025 · 35:06

Beyang Liu, CTO and co-founder of Sourcegraph, argues that coding agents are a real and high-ceiling skill, contrary to skeptics like Jonathan Blow and Eric S. Raymond. He presents design decisions for the agentic era: agents should directly edit files instead of asking permission, UIs should be minimal (like Amp's bare-bones VS Code extension and CLI), and fixed pricing should give way to usage-based models. In a live demo, Liu uses Amp to implement a custom icon for the linear connector in Amp's own codebase, demonstrating agentic search and sub-agents. He shares power-user patterns, including writing long prompts, constructing feedback loops with Playwright and Storybook, and running multiple agents in parallel—as exemplified by Jeff Huntley using Amp to build a compiler while sleeping. Liu emphasizes that agents should enable more thorough code reviews, not replace human understanding.

Evals 101 — Doug Guthrie, Braintrust

Jun 27, 2025 · 48:31

Braintrust solutions engineer Doug Guthrie presents the full AI evaluation lifecycle, covering offline and online strategies for building robust AI products. He explains that evals require three ingredients—tasks (prompts or agentic workflows), datasets (real-world examples), and scores (LLM-as-a-judge or code-based)—and demonstrates how to run them in Braintrust's playground and via SDK. The talk emphasizes creating a feedback loop: production logs feed into datasets, enabling human review and user feedback to iteratively improve offline evals. Guthrie showcases a changelog app, the new AI-driven "loop" feature for prompt optimization, and answers audience questions on A/B testing models, handling multiple human scorers, pre-launch validation, and exporting data for custom dashboards.

Ship it! Building Production Ready Agents — Mike Chambers, AWS

Jun 27, 2025 · 19:37

Mike Chambers, a developer advocate at AWS, demonstrates how to take a simple local agent—built with a Llama 3.1 8B model and a dice-rolling tool—and ship it to production at cloud scale using Amazon Bedrock Agents. He breaks down the essential components of an agent: model, prompt, loop, history, and tools. Then he live-deploys the agent with Bedrock Agents, configuring instructions and an action group wired to an AWS Lambda function that handles the dice roll. The fully managed service automates scaling, infrastructure, and the agentic loop. Chambers also highlights free courses on DeepLearning.AI and invites attendees to discuss MCP servers and the new open-source SDK for model-first agents.

From Mixture of Experts to Mixture of Agents with Super Fast Inference - Daniel Kim & Daria Soboleva

Jun 27, 2025 · 53:15

Daria Soboleva and Daniel Kim of Cerebras explain how Mixture of Experts (MoE) architectures enable scaling large language models efficiently by replacing monolithic feedforward networks with specialized experts, a technique used by GPT-4 and Claude. They then introduce Mixture of Agents (MoA), which combines multiple LLMs with custom prompts to outperform frontier models like GPT-4o on complex tasks, reducing a 293-second reasoning problem to 7.4 seconds using Cerebras' ultra-fast inference. The workshop guides participants to build their own MoA system, configure agents for bug fixing and performance optimization on a Python function, and achieve scores up to 120/120. Daniel details Cerebras' wafer-scale chip with 900,000 cores and distributed memory that eliminates memory bandwidth bottlenecks, enabling linear scaling and 15.5x faster inference on Llama 3.3-70B versus GPUs. Daria discusses ongoing research in diffusion models and sparsity, while Daniel notes plans for multimodal APIs and LoRA fine-tuning support.

Effective agent design patterns in production — Laurie Voss, LlamaIndex

Jun 27, 2025 · 15:38

Laurie Voss, VP of Developer Relations at LlamaIndex, presents five agent design patterns—chaining, routing, parallelization, orchestrator workers, and evaluator optimizers—for building production-ready agents. He argues that agents improve RAG by enabling introspection, self-correction, and better accuracy, and that RAG remains essential because it's cheaper and faster than feeding full context. LlamaIndex provides a framework, LlamaParse for parsing complicated documents, and LlamaCloud for managed retrieval endpoints, integrating with 400 models over 80 providers. He demonstrates how workflows in LlamaIndex enable concurrent event emitting to implement parallelization and voting to reduce hallucination, noting that three different LLMs seldom hallucinate the same answer. The evaluator optimizer pattern uses an LLM to check its own output and loop back for improvement. Multi-agent systems can be built with a single line of code by passing an array of function agents.

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

Jun 27, 2025 · 1:20:38

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

RAG in 2025: State of the Art and the Road Forward — Tengyu Ma, MongoDB (acq. Voyage AI)

Jun 27, 2025 · 18:48

Tengyu Ma, Chief AI Scientist at MongoDB (acquired Voyage AI), argues that retrieval-augmented generation (RAG) will outlast fine-tuning and long-context models for enterprise AI because it mirrors how humans use libraries—retrieving only relevant information rather than memorizing or reprocessing entire corpora. He reports that Voyage's embedding models now achieve ~80% average accuracy across 100 datasets, with half exceeding 90%, and that 100x storage compression via matryoshka learning and quantization loses only 5–10% accuracy. Ma advocates hybrid search with rerankers and domain-specific embeddings (e.g., for code) to further improve retrieval. He predicts the model layer will absorb current 'tricks' like query decomposition and contextual chunking, simplifying RAG pipelines. New products like multimodal embeddings (accepting screenshots of PDFs, tables, videos) and auto-chunking embeddings that incorporate cross-chunk metadata are designed to shift complexity from users to model providers.

Revenue Engineering: How to Price (and Reprice) Your AI Product — Kshitij Grover, Orb

Jun 27, 2025 · 15:39

Kshitij Grover, CTO of Orb, argues that AI-native pricing treats monetization as a first-class engineering concern, with pricing acting as a form of friction that must balance value delivery, audience, and rapidly changing margins. He walks through examples like Replit’s multi-tier transparent pricing with a free tier to prove value before charging, Unify’s higher price point and credit-based model to signal enterprise readiness, and Cloudflare’s charging for CPU milliseconds rather than wall time to pass on architectural advantages. Grover explains that margins are not fixed; companies should protect against degenerate workloads with guardrails rather than linear scaling, as Jasper did by going unlimited after switching models seamlessly. He emphasizes flexibility, noting Orb customers make price changes two to three times a month, and advises simulating pricing impacts on different usage cohorts. Predictions include price wars, convergence toward effectively unlimited plans with caps, more real outcome-based pricing with clear SLA definitions, and real-time spend visibility with agent prompts estimating credit usage.

Building Agentic Applications w/ Heroku Managed Inference and Agents — Julián Duque & Anush Dsouza

Jun 27, 2025 · 52:35

In this workshop, Heroku Principal Developer Advocate Julián Duque and Product Manager Anush Dsouza introduce Heroku Managed Inference and Agents, a platform designed to make every software engineer an AI engineer by simplifying the attachment of agents and AI to applications. They demonstrate an opinionated, curated set of models (e.g., Claude 4) and an agentic control loop running on Heroku's trusted compute (Dynos) that provides first-party tools like code execution (Python, Node, Go, Ruby), Postgres schema inspection and querying, and document conversion, all streaming responses in real time. The workshop walks through provisioning inference via a single CLI command or add-on, using a Jupyter notebook to chain multiple tools (e.g., HTML-to-markdown then Python execution), and attaching custom MCP servers (like Brave Search) that spin up one-off Dynos and scale to zero. They also show how to expose MCPs remotely via a server-sent events endpoint for use with Cursor or other clients, emphasizing security (read-only database followers, bearer tokens) and future OAuth support. The episode concludes with a call to try the platform via a free trial team valid through the weekend.

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

Jun 25, 2025 · 18:47

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

Building Protected MCP Servers — Den Delimarsky and Julia Kasper, MCP Steering Committee & Microsoft

Jun 20, 2025 · 20:13

Den Delimarsky and Julia Kasper, Microsoft engineers on the MCP Steering Committee, explain how the new MCP authorization spec simplifies securing remote MCP servers by separating the resource server from the authorization server, eliminating the need for developers to build custom token factories. They argue that developers shouldn't need to be security experts, so the spec offloads token minting and lifecycle management to standard identity providers like Entra ID, Okta, or Auth0. The client now handles the full OAuth 2.0 dance, while the server only validates tokens via a Protected Resource Metadata (PRM) document. A live C# SDK demo shows a server configured with minimal code, and an Azure API Management deployment demonstrates production-ready remote MCP servers with OAuth proxy and consent flows, including integration with VS Code and GitHub Copilot. The session also previews transforming REST APIs into MCP tools via Azure API Management.

Remote MCPs: What we learned from shipping — John Welsh, Anthropic

Jun 19, 2025 · 15:12

John Welsh, a software engineer at Anthropic, explains how his team standardized on the Model Context Protocol (MCP) for all internal and external integrations, treating it as a universal JSON-RPC stream that can be piped through any transport—including web sockets, gRPC, or even email. He argues that adopting MCP internally solves integration chaos by providing a single, well-defined interface for tool calling, resource access, and authentication, and that building an "MCP gateway" as shared infrastructure creates a pit of success where engineers naturally follow the correct pattern. Welsh details how the gateway handles OAuth flows, credential portability for batch jobs, rate limiting, and observability, while also enabling future features like sampling and prompt injection defense at no extra cost. The talk emphasizes that MCP's message format, not the transport layer, delivers the most value, and that standardizing on any protocol—preferably MCP—reduces engineering overhead and allows teams to focus on high-leverage work.

MCP: Origins and Requests For Startups — Theodora Chu, Model Context Protocol PM, Anthropic

Jun 18, 2025 · 17:45

Theodora Chu, product manager at Anthropic, explains the origin of the Model Context Protocol (MCP) as an open-source standard for giving LLMs agency to interact with external tools and data, born from two engineers copying context manually. She details MCP's evolution from an internal hack week project to wide adoption by Google, Microsoft, OpenAI, and coding tools like Cursor and VS Code. Key protocol decisions include optimizing for server simplicity over client complexity, adding streamable HTTP for bidirectionality, and fixing authentication via community contributions. Chu outlines three startup opportunities: building high-quality MCP servers for verticals beyond dev tools (80% weight), simplifying server building with hosting/testing/deployment tooling, and creating AI security and observability tools. She emphasizes that models are a third user of servers, so tool design must consider end users, client developers, and the model itself.

Exposing Agents as MCP servers with mcp-agent: Sarmad Qadri

Jun 11, 2025 · 18:05

Sarmad Qadri, CEO of Lastmile AI, argues that agents should be exposed as MCP servers, enabling multi-agent composition and async workflows. He introduces mcp-agent, a framework implementing Anthropic's effective agent patterns—augmented LLM, evaluator-optimizer, orchestrator—on top of the Model Context Protocol. Qadri demonstrates an agent that reads a student story, fetches an APA style guide via a fetch MCP server, and writes a graded report, all orchestrated as a durable Temporal workflow. He explains that MCP standardizes tool connections for LLMs, shifting agentic behavior from client-side to server-side, allowing agents to be invoked from any MCP client like Claude or Cursor. The talk covers how this paradigm enables scalable, platform-agnostic agents that can be paused, retried, and scheduled.

Why Bolt.new Won and Most DevTools AI Pivots Failed - Victoria Melnikova

Jun 10, 2025 · 5:45

Victoria Melnikova explains how StackBlitz's Bolt.new achieved explosive growth from near-death to over 100M ARR by avoiding common AI pivot traps. She outlines three mistakes: adding a chatbot UI, competing broadly against big AI labs, and waiting for perfect AI instead of building tactically. StackBlitz succeeded by identifying its unfair advantage—running full dev environments in the browser without containers or servers—and amplifying it with AI to let users describe apps and see them live instantly. This created a new category of vibe coding, not just an AI feature. Melnikova urges devtools founders to find their unique moat and reinvent workflows rather than bolt AI onto existing ones.

The Many Ends of Programming - Ray Myers

Jun 10, 2025 · 27:12

Ray Myers, Chief Architect at All Hands AI, argues that the future of software engineering is not predetermined and we have a say, categorizing competing visions into six distinct endgames: extreme completion, dev apocalypse (innovator's paradise), abstraction leap, uncharted waters, review economy, and infinite pile of garbage. He illustrates extreme completion with a real example where an AI agent generated a 48-file pull request from a Slack message, and abstraction leap via domain-specific languages (DSLs) shown in the Parcel paper’s 61 prompts producing a 220-line Lisbon interpreter. Myers warns that dev apocalypse is desirable but not yet feasible, while the review economy is a pit stop where manual review bottlenecks must be managed using Theory of Constraints. He cites contradictory studies: UpLevel found developers with coding assistants had higher bug rates, while GitHub Copilot claimed improved quality; he notes 2024 was the first year copy-pasted code exceeded refactored code, a red flag for tech debt. Ultimately, Myers urges deliberate choices: whether we want no programmers or everyone to be a programmer, and whether we prioritize quality over quantity.

Are MCPs Overhyped? A Rant about MCPs — Henry Mao, Smithery

Jun 3, 2025 · 7:29

Henry Mao, founder of Smithery and MCP steering committee member, argues that despite MCPs standardizing AI agent-service connections, the ecosystem faces fragmentation, high-friction installation, security, and monetization problems. Users struggle with unreliable MCP servers and complex five-step installs, while developers face hosting challenges, lacking tooling, distribution hurdles, and unclear monetization. Smithery aims to solve these as an AI gateway, demoing an agent that finds GitHub issues and creates Linear tickets using curated MCPs. Mao envisions a future dominated by tool calls where agent experience trumps user experience.

The Coherence Trap: Why LLMs Feel Smart (But Aren’t Thinking) - Travis Frisinger

Jun 3, 2025 · 20:47

Travis Frisinger argues that large language models are not intelligent but coherent, introducing 'coherence reconstruction' as a mental model for understanding their utility. He explains that hallucinations are a feature, not a bug, as models fill gaps predictably to maintain pattern completion. Prompts act as force vectors navigating latent space, and the key to reliable outputs is a 'frame, generate, judge, iterate' loop. Frisinger presents a three-layer model: latent space, execution layer (tools and RAG), and conversational interface. He advises engineers to design for emergence rather than control, using dense context as anchors to steer generation, and to watch for breakdowns in tone as early signs of lost coherence.

Agents reported thousands of bugs, how many were real? - Ian Butler and Nick Gregory

Jun 3, 2025 · 18:39

Ian Butler and Nick Gregory introduce SM-100, a benchmark of 100 real-world bugs across 84 repositories, and present their agent Bismuth as outperforming existing agents in detecting complex bugs—finding 10 needles vs 7 for the next best. However, even top performers struggle: Bismuth's true positive rate is only 25%, and Codex leads at 45%, while most agents (Cursor, Debian) report thousands of false positives (97% for basic loops). They argue that agents universally exhibit narrow thinking, missing simple bugs like a form state issue that only Bismuth and Codex caught, and that high SWE-bench scores do not translate to maintenance tasks. The episode concludes that software maintenance remains an unsolved problem requiring deeper reasoning and targeted search.

Invisible Users, Invisible Interfaces: Accelerating Design Iteration with AI Simulation - Alex Liss

Jun 3, 2025 · 12:37

Alex Liss, VP of Data Science and AI at Huge, argues that AI should be used as a tool for design itself rather than as a feature, proposing Intelligent Twins—AI simulations of user personas—to accelerate needfinding and interface testing. Citing a trust gap where only 32% of US adults trust AI, he advocates for repairing it by designing better interfaces, not adding chatbots. He demonstrates a global audit of sports websites (NBA, Olympics, Premier League) where Intelligent Twins simulated casual and super fans across 72 tasks, revealing strong navigation but declining performance in information architecture and engagement. The methodology uses computer use agents for visual evaluation and human-in-the-loop review to generate focused design briefs. Limitations include reproducibility and the need for test-and-control validation, with future potential in integrating MCP protocol for turning Figma components into code. Liss concludes that AI simulation can help teams gather insights faster and create simpler, trustworthy interfaces.

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

Jun 3, 2025 · 25:09

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

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.

Letting AI Interface with your App with MCP — Kent C Dodds

Jun 3, 2025 · 19:54

Kent C Dodds explains how Model Context Protocol (MCP) enables AI assistants like Claude Desktop to interface with any app or service, moving beyond limited built-in integrations. He traces the evolution from early LLM chat (phase one) through host applications with custom integrations (phase two) to MCP's open standard (phase three), arguing that MCP lets developers build once for any assistant. In his live demo, he runs a Locationator server to derive his location, a GetWeather server for weather, and an Epic Me server with OAuth authentication to create a journal entry. MCP servers handle tools, resources, and prompts; the client standardizes communication while the server controls unique logic. Kent contends this protocol is how we give AI "hands" to perform real tasks, leading toward a universal Jarvis-like assistant that can dynamically connect to any service without manual integration per platform.

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.

Self Coding Agents — Colin Flaherty, Augment Code

Apr 21, 2025 · 17:23

Colin Flaherty, founding researcher at Augment Code, describes how the company built an AI coding agent that wrote over 90% of its own 20,000-line codebase with human supervision. The agent autonomously added third-party integrations like Google Search and Linear by searching its own codebase and even used its own Google Search tool to look up Linear API docs. It profiled and optimized itself, replacing synchronous file hashing with a process pool after adding print statements and running sub-copies. Flaherty argues that agent capabilities improve with better context engines, code execution environments, and test harnesses—adding test-driven iteration boosted a bug-fixing benchmark by 20% versus 4% from just upgrading the foundation model. He cautions that agents are general-purpose, not category-specific, and have different strengths than humans, making knowledge bases crucial for onboarding. With code becoming cheap, the focus shifts to product insights and design, while better tests enable greater autonomy and accelerate agent self-improvement.

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

Apr 19, 2025 · 22:26

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

Stateful Agents — Full Workshop with Charles Packer of Letta and MemGPT

Apr 19, 2025 · 1:19:34

Charles Packer, lead author of the MemGPT paper and co-founder of Letta, argues that statefulness (memory) is the most important problem to solve for building useful AI agents, since LLMs are inherently stateless transformers. He presents MemGPT's LMOS (Language Model Operating System) approach, which treats memory management as a context compilation problem solved by the LLM itself using tool calling to read and write structured memory blocks. The workshop demonstrates Letta's open-source stack (FastAPI, Postgres, Python) where agents persist state on a server, enabling long-running, learning interactions without context overflow—e.g., an agent can update its core memory (e.g., correcting a user's name) or search archival memory (e.g., recalling user preferences after a reset). Packer also shows multi-agent communication via async message passing between agents running as independent services, and highlights that tools are sandboxed by default with support for Composio integrations. The session includes a live notebook exercise and a low-code UI (ADE) showing context window management and memory editing, emphasizing that true stateful agents improve continuously over time rather…

Insights on Building AI Teams — Heath Black, SignalFire

Apr 15, 2025 · 20:30

Heath Black, Managing Director of Product at SignalFire, uses Beacon platform data to guide AI team building, arguing that credentialism is declining—only 7% of AI engineers had PhDs in 2023 versus 16% in 2015—and that work experience now outweighs education. He shows AI talent concentrates in San Francisco (35% of AI engineers), Seattle (22%), and New York (10%), and that tracking retention rates (e.g., Anthropic at 66% four-year retention vs. Perplexity at 43%) helps time outreach. Black advises hiring based on a candidate's body of work, removing academic requirements from postings, and understanding generational job-hopping (27% of Gen Z left jobs in 2023). He warns against relying solely on salary and equity, as AI engineers command 5% salary and 10–20% equity premiums, and recommends narratives centered on mission, speed, and collaborative teams. The talk emphasizes using data to filter, locate, time, and close hires effectively.

Anthropic in the Enterprise — Alexander Bricken & Joe Bayley

Apr 13, 2025 · 20:55

Alexander Bricken and Joe Bayley from Anthropic's Applied AI team argue that enterprise AI implementation often fails due to overengineering, poor data infrastructure, or lack of testing—but industry leaders achieve transformative results with Claude. They detail Anthropic's deployment models (API, cloud partnerships, enterprise solutions) and real-world case studies like Intercom's Fin agent, which solved 86% of support volume using Claude. Best practices include building evals early as intellectual property, identifying intelligence/cost/latency trade-offs based on use-case stakes, and avoiding premature fine-tuning by trying prompt caching, contextual retrieval, and agentic architectures first. They also highlight interpretability research and the Model Context Protocol for reliable AI deployments.

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

Mar 26, 2025 · 15:15

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

How Windsurf writes 90% of your code with an Agentic IDE - Kevin Hou, Windsurf

Mar 11, 2025 · 20:50

Kevin Hou, head of product engineering at Codeium, introduces Windsurf as the first AI agent-powered editor, arguing that agents are the future of software development. The editor is built on three principles: trajectories, a unified timeline that lets the agent read the user's mind and execute commands like 'continue my work'; meta-learning, which auto-generates memories of user preferences and codebase context; and scaling with intelligence, removing legacy features like chat and @-mentions as models improve. Windsurf launched three months ago and has already generated 4.5 billion lines of code, with 90% of code now written via its Cascade agent. Hou emphasizes that the agent reduces human-in-the-loop effort by inferring context, running terminal commands in the user's environment, and dynamically retrieving documentation—allowing developers to contribute less input while getting more production-ready output.

Building Agents with Model Context Protocol - Full Workshop with Mahesh Murag of Anthropic

Mar 1, 2025 · 1:44:12

Mahesh Murag of Anthropic presents the Model Context Protocol (MCP) as an open standard that replaces fragmented integrations with a single protocol for connecting AI systems to data sources, enabling context-rich AI applications and agentic experiences. He explains MCP's philosophy, inspired by APIs and LSP, and its three interfaces: tools (model-controlled), resources (application-controlled), and prompts (user-controlled). Murag highlights adoption with over 1,100 community-built servers and official integrations from companies like Cloudflare and Stripe. He demonstrates building agents with MCP using the MCP-Agent framework, showing how agents can use tools dynamically and composably across hierarchical systems. Future plans include remote server support with OAuth 2.0, a centralized registry for discovery and verification, and enabling agents to self-evolve by dynamically finding new capabilities via registry search.

Beyond APIs: How AI Web Agents Are Automating the "Long Tail" of Knowledge Work

Feb 22, 2025 · 17:44

Arjun and Bhavani present Rtrvr.ai, a universal AI web agent using a text-based approach to autonomously perform tasks across multiple browser tabs at under a penny per page. They argue text-based reduces hallucination compared to vision-based agents like OpenAI's operator, and being a Chrome extension avoids password sharing and accesses logged-in content. Features include deep research navigating multiple pages, dynamic function calling for any third-party API, and graph generation. Rtrvr extracts structured data, performs actions like clicking dropdowns, and processes tabs simultaneously, automating the long tail of knowledge work including market research, LinkedIn automation, and WhatsApp messaging. They claim a distributed subtask approach lowers failure rates and envision collaborative dataset construction, e.g., aggregating local government events.

Your Evals Are Meaningless (And Here’s How to Fix Them)

Feb 22, 2025 · 18:50

In this AI Engineering Summit talk, HoneyHive co-founder exposes why most LLM evaluations are meaningless due to criteria drift—where evaluator criteria misalign with user needs—and dataset drift, where test cases don't reflect real-world queries. He argues that static evaluation frameworks from tools like LangChain or Ffragas fail because they measure generic metrics rather than business-specific relevance, citing an e-commerce recommendation system that looked perfect in testing but broke in production. The fix is a three-step iterative alignment process: align evaluators with domain experts via continuous critique and few-shot examples; keep datasets alive by logging production underperformance and flowing those cases back into the test bank; and track alignment over time using F1 scores for binary judgments. Practical advice includes customizing the LLM evaluator prompt, starting with 20 domain expert examples in spreadsheets, and avoiding templated metrics. The speaker emphasizes that evals must evolve continuously, just like the LLM application itself, or they become meaningless.

OpenLLMetry is all you need

Feb 22, 2025 · 9:12

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

The Model Isn’t Wrong—You’re Just Bad at Prompting

Feb 22, 2025 · 8:54

Dan from PromptHub argues that prompt engineering remains critical for improving LLM outputs, covering Chain of Thought, few-shot, and meta prompting techniques. Chain of Thought breaks problems into sub-problems and is built into reasoning models; few-shot prompting works best with just one or two diverse examples, but can degrade performance on reasoning models like O1 and R1. Meta prompting uses LLMs to write or refine prompts, with PromptHub offering model-specific enhancers. For reasoning models, Dan advises minimal prompting, encouraging more reasoning instead of few-shot, and avoiding instructing the model on how to reason. Free resources include PromptHub's templates, the AutoReason prompt, and the Prompt Engineering Substack.

Tool Calling Is Not Just Plumbing for AI Agents — Roy Derks

Feb 22, 2025 · 25:18

Roy Derks argues that tool calling is the most critical yet overlooked component of AI agents, far more than mere 'plumbing.' He contrasts traditional tool calling—where developers manually manage callbacks, retries, and errors within the agent loop—with embedded tool calling, a black-box approach used by frameworks like LangChain’s createReactAgent. Derks advocates for separation of concerns via the Model Context Protocol (MCP) from Anthropic, which splits tool logic into MCP servers communicating with clients, and via standalone tool platforms such as IBM’s wxflows, Composio, and Toolhouse that let teams build tools once and reuse them across LangChain, CrewAI, or AutoGen. He also introduces dynamic tools, where an agent generates queries on the fly—e.g., using GraphQL or SQL schemas—instead of defining hundreds of static tools, noting that LLMs like Claude handle GraphQL well but may hallucinate on deeply nested schemas. The episode emphasizes that 'an agent is only as good as its tools' and provides practical guidance on designing tool descriptions (which act like system prompts) and output schemas to enable type-safe, chainable tool calls.

Your LLM Ran Out of Knowledge — Now What?

Feb 22, 2025 · 12:51

Speaker 1 presents a technique for applying LLMs to low-knowledge domains like corporate negotiations and geopolitics, where structured training data is scarce. The method uses a parsing engine to identify the problem type and match domain-specific heuristics—binary rules like 'must prioritize agreements with highest combined value' for negotiations or 'must have three independent paths for critical resources' for geopolitics. After reformatting the input for consistency, the system sends it to a reasoning model (e.g., Anthropic's Claude with a world sim) that applies the rule set alongside powerful reasoning capabilities. The demo shows an intelligence estimate scenario where the model identifies geopolitics, reformats the query, and evaluates options against rules—eliminating those that breach heuristics (e.g., scenario five violating a rule on control thresholds). The approach enables generating dozens of scenarios in a fraction of the time a human expert would take, allowing practitioners to explore more options and find novel solutions while keeping a human in the loop for subject-matter oversight.

How Coding Agents change Software Development Forever - Hailong Zhang

Feb 22, 2025 · 8:50

Hailong Zhang presents how coding agents, particularly the unit test agent Gru, transform software development by automating routine tasks while humans focus on creative work. In the future workflow, synchronous agents like GitHub Copilot and Cursor assist in real-time, while asynchronous agents like Gru autonomously handle tasks such as writing tests, fixing bugs, and submitting pull requests. Gru, built to boost unit tests, detects code changes from pull requests, generates and runs tests, and submits a new PR with a summary and coverage improvement. In production, over 50% of Gru's PRs are accepted by humans, and it handles 80% of unit tests in its own repo, making it the top contributor. To build such agents, Zhang emphasizes defining a clear problem (e.g., unit tests, not generic software engineering), creating datasets and evaluation harnesses, selecting and fine-tuning LLMs per stage, building task-specific context from environment data, and developing an agent operating system to reuse common infrastructure across different tasks.

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.

Claude plays Minecraft!

Feb 15, 2025 · 18:16

Derek from AWS demonstrates building Rocky, an autonomous Minecraft agent using Amazon Bedrock, Claude 3 Haiku, and serverless AWS services, proving agentic workflows enable AI to reason and act beyond chatbots. He explains the architecture: Minecraft server on ECS with Mineflare bot framework, agents for Bedrock with return of control, and prompt engineering for tasks like digging and building. In a live demo, Rocky jumps, finds players, digs a hole, and builds a double-decker couch from a chat command, inferring parameters from natural language. The code is open-source and built with CDK/CloudFormation, emphasizing that agentic AI can operate in complex 3D environments through tool orchestration and managed prompt design.

System Design for Next-Gen Frontier Models — Dylan Patel, SemiAnalysis

Feb 11, 2025 · 18:29

Dylan Patel of SemiAnalysis breaks down the inference challenges for next-generation frontier models like GPT-4 (1.8 trillion parameters) and upcoming models trained on 100,000+ GPU clusters. He emphasizes that prefill (prompt processing) is compute-intensive while decode (token generation) is memory bandwidth-intensive, creating a systems problem where serving 64 users at 30 tokens/second requires 60 terabytes/second of memory bandwidth. Patel details engineering strategies such as continuous batching to improve batch utilization by 10-100x, disaggregated prefill to isolate noisy neighbors and maintain time-to-first-token SLAs, and context caching (like Google's) to cache KV cache on CPU/storage instead of GPU memory, dramatically reducing prefill costs. He warns that open-source tools like LLaMA.cpp lack these optimizations, making high-performance serving of models like LLaMA 405b infeasible without libraries like vLLM or TensorRT-LLM. On scaling, Patel notes that 100,000 GPU clusters (e.g., Microsoft's Arizona data center consuming 150 MW) face reliability issues — optical transceivers fail every five minutes — and straggler chips (silicon lottery) can degrade training…

LLM Quality Optimization Bootcamp: Thierry Moreau and Pedro Torruella

Feb 8, 2025 · 53:05

Thierry Moreau of OctoAI demonstrates how to fine-tune Llama 3 8B on a PII redaction task using OpenPipe and OctoAI, achieving 47% better accuracy and a 200x cost reduction (from $30 to $0.15 per million tokens) compared to GPT-4 Turbo. He explains that fine-tuning should follow prompt engineering and RAG, and works best for specialized tasks like function calling. The talk walks through building a fine-tuning dataset from the PI Masking 200k dataset, using OpenPipe to train a LoRA for $40, deploying it on OctoAI, and evaluating it to show the fine-tuned model scores 0.97 accuracy versus GPT-4’s 0.68. Moreau emphasizes that this continuous deployment cycle requires monitoring data drift and retraining, but tools like OpenPipe and OctoAI make it accessible even for teams without deep ML expertise.

Agentic Workflows on Vertex AI: Rukma Sen

Feb 8, 2025 · 18:06

Google Cloud's Rukma Sen argues that AI agents are the essential bridge between generative models and users, and Vertex AI provides a platform to build and deploy them with enterprise-grade safety and flexibility. She defines agents as systems with a model (brain), tools (hands), and orchestration (nervous system), covering deterministic, generative, and hybrid types. For production reliability, she advocates multi-agent architectures, giving the example of a customer service system with dispatcher, expert, and supervisor agents—and a personal anecdote where a supervisor agent kept rejecting outputs. Use cases span customer support, employee HR, knowledge agents, and voice agents for drive-throughs. Vertex AI offers 150+ models (Google, Anthropic, LLaMA) and Agent Builder from no-code to full-code, with enterprise security and data privacy.

[Full Workshop] How to add secure code interpreting in your AI app: Vasek Mlejnsky

Feb 6, 2025 · 1:48:16

Vasek Mlejnsky, CEO of E2B, demonstrates how to add secure AI code execution to any app using E2B’s Code Interpreter SDK alongside Anthropic's Sonnet 3.5 and Vercel’s AI SDK. The workshop builds an open-source version of Claude’s artifacts UI, running Python code in isolated Firecracker VMs that start in ~900ms and support custom environments via Dockerfiles. Vasek explains how E2B’s Jupyter-server-based sandbox returns stdout, stderr, runtime errors, and rich outputs like PNG charts, which are streamed to the front end using Vercel’s stream data. He covers security architecture—full root access in a VM that self-destructs on escape—and plans for AWS/GCP self-hosting and snapshot-based agent branching. The episode also addresses customizing sandboxes with private packages, mounting cloud storage (S3, GCS), and interpreting table previews as HTML or images.

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.

Lessons from the Trenches: Building LLM Evals That Work IRL: Aparna Dhinkaran

Feb 6, 2025 · 18:49

Aparna Dhinakaran, co-founder of Arize AI, distinguishes between model evals (e.g., Hugging Face leaderboard) and task evals for real-world LLM systems, arguing that production applications need component-level evaluations like router and parameter evals. She demonstrates a chat-to-purchase app where a router function call misidentifies user intent, showing how Phoenix open source tool traces errors and provides explanations to iterate. Dhinakaran advises using categorical over numeric LLM-as-judge scores because numeric outputs tend to be binary (0 or 10) and lack granularity. Presenting needle-in-haystack research, she notes GPT-4 struggles retrieving facts placed early in large context windows, and in retrieval-with-generation tasks, Anthropic’s Claude 2.1 outperforms GPT-4 due to verbose reasoning, a gap closed by prompting GPT-4 to explain itself first.

Iterating on LLM apps at scale Learnings from Discord: Ian Webster

Nov 22, 2024 · 18:26

Ian Webster, Senior Staff Engineer at Discord and maintainer of Promptfoo, shares how Discord built and scaled Klyde AI, a chatbot for 200 million users, focusing on evaluation and safety. He argues that evals should be treated as simple, deterministic unit tests that run locally, avoiding complex metrics, and that breaking the system into small, testable pieces (e.g., checking for lowercase output to enforce casual tone) achieves 80% of the goal with 1% of the work. Webster details how Discord mitigated risks like the 'grandma jailbreak' (which originated on Discord) by using an attacker LLM to generate adversarial inputs and a judge to refine them, exposing cracks in safeguards. He advocates for pre-deployment red teaming over live filtering, and describes using Promptfoo for risk assessment across brand, legal, and safety categories. The episode also covers prompt management via Git and Retool, routing with occasional GPT-4 responses to correct model drift, and the challenge of closing the feedback loop due to privacy constraints, relying instead on dogfooding and public examples.

The AI emperor has no DAUs why most devs still don't use code AI: Quinn Slack

Nov 20, 2024 · 18:45

Quinn Slack, CEO and cofounder of Sourcegraph, argues that despite massive hype, only about 5% of professional developers actually use Code AI tools, with total recurring revenue from Code AI sitting at roughly $300 million ARR—a fraction of Salesforce's $36 billion. He cites GitHub's 1.3 million paid Copilot subscribers and just 935,000 yearly active users receiving suggestions, revealing the gap between perception and reality. Slack warns that the entire AI ecosystem—foundation models, infra, and applications—risks collapse if usage doesn't grow, and most revenue in AI flows to NVIDIA and chip makers, not software. From building Cody, the number two Code AI product, he shares lessons: hype fools everyone, autocomplete is a freakishly good feature that spoils expectations, while chat and agents are harder to vet and adopt. He advises builders to use their own product daily, ignore customer demands for buzzwords like fine-tuning, and manually build explicit interactions before adding magic. Slack concludes that the industry must collectively dehype and focus on real daily active users to turn the potential into sustained enterprise revenue.

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

Nov 4, 2024 · 21:30

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

AI Engineering Without Borders — swyx

Oct 30, 2024 · 10:32

In this talk from the AI Engineer World's Fair, host swyx argues that AI inherently disrespects human-made borders—it is naturally multilingual, multimodal, and indifferent to copyright or ground truth. He challenges the field to define its own laws, distinguishing constants (e.g., humans speak at 80 wpm vs. read at 200 wpm) from contingent facts (e.g., Apple Intelligence's 30 tokens/sec baseline). Reflecting on one year of the 'Rise of the AI Engineer,' he notes that the conference tracks—RAG, code gen, agents, multimodality—are arbitrary constructs we created, not natural categories. He proposes that AI Engineering sits between software engineering and real engineering: it must apply natural sciences for humanity's benefit. The talk concludes with a call to 'disagree more'—with your own conclusions, each other, and the status quo—and to transform the Shoggoth of raw AI into mass transit tools for society.

Second Order Effects of AI: Cheng Lou

Oct 28, 2024 · 21:46

Cheng Lou explores how to anticipate second-order effects of AI by examining who is learning, widening information bandwidth, and extrapolating quantity to extremes. He uses chess and Go as examples where AI initially seemed to end human play but actually improved it, likening this to Conway's Game of Life's emergent behavior. He argues AI can aid human learning in drawing through stroke auto-completions and in music via indirect manipulation of spectrograms, shifting focus from automation to personal skill development. He envisions personalized AR language translation to replace one-size-fits-all text, and critiques current UI designs by proposing machine-learned gesture interpretation that considers full context. Finally, he extrapolates generating thousands of AI-curated UI layouts at design time, then using classification at runtime to deliver dynamic, context-aware interfaces, moving beyond static media queries.

Building and Scaling an AI Agent Swarm of low latency real time voice bots: Damien Murphy

Oct 8, 2024 · 1:07:23

Damien Murphy, Senior Applied Engineer at Deepgram, demonstrates building and scaling low-latency real-time voice bots using Deepgram's new voice agent API, which wraps speech-to-text, LLM, and text-to-speech into a single streaming endpoint. He shows a drive-thru ordering demo with function calling (add/remove items) using GPT-4o, achieving sub-second latency by co-locating components. Murphy explains scaling to millions of concurrent calls through regional Kubernetes clusters and multi-agent swarms (routing, booking, support agents) to reduce complexity and cost. He addresses endpointing challenges, VAD-based barge-in, and cost/quality trade-offs with hosted vs. self-hosted models, noting Deepgram offers 20x cheaper TTS than ElevenLabs and 50ms STT latency self-hosted. The talk emphasizes keeping agents simple, using smallest capable LLMs, and composability for reuse.

Pydantic is STILL all you need: Jason Liu

Sep 6, 2024 · 15:21

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

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

Decoding the Decoder LLM without de code: Ishan Anand

Aug 9, 2024 · 17:08

Ishan Anand demonstrates how decoder-based LLMs like GPT-2 work internally using a fully functional spreadsheet implementation. He explains tokenization (e.g., 're-injury' splitting into 'rain' and 'injury' due to subword units), 768-dimensional embeddings, multi-headed attention where tokens look backward (e.g., 'he' focuses 0.48 on 'Mike'), and the multi-layer perceptron with matrix multiplies (MMULT). He shows residual connections creating an information superhighway and uses logit lens to reveal layer-by-layer predictions (e.g., 'Wednesday' appears early but only rises to top probability at later layers). Finally, he injects a sparse autoencoder feature vector for 'Jedi' into the residual stream, steering GPT-2 to output 'lightsaber' instead of 'phone', and contrasts this with alternative steering methods like representation engineering and activation steering.

What's new from Anthropic and what's next: Alex Albert

Aug 5, 2024 · 13:38

Alex Albert, Head of Developer Relations at Anthropic, argues the industry is in a 'magic star icon phase'—tacking AI onto existing products—and urges rebuilding from the ground up. He announces Claude 3.5 Sonnet, which scores 64% on pull request evals (vs 38% for 3 Opus), with 200k context, vision improvements, and pricing at $3/M input and $15/M output tokens. New features include Artifacts for collaborative creation of code and React components from screenshots, Projects for team knowledge grounding, and an enhanced ToolUse API supporting hundreds of tools and structured JSON output. Future models (3.5 Haiku/Opus) will be smarter, cheaper, and faster; a steering API for interpretability allows clamping feature values to control outputs.

From Software Developer to AI Engineer: Antje Barth

Jul 24, 2024 · 19:48

Antje Barth, a Principal Developer Advocate for generative AI at AWS, outlines five practical steps from software developer to AI engineer: understanding foundation models, getting hands-on with AI developer tools like Amazon Q Developer, prototyping with models via Amazon Bedrock, integrating agents, and staying up to date with community events. She demonstrates Amazon Q Developer's ability to generate, explain, and transform code, reducing unvaluable tasks from 70% to focus on creative work. Barth introduces Amazon Bedrock's unified Converse API for standardized model invocation across providers like Anthropic's Claude 3.5 Sonnet, and shows how agents can be built to control a Minecraft bot through reasoning and tool use. The episode concludes with the announcement of the AI Engineering Hub at the AWS loft in San Francisco for community workshops and events.

Open Challenges for AI Engineering: Simon Willison

Jul 17, 2024 · 18:49

Simon Willison argues the GPT-4 barrier has been broken as GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro, and open models like LLaMA 3 70B now compete, making GPT-4-class models a commodity. He highlights the AI trust crisis with examples of Dropbox and Slack being falsely accused of training on user data, and notes Anthropic trained Claude 3.5 Sonnet without customer data. Willison warns about prompt injection vulnerabilities, citing the Markdown image exfiltration bug affecting six major chatbots, and defines slop as unreviewed AI-generated content, calling for accountability and responsible use patterns.

Pragmatic AI with TypeChat: Daniel Rosenwasser

Nov 14, 2023 · 18:34

Daniel Rosenwasser, TypeScript program manager, introduces TypeChat, an experimental library that uses TypeScript type definitions to guide and validate unstructured LLM output into structured JSON for traditional apps. He demonstrates a coffee shop ordering system where types define the schema, showing how the library can handle ambiguous inputs like 'a purple gorilla' by including unknown text for recovery. TypeChat also generates programs as JSON using a fake language to safely script multi-step operations, avoiding sandboxing issues from real code. A Python prototype extends the same approach, with examples like CSV data manipulation via a class-based API. The library aims to make AI tools accessible to all engineers by leveraging types they already use.

Building Reactive AI Apps: Matt Welsh

Nov 9, 2023 · 17:02

Matt Welsh announces AI.JSX, an open-source TypeScript framework he describes as 'React for LLMs,' which lets developers build reactive AI applications by composing JSX components that render to an LLM rather than the DOM. He argues AI.JSX makes LLM app development accessible to JavaScript developers, not just Python back-end engineers, by handling RAG, tool invocation, and real-time voice interaction out of the box. Welsh demonstrates parallel streaming of multiple LLM calls for story generation, a kid-safe wrapper component that rewrites content, and a 10-line RAG implementation. He showcases a live voice demo where an AI takes a donut order with sub-second latency, powered by Fixie's cloud platform for hosting, managed RAG pipelines, and conversational state. He emphasizes the framework's full React integration and ability to generate UI from AI, positioning AI.JSX as a simplification for building sophisticated LLM-powered apps.

AI Engineering 201: The Rest of the Owl

Nov 8, 2023 · 56:57

Charles Frye, instructor of the Full Stack LLM Bootcamp, presents essential patterns for building language user interfaces (LUIs), arguing that while RAG chatbots are the 'to-do list app' of AI engineering, structured outputs via function calling (e.g., OpenAI's JSON schema, Instructor library) improve robustness, and agents with memory (like generative agents or Voyager in Minecraft) represent the true AI frontier. He emphasizes the need for hybrid search combining vector and keyword retrieval (citing Vespa, Postgres, Redis), and warns that monitoring and evaluation are the hardest engineering challenges: monitoring user behavior, latency quantiles (especially 99th percentile), and costs must be paired with observability tools like Honeycomb or Gantry, while evaluation often requires iterated decomposition or using LLMs as evaluators (GPT-4 as 90th percentile crowd worker). The episode concludes that shipping to learn — starting with production data to generate tests — is the dominant engineering mindset, and that the field is still filling in the gaps between inference and full product value.

[Workshop] AI Engineering 201: Inference

Nov 7, 2023 · 1:43:16

Charles Frye, instructor of the Full Stack LLM Bootcamp, leads a workshop on AI engineering inference, focusing on the build-versus-buy decision between proprietary and open models. He argues that proprietary models like OpenAI's GPT-4 and Anthropic's Claude are currently more capable but expensive, while open models like LLaMA 2 are less capable but offer hackability, though they may catch up if capabilities requirements saturate. Frye covers inference on end-user devices, noting that running models locally avoids network latency but faces tight memory and power constraints—e.g., a 7B parameter model requires 14 GB, too large for phone RAM. He explains inference-as-a-service (e.g., OpenAI, Replicate) versus self-serving on cloud GPUs or serverless platforms like Modal, highlighting that memory bandwidth is the bottleneck: GPUs have 1.5 TB/s memory bandwidth vs 312 TFLOPS compute, so batching is crucial for throughput. Frye also discusses inference arithmetic, custom silicon like TPUs which offer ~30% better efficiency but not drastic gains, and containerization challenges for GPU workloads.

The Hidden Life of Embeddings: Linus Lee

Nov 7, 2023 · 18:15

Linus Lee, a Research Engineer at Notion, presents a tour of embedding visualization and manipulation at the AI Engineer Summit 2023. He demonstrates an encoder-decoder model fine-tuned from T5 that can reconstruct text from embeddings, allowing direct manipulation of features like length and sentiment by moving in latent space. Lee shows that mixing embeddings by splicing dimensions from two texts produces a semantic blend, and a linear adapter can decode text from OpenAI's text-embedding-ada-002 embedding space. Using CLIP, he interpolates between photographic and cartoon images and performs vector arithmetic to modify facial expressions. Lee releases these custom text embedding models on Hugging Face, enabling others to explore and interact with latent spaces. He argues that making model internals visible and manipulable fosters deeper understanding and more humane interfaces to generative AI.

Building Blocks for LLM Systems & Products: Eugene Yan

Nov 2, 2023 · 17:24

Eugene Yan presents practical patterns for building LLM systems and products, emphasizing evals as the foundation. He argues that automated evals—starting with as few as 40 domain-specific questions—enable faster iteration and safer deployment, while academic benchmarks like MMLU may not fit real tasks. For retrieval-augmented generation, he warns that LLMs perform worse when the answer is in the middle of retrieved documents, and even with perfect retrieval, accuracy tops out at 75%. Guardrails against hallucination can be built via natural language inference at the sentence level or by sampling multiple summaries to check consistency. Finally, he highlights UX design—like Copilot’s accept/reject or Midjourney’s upscale/vary—as a way to collect implicit feedback that builds a data flywheel for evals and fine-tuning.

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.