Model Context Protocol (MCP)

Your Agents Need a Save Button - Hamza Tahir, ZenML

Jul 18, 2026 · 17:07

Hamza Tahir, co-founder of ZenML and Kitaru, argues that AI agents need a durable 'save button' — checkpointing runtime state — to move beyond read-only traces and enable replay, debugging, and optimization at scale. He demonstrates Kitaru, an open-source runtime that snapshots code, artifacts, and environment between tool calls, letting developers replay an agent from any checkpoint with a swapped model or mocked tool. Tahir shows how this allows side-by-side diffs across single runs or entire cohorts sorted by cost, then uses an MCP server to let an LLM analyze the results and flag false economies. He cites DoorDash's blog post, which used simulated replays to cut hallucination by 90% and reduce simulation time from hours to minutes. The conclusion: a single replay is an anecdote; real insights come from cohort analysis across production checkpoints.

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

Jul 17, 2026 · 17:35

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

Claws Out: Securing and Building with OpenClaw - Nick Taylor, Pomerium

Jul 11, 2026 · 17:12

Nick Taylor, a dev advocate at Pomerium, explains how he contributed trusted-proxy auth mode to OpenClaw, allowing a trusted identity-aware proxy to handle WebSocket authentication and removing the need for tokens and device pairing. He demonstrates building tools like Clawspace, a browser-based file explorer and editor for his OpenClaw workspace, and an MCP server for ChatGPT, all secured with Pomerium's open-core Identity-Aware Proxy. In a live demo, he creates an MCP server by editing files in his OpenClaw workspace via Discord, with changes reflected instantly through Vite hot reload. Taylor argues that hardening OpenClaw access with a trusted proxy improves both security and user experience, showcasing his workflow of building software entirely from his phone.

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.

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.

Structuring the Unstructured - Cedric Clyburn, Red Hat

Jun 28, 2026 · 20:41

Cedric Clyburn (Red Hat) demonstrates how Docling, an open-source tool from the Linux Foundation, converts unstructured documents like PDFs, tables, and images into structured formats (Markdown/JSON) for AI workflows. He shows that naive PDF parsers lose table structure and image content, while proprietary VLMs are expensive and non-deterministic. Docling uses OCR and layout analysis to preserve context, achieving 50x cost savings compared to VLMs on CPU. The demo covers extracting tables and images from an 8-page PDF, using a local Granite vision model for image annotation, and implementing chunkless RAG where an LLM queries a Docling document outline directly. Scaling is addressed via Docling Serve (REST API) and Docling MCP server for agentic document processing with tools like Claude Code.

Your Agent's Biggest Lie: "I Searched the Web" — Rafael Levi, Bright Data

Jun 17, 2026 · 15:49

Rafael Levi from Bright Data argues that LLMs often hallucinate and provide fake citations because they fail to actually access live web data, getting blocked by anti-bot systems like CAPTCHAs and Cloudflare's AI labyrinth. He demonstrates this with a comparison: without Bright Data's MCP, GPT-5 failed all five tasks accessing sites like LinkedIn and Amazon; with the MCP's 66 tools—including a CAPTCHA-solving browser that mimics human behavior—four succeeded. Levi explains that agents enter an invisible failure loop where they get blocked or served fake data but still answer confidently, making up numbers or non-existent URLs. He emphasizes that 20% of the web is blocked by Cloudflare from AI crawling, and that fake data fed to bots increases hallucinations. The episode covers how Bright Data's MCP provides real web access with search, scraping, and remote browsers, offering a free tier of 5,000 requests per month for experimentation.

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.

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

Jun 11, 2026 · 21:34

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

Your Attention Is the Bottleneck, Not Your Agents — Zack Proser, WorkOS

Jun 11, 2026 · 25:17

Zack Proser from WorkOS argues that human attention, not agent speed, is the real bottleneck in AI-assisted coding. He proposes a sustainable stack: signal layers to filter Slack and Linear, voice-first flows at 184 wpm, remote control of agents from a phone to leverage diffuse thinking, and weekly self-improvement passes over JSONL conversation history. He also integrates an Oura ring via MCP so Claude can nudge him about sleep, emphasizing balance over burnout.

Why Eval++ Is the Next Great Compute Primitive — Sunil Pai & Matt Carey, Cloudflare

Jun 8, 2026 · 24:51

Matt Carey and Sunil Pai from Cloudflare's agents team argue that Durable Objects — stateful serverless with 15ms London latency — and Dynamic Workers — a safe, sandboxed eval for LLM-generated code — form the next compute primitive for AI agents. They explain how Durable Objects enable resumable streaming, multi-tab sync, and background scheduling out of the box without distributed systems engineering. Dynamic Workers allow running generated JavaScript strings in isolated sandboxes, reclaiming 30 years of avoided eval. The pair tease upcoming talks: one on collapsing Cloudflare's 2,600 API endpoints into a 1,000-token MCP tool, and another on a coding agent harness built entirely on Workers that they are already shipping.

From MCP to Scale: Pipelines That Build Themselves — Rafael Levi, Bright Data

Jun 7, 2026 · 25:26

Rafael Levi from Bright Data shows how LLMs combined with Bright Data's MCP and infrastructure turn web scraping into self-healing pipelines. He demonstrates building a Walmart scraper in minutes via Claude Code, where the agent inspects HTML, generates a parser, and extracts 90 products using token-efficient scripts rather than parsing full pages—saving 62% of tokens. Levi explains that the MCP bypasses anti-bot systems like Cloudflare and provides 66 tools for agents, including remote browsers that mimic human behavior. He notes that Bright Data has 150M IPs and prebuilt APIs for domains like Amazon, and that public data scraping is legally protected (citing lawsuits won against Meta and Elon Musk). Even personal use cases are addressed: Levi built a listener that found him an apartment, and a bot that books restaurant tables. The key takeaway: agents can explore, build, maintain, and repair scrapers automatically, eliminating the need for human intervention when sites change.

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.

Building Agent Interfaces: Lessons from Chrome DevTools (MCP) for Agents — Michael Hablich, Google

Jun 5, 2026 · 22:38

Michael Hablich, product manager for Chrome DevTools at Google, presents four engineering lessons from building agent interfaces, centered on the Chrome DevTools MCP server. He introduces the metric 'tokens per successful outcome' to measure interface fuel efficiency, contrasting it with raw JSON trace files that blew through context windows. The team improved error messages, like adding 'Cannot navigate back, no previous page in history' to enable agent self-healing without human intervention. They decomposed a monolithic `debug_webpage` tool into 25 focused tools, but then faced a discoverability problem solved by auditing tool descriptions for intent. Hablich defends keeping autoconnect friction to prevent prompt injection, citing the 'lethal trifecta' of agents with tool access, data access, and internet access, and outlines three security tiers for browsing agents.

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.

Why your agents need decision traces, not just documents — Zach Blumenfeld, Neo4j

May 29, 2026 · 20:12

Zach Blumenfeld from Neo4j argues that context graphs—a graph-based layer storing decision traces, precedence, and causal chains—extend standard RAG to make AI agents more accurate and explainable. A financial analyst agent, for example, can reject or accept a request by retrieving past decision traces and structurally similar precedents via graph embeddings, not just semantic similarity. Neo4j's one-command tool `uvx create-context-graph` scaffolds a full-stack app with backend, frontend, demo data, and MCP server, supporting 22 built-in domains or custom ontology generation. The underlying `neo4j-agent-memory` package handles entity extraction through a spaCy-to-GLiNER-to-LLM pipeline with deduplication and integrates with pydantic AI, LangGraph, Crew, Google ADK, and others. The episode also covers data connectors for GitHub, Notion, Jira, and Slack, and the ability to store and query decision traces with timestamps, though automated trace quality evaluation is still evolving.

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.

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

May 16, 2026 · 19:45

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

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.

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

May 13, 2026 · 19:11

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

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

May 13, 2026 · 18:22

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

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.

Context Is the New Code — Patrick Debois, Tessl

May 3, 2026 · 27:14

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

Agents for Everything Else — swyx

May 1, 2026 · 14:10

swyx, co-founder of AI Engineer Conferences, details how his team of nine full‑time people uses coding agents like Devin and Town to run the conference, moving from a non‑AI stack to agents that handle everything from Figma‑to‑website conversion and schedule management to buying a lobster for the event. He claims these agents save “yak shaving” and increase human productivity because employees enjoy faster feedback cycles, leading to more work like animations and polish. The team now manages a 1,000‑person conference with plans to handle 6,000 in San Francisco without growing headcount. Swyx also advocates for “agents for everything else,” predicting that the primary user of software will shift from humans to bots, making APIs and MCPs more important than dashboards. He urges attendees to adopt agents and “prescribe” them to skeptical coworkers.

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.

MCP = Mega Context Problem - Matt Carey

Apr 25, 2026 · 22:42

Matt Carey from Cloudflare argues that the real bottleneck in connecting agents to APIs via MCP is the context window, not the protocol itself. Cloudflare’s OpenAPI spec is 2.3 million tokens; naive tool generation would consume 1.1 million, overwhelming any agent. To solve this, Carey advocates progressive discovery: CLIs (requiring shell access), tool search (loading only relevant tools), or codemode—letting agents write code against a typed SDK and execute it in Cloudflare’s isolated Workers sandbox. This sandbox provides safe, programmable guardrails (no secrets, limited network access), allowing agents to access all 2,600+ Cloudflare API endpoints from a single MCP server. Carey predicts that as agents become code generators, infrastructure primitives like WorkerD, Deno, and Pydantic will proliferate, and MCP servers will become a lightweight middleware flag (e.g., `MCP: true` in Next.js). The talk demonstrates read-only access to the entire Cloudflare API from an MCP client, showing codemode in action.

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.

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 Future of MCP — David Soria Parra, Anthropic

Apr 19, 2026 · 18:46

David Soria Parra from Anthropic argues that MCP (Model Context Protocol) is the key to connecting agents to tools and data in production, with 110 million monthly downloads—outpacing React's growth at the same stage. He lays out a 2026 connectivity stack combining Skills, MCP, and CLI/Computer Use, each suited for different needs, and emphasizes that best agents will use all three seamlessly. To improve client harnesses, he introduces Progressive Discovery—deferring tool loading via Tool Search to reduce context usage—and Programmatic Tool Calling, where models write scripts to compose tool outputs efficiently. Upcoming MCP protocol improvements include stateless transport (with Google) for easier scaling, async agent-to-agent tasks, enterprise features like Cross App Access and Server Discovery via well-known URLs, and a Skills-over-MCP extension for shipping usage instructions with servers. He calls for community feedback on these directions.

One Registry to Rule them All - Sonny Merla, Mauro Luchetti, & Mattia Redaelli, Quantyca

Apr 10, 2026 · 22:47

Amplifon's AI transformation led to the Amplify program, for which Quantyca built an enterprise-grade registry system for MCP servers and A2A agents. Sonny Merla, Mauro Luchetti, and Mattia Redaelli explain how three registries—MCP, A2A, and use case—are linked via a catalog to provide full lineage, including ownership, environment, authentication, cost attribution, and use case linkage. The solution uses an AI gateway for unified LLM access with Entra ID authentication and budgeting, and provides template repositories on GitHub with CI/CD pipelines that automatically publish agent cards and server metadata to the registries. This enables discovery, governance, and impact analysis across 26 countries and multiple teams, letting developers focus on business logic while avoiding reinventing security and deployment infrastructure.

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

Apr 10, 2026 · 52:55

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

Your Insecure MCP Server Won't Survive Production — Tun Shwe, Lenses

Apr 8, 2026 · 24:34

Tun Shwe and Jeremy Frenay from Lenses.io argue that poorly designed MCP servers are inherently insecure, and propose five core design principles—shrink attack surface, constrain inputs, treat docs as defense, return minimal data, minimize blast radius—that also thwart OWASP's MCP Top 10. They highlight that standard I/O fails under load (20 of 22 requests failing with 20 concurrent connections), forcing a shift to streamable HTTP with OAuth 2.1. Jeremy details Dynamic Client Registration (DCR) and the newer Client ID Metadata Document (CIMD) approach, noting DCR's vulnerabilities (phishing, non-portable registrations) and CIMD's stronger identity verification since November 2025. Beyond OAuth, enterprise deployment requires tool-level RBAC, data masking for PII, full audit logs, and end-to-end tracing to meet regulations like the EU AI Act.

Bending a Public MCP Server Without Breaking It — Nimrod Hauser, Baz

Apr 8, 2026 · 40:50

Nimrod Hauser, founding engineer at Baz, presents a hands-on guide to adapting third-party MCP servers for production, using Playwright's MCP server as an example. He demonstrates five best practices—curation, wrapping descriptions, deterministic guardrails, composing new tools, and treating tools as deterministic functions—to transform a brittle setup into resilient infrastructure. Hauser shows how curating tools from 21 to 16 reduces context load, while enhanced descriptions guide agents to use accessibility snapshots before clicking. Deterministic path validation prevents agents from saving screenshots outside a designated folder, and a new 'evidence tool' with tailored instructions improves spec review accuracy. The talk culminates with Baz's Spec Reviewer, an agentic code review tool that compares requirements against implementation, successfully passing a test after applying all optimizations.

Identity for AI Agents - Patrick Riley & Carlos Galan, Auth0

Jan 14, 2026 · 1:22:12

Patrick Riley and Carlos Galan from Auth0 (Okta) present new identity and access management features for AI agents, including Async Auth, Token Vault, and MCP integration. Token Vault securely stores and refreshes upstream resource tokens, enabling agents to access APIs on behalf of users. Async Auth allows agents to request user approval for risky operations, such as placing an order, via out-of-band notifications like push to the Guardian app. They demonstrate a Next.js chatbot that uses Token Vault to read a user's stock portfolio and Async Auth to require explicit consent before executing trades. The MCP server is secured with OAuth 2.0, supporting Dynamic Client Registration (DCR) and fine-grained scopes. The solution bridges user identity, agent identity, and upstream API authorization, ensuring agents can act autonomously but with user-defined boundaries.

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.

What We Learned Deploying AI within Bloomberg’s Engineering Organization – Lei Zhang, Bloomberg

Dec 16, 2025 · 18:21

Lei Zhang, Bloomberg's Head of Technology Infrastructure Engineering, shares lessons from deploying AI across 9,000+ software engineers, emphasizing that real ROI comes from maintenance and incident response rather than greenfield coding. He details how Uplift Agents automate refactoring patches and Incident Response Agents provide unbiased troubleshooting, both leveraging MCP servers. To avoid duplication, Bloomberg built a Paved Path with a model gateway, tool discovery hub, and standardized deployment. Adoption was boosted by integrating AI into onboarding training and across tech communities, while data showed leadership lagging behind individual contributors—prompting targeted leadership workshops. Zhang concludes that AI changes the cost function of engineering, enabling previously expensive tasks to become cheap, forcing a reexamination of what constitutes high-quality software engineering.

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.

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

Nov 24, 2025 · 14:19

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

Context Engineering: Connecting the Dots with Graphs — Stephen Chin, Neo4j

Nov 24, 2025 · 26:50

Stephen Chin, VP of Developer Relations at Neo4j, argues context engineering powered by knowledge graphs transforms AI from prompt engineering to information architecture, enabling agents with structured memory and retrieval. He demonstrates GraphRAG using Neo4j's knowledge graph builder with supply chain and VEX documents, showing how vector and graph algorithms retrieve specific Jackson library vulnerabilities with CVE details, severity, and remediation versions. Chin contrasts fast two-pass vector+graph retrieval with agentic multi-step traversal via the Neo4j MCP server and Claude Code, which yields deeper results like CVE number, attack type, and upgrade paths. He explains that graphs excel when relationships span two or more facts, using a presentation update example involving himself, colleague Sid, and the GIDS event. Practical applications include role-based access overlays and explainable AI via visualized conversation flows. Resources like free Graph Academy courses, Nodes AI 2026 conference, and graphrag.com support implementation.

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.

How to Secure Agents using OAuth — Jared Hanson (Keycard, Passport.js)

Jul 30, 2025 · 18:59

Jared Hanson, creator of Passport.js and co-founder of Keycard, argues that OAuth is essential for securing AI agents and MCP, replacing static API keys with dynamic access tokens. He explains OAuth's core concepts: clients, resource servers, and authorization servers, and how OpenID Connect adds identity. Hanson critiques early MCP authorization specs for conflating server roles, but notes fixes now model MCP servers as resource servers. He outlines future challenges: agent-to-agent communication via client credentials, dynamic client registration with push registration for public clients, URL-based PKI for agent identity, remote attestation for edge agents, transactional authorization using rich authorization requests, chain of custody via token exchange, async interactions via non-browser channels, and voice/video security. Hanson frames these as necessary for safe AI deployment and positions Keycard as building identity infrastructure for agents.

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

Jul 26, 2025 · 1:23:14

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

Piloting agents in GitHub Copilot - Christopher Harrison, Microsoft

Jul 26, 2025 · 59:07

Christopher Harrison (Microsoft) demonstrates GitHub Copilot's agent capabilities for AI Engineers, arguing context is key to effective pair programming. He explains Copilot's modes—completion, chat, edit, local agent, and coding agent—and how Model Context Protocol (MCP) enables access to external tools like databases. Harrison shows how Copilot-instructions.md files provide project-specific guidance, and how coding agent runs within ephemeral GitHub Actions environments with strict security (no external access, only write to its own branch). He emphasizes that AI doesn't change DevOps fundamentals: tests still run locally and via PR workflows, and code review remains essential. The lab covers assigning issues to Copilot, configuring MCP servers, and using .instructions files for reusable patterns, with a repeat session at 3:30 PM.

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.

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.

Real world MCPs in GitHub Copilot Agent Mode — Jon Peck, Microsoft

Jul 19, 2025 · 14:27

Jon Peck from Microsoft demonstrates how Model Context Protocol (MCP) servers enable GitHub Copilot Agent Mode to solve real-world engineering problems beyond vibe-coding. He shows a README-driven workflow where Agent Mode builds a full app from a specification, then adds MCPs for database access and GitHub operations. Specifically, he configures a PostgreSQL MCP to pull live schema and data into mock JSON for testing, and the GitHub MCP to commit changes and create pull requests automatically. He emphasizes the read-only safety of the Postgres MCP and recommends using Copilot instructions to enforce practices like change logs. The episode covers how MCPs extend Copilot's capabilities to interact with data sources, testing tools, and DevOps pipelines securely.

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.

MCP is all you need — Samuel Colvin, Pydantic

Jul 18, 2025 · 15:24

Samuel Colvin, creator of Pydantic, argues that MCP (Model Context Protocol) is all you need for agent-to-agent communication, simplifying what many are overcomplicating. He explains that MCP's tool calling primitive offers advantages over OpenAPI, such as dynamic tools, logging, and sampling—a mechanism for MCP servers to request LLM calls through the client, enabling nested agentic workflows. Colvin demonstrates a research agent using Pydantic AI that queries the BigQuery public PyPI dataset via an MCP server over stdio, showing how sampling allows the server to generate SQL itself while keeping the main agent's context lean. The demo logs progress to Logfire, an observability platform, and outputs human-readable results. He emphasizes that MCP’s standard I/O mode and extensibility make it ideal for autonomous agents beyond its original desktop coding use case.

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

Jul 18, 2025 · 14:53

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

[Workshop] AI Pipelines and Agents in Pure TypeScript with Mastra.ai — Nick Nisi, Zack Proser

Jul 12, 2025 · 1:51:14

This hands-on workshop introduces Mastra.ai, a TypeScript framework for building production AI agents and pipelines, and demonstrates how to build an AI meme generator using composable workflows, tools, and agents. Hosts Nick Nisi and Zack Proser walk through creating a multi-step workflow: extract user frustration, find a base meme via ImageFlip, generate captions, and publish the meme at a stable URL. They show how to chain steps with Zod schema validation for deterministic output, then wrap the workflow in an agent that accepts natural language requests. The workshop also covers MCP (Model Context Protocol) and a live demo of MCP.shop for ordering a shirt, emphasizing local iteration with Mastra's playground, built-in memory, and evaluation tools. Real-world patterns include building internal AI assistants for data cleaning, email drafting, and document summarization with minimal code.

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.

MCP Is Not Good Yet — David Cramer, Sentry

Jul 3, 2025 · 16:41

David Cramer, founder and engineer at Sentry, argues that the Model Context Protocol (MCP) is a pluggable architecture for agents, not a simple API overlay, and that it is not yet good but worth experimenting with. He stresses that exposing existing OpenAPI endpoints as MCP tools yields terrible results; instead, developers must design context specifically for agents, returning Markdown rather than raw JSON to improve model reasoning. Cramer details Sentry's MCP server, built in two days using Cloudflare Workers for OAuth 2.1, and notes that remote OAuth is essential for B2B SaaS, while standard I/O introduces security risks. He highlights the need for careful token and cost management—citing a single request that produced 20 API calls to Sentry—and advocates for building dedicated agents (like Sentry's root cause analysis tool) that wrap MCP, giving the provider control over prompts, models, and error handling. Despite ongoing issues like lack of streaming responses and unstable client support, Cramer concludes that MCP's core concepts (plug-ins, agents, tools) are just familiar software patterns with new names.

Agents, Access, and the Future of Machine Identity — Nick Nisi (WorkOS) + Lizzie Siegle (Cloudflare)

Jun 30, 2025 · 14:17

Lizzie Siegle (Cloudflare) and Nick Nisi (WorkOS) argue that AI agents need the same authentication and authorization patterns as humans, extending OAuth to machines. They demonstrate an MCP server built with Cloudflare Workers and WorkOS that allows Claude to order a shirt on behalf of a user, showing how agents can act with user credentials. They explain using Cloudflare durable objects for per-user persistent storage and how authorization can be added to MCP servers to control agent actions, including an example where a 'pretty please' tool bypasses a block. The talk emphasizes the need for fine-grained authorization and audit trails as agents scale to thousands of tasks.

Containing Agent Chaos — Solomon Hykes, Dagger

Jun 28, 2025 · 23:48

Solomon Hykes, creator of Docker and founder of Dagger, argues that containing agent chaos requires engineering reproducible execution workflows built on containerization applied to each step of an agent's workflow. He introduces 'container use'—agents developing inside fully isolated, customizable environments rather than just sandboxing outputs—and demonstrates a prototype using MCP to integrate with Claude Code and Goose. The system provides background work, rails, seamless human stepping in, and optionality by leveraging Dagger, Git-based state management, and ephemeral containers snapshotted per action. Hykes shows how agents can run parallel experiments, merge snapshots, and discard failed environments without pollution. The episode concludes with him open-sourcing the project as github.com/dagger/containeruse.

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

Jun 27, 2025 · 1:15:43

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

Foundry Local: Cutting-Edge AI experiences on device with ONNX Runtime/Olive — Emma Ning, Microsoft

Jun 27, 2025 · 22:52

Emma Ning, Principal PM at Microsoft, presents Foundry Local, a platform for building cross-platform on-device AI applications using ONNX Runtime and Olive. She argues local AI is essential for low-bandwidth, privacy-sensitive, cost-efficient, and real-time latency scenarios, noting that modern hardware and optimized models like Phi-4-mini and DeepSeek make it viable. Ning demonstrates Foundry Local's CLI, model benchmarking (Qwen 1.5B at 90 tok/s vs. Phi-4-mini with richer output), and a cross-platform document summarization app built with JavaScript SDK, running identically on Windows and macOS. She also previews a local agent with MCP servers (file system and OCR) that extracts receipt totals using Phi-4-mini. Customer testimonial from Sava (CEO of Pieces) highlights improved memory management and tokens-per-second, while another partner underscores ease of install and hybrid cloud-local solutions.

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

Unlocking AI Powered DevOps Within Your Organization — Jon Peck, GitHub

Jun 27, 2025 · 22:13

Jon Peck, a developer advocate at GitHub, explains how organizations can unlock AI-powered DevOps by integrating tools like GitHub Copilot into their workflows, achieving up to 1.5x feature throughput and 30% average improvement in successful builds. He emphasizes starting with brownfield (existing code) rather than greenfield, using agent mode for iterative planning and narrowed context, and codifying team best practices via copilot-instructions.md files. Peck also covers governance: safety, privacy, org-wide policies, and excluding sensitive files. Autonomous AI use cases include auto-generating PR descriptions, code review, and assigning issues to Copilot, always keeping a human in the loop with isolated branches. Finally, MCP servers allow agents to interact with GitHub and other systems, automating commits and PR creation.

The Agent Awakens: Collaborative Development with Copilot - Christopher Harrison, GitHub

Jun 27, 2025 · 1:04:06

GitHub Enterprise Advocates Christopher Harrison and John Peck demonstrate GitHub Copilot's Coding Agent at the AI Engineer World's Fair, arguing that context is the key to effective AI pair programming. They explain that coding agent works by assigning GitHub issues with detailed requirements, then running inside a secure, ephemeral GitHub Actions environment with no internet access and limited write permissions. Harrison emphasizes using `copilot-instructions.md` and `.instructions` files to guide code generation, and MCP servers to access external data or APIs. He stresses that AI does not change the DevOps flow—code still requires manual review, linters, security scans, and unit tests. The session covers agent mode, edit mode, and multi-file edits, along with practical Q&A on enterprise adoption, model transparency, and managing multiple coding agents.

Building Code First AI Agents with Azure AI Agent Service — Cedric Vidal, Microsoft

Jun 27, 2025 · 1:54:06

Cedric Vidal, Principal AI Advocate at Microsoft, demonstrates building code-first AI agents with Azure AI Agent Service, using function calling, code interpreter, file search, and Bing grounding for a sales analysis use case. He creates a conversational agent that queries SQLite, generates pie charts from Python code, and blends product PDF data with relational data. The workshop explains stateful agents, tool routing (LLM generates JSON to call functions), and the limits of single-step agents versus multi-agent orchestration with AutoGen. Cedric addresses when to use Agent Service (managed persistence and tools) versus raw LLM endpoints, and covers MCP servers as a tool lifecycle manager. Key insights include using instructions to ground agent behavior and the need for eval frameworks for agent quality.

Memory Masterclass: Make Your AI Agents Remember What They Do! — Mark Bain, AIUS

Jun 27, 2025 · 51:25

Mark Bain, Vasilia Markovits, Alex Gilmore, and Daniel Chalev demonstrate that AI memory requires causal relationships and graph databases, not just vector similarity, to solve hallucinations and enable agentic workflows. Bain argues that memory is any data affecting change, and that attention, diffusion, and VAEs follow the same geometric principles as gravity and entropy. Alex shows Neo4j's MCP server storing semantic memory as entities and relationships retrieved across conversations. Vasilia demos Cognee building semantic graphs from GitHub data for agentic hiring decisions. Daniel presents Graphiti's domain-aware memory using custom Pydantic schemas to filter irrelevant facts. Bain introduces a GraphRAG chat arena that switches between memory solutions on a single Neo4j graph, testing different implementations for episodic and temporal recall.

Agentic GraphRAG: Simplifying Retrieval Across Structured & Unstructured Data — Zach Blumenfeld

Jun 27, 2025 · 15:25

Zach Blumenfeld (Neo4j) demonstrates how a knowledge graph simplifies agentic retrieval across structured and unstructured data, using an employee skill graph as an example. He shows that a plain document search fails to answer questions like "how many Python developers" (returns 5 instead of 28) or "who is most similar to Lucas Martinez" — but after extracting entities into a Neo4j graph, the agent can run precise Cypher queries via an MCP server, correctly reporting 28 Python devs and identifying Sarah as the closest match via skill overlap. He also shows how to flexibly add new relationships (e.g., project collaborators from an HR system) without schema changes, enabling questions like "which individuals collaborated most on AI projects" to return exact pairings like Sarah and Amanda. The talk emphasizes accuracy, explainability, and the ability to start with a simple data model and expand as agents ingest more data.

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.

(possible dupe but better sound) What does Enterprise Ready MCP mean? — Tobin South, WorkOS

Jun 27, 2025 · 13:53

Tobin South from WorkOS explains what it takes to make Model Context Protocol (MCP) enterprise-ready, covering the full journey from a hacky local server to a production system with authentication, authorization, SSO, audit logs, and data loss prevention. He demonstrates buying a shirt via MCP live, highlighting the need for bot blocking, input validation, and adapting auth stacks for dynamic client registration. South also discusses open challenges like headless auth for remote asynchronous workloads and communicating scope between AI agents, emphasizing that authorization is the hardest part of scaling MCP to the enterprise.

Case Study + Deep Dive: Telemedicine Support Agents with LangGraph/MCP - Dan Mason

Jun 22, 2025 · 1:56:13

Dan Mason of Stride presents a case study on building autonomous agents for telemedicine support, replacing a human-driven button-pushing workflow with LangGraph, Claude, MCP, and a Node.js/React/MongoDB stack, achieving roughly 10X capacity increase. The LLM-driven virtual operations associate ("Ava") assesses patient messages, updates state with anchors and scheduled messages, and passes proposals to an evaluator agent that scores confidence and complexity, escalating to humans below 75% confidence. Mason explains how treatment "blueprints" in Google Docs are read directly by the LLM instead of using RAG, enabling new treatments to be added without writing code. He details the eval system using LLM-as-a-judge via PromptFu and retry logic for tool-calling errors, and discusses trade-offs around confidence scoring, prompt caching, and model selection (Claude for steerability). The team includes two software engineers, one designer, and Mason, who wrote most LangGraph code with AI assistance (Kline).

Building Agents with Amazon Nova Act and MCP - Du'An Lightfoot, Amazon (Full Workshop)

Jun 21, 2025 · 1:26:20

Du'An Lightfoot and Benjiro Byami present a workshop on building AI agents with Amazon Nova Act, Model Context Protocol (MCP), and Strands Agents, demonstrating autonomous web navigation and multi-step task execution. Lightfoot explains agentic AI as plan, action, and reasoning, with components like LLM, knowledge base, guardrails, and tools. Nova Act, a research preview, enables browser automation: one demo searches Amazon for a coffee maker and retrieves the product title using natural language commands instead of explicit HTML tags. Byami builds an MCP server for Nova Act, allowing clients like Claude Desktop to control the browser via spoken instructions, then integrates it with Strands Agents, an open-source framework that combines a prompt, LLM, and tools in minimal code. The workshop shows parallel execution (e.g., comparing three monitors) and multi-agent collaboration for tasks like generating a PowerPoint presentation for cloud migration. Limitations include inability to bypass CAPTCHAs and occasional loops in complex websites.

The Web Browser Is All You Need - Paul Klein IV, Browserbase

Jun 20, 2025 · 17:31

Paul Klein IV, founder of Browserbase, argues that the web browser is the default MCP server for the rest of the internet, serving as the essential bridge between AI agents and legacy websites that lack APIs. He distinguishes between web agents (one prompt to many actions, e.g., OpenAI's Operator) and browser tools (one action per prompt), noting that both rely on vision-driven or text-based approaches to parse pages. Klein explains that Browserbase offers a horizontal MCP server for browsing, enabling automation of any website, and stresses the need for custom evals and observability to track agent behavior. In a live demo, he shows an agent navigating sfpca.org to find a dog for adoption, handling unexpected modals. He also addresses captchas, advising good citizenship and hinting at future agent authentication solutions.

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.

The State of MCP observability: Observable.tools — Alex Volkov and Benjamin Eckel, W&B and Dylibso

Jun 20, 2025 · 16:56

Alex Volkov (Weights & Biases) and Benjamin Eckel (Dylibso) argue that MCP-based AI agents create observability blind spots, and that OpenTelemetry-based distributed tracing, combined with community initiatives like observable.tools, can provide end-to-end visibility. They show how Weave's MCP support and mcp.run's upcoming OTel export enable tracing across client and server, using context propagation via MCP's metadata to stitch traces together. Volkov shares a meta story where Claude Opus 4 used MCP to automatically fix its own observability code, discovering and querying a support bot without human intervention. The episode calls for tool builders to adopt OTel and join semantic conventions efforts for agent observability.

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.

Just do it. (let your tools think for themselves) - Robert Chandler

Jun 10, 2025 · 6:50

Robert Chandler, co-founder and CTO of WordWare, argues that current low-level MCP tools wrapping APIs directly cause agents to be slow, expensive, and unreliable, citing an example where a Slack MCP took five minutes and failed to send a message. He advocates for agentic MCPs that blur the line between tool and agent, giving tools more agency and simple natural language APIs. Chandler demonstrates WordWare's new MCP toolbox, which turns workflows like a competitor analysis (scraping Twitter, writing to Notion) into a single, reusable tool for agents like Claude. This approach yields highly reliable, repeatable, and aligned results, offloading complex tasks from the main agent and allowing it to focus on reasoning. The episode promotes building tools that think for themselves, following the pattern of specialist teams like the Avengers.

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

Jun 10, 2025 · 28:32

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

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.

Blender MCP and The Future Of Creative Tools - Siddharth Ahuja

Jun 3, 2025 · 16:50

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

The Knowledge Graph Mullet: Trimming GraphRAG Complexity - William Lyon

Jun 3, 2025 · 32:52

William Lyon presents the 'Knowledge Graph Mullet' concept, combining property graph interfaces with RDF triple storage in Dgraph to optimize GraphRAG systems and AI agent development. Dgraph uses a property graph model for data modeling and DQL (inspired by GraphQL) for queries, while leveraging RDF triples for scalable storage and data interchange. Features include vector similarity search (e.g., finding articles about 'money laundering'), geospatial indexes, and a Model Context Protocol (MCP) server that exposes tools to models like Claude Desktop for auto-generating schema and querying. Lyon demonstrates building a news knowledge graph from the New York Times, chunking articles into nodes, and using graph traversal to surface related topics after vector search. He also showcases Hypermode agents, created from a prompt with access to GitHub and Notion via MCP servers, which can analyze repos like hyper-news and generate social media posts with code snippets, then save them to a Notion workspace. Hypermode agents are now in early access.

Arrakis: How To Build An AI Sandbox From Scratch - Abhishek Bhardwaj, OpenAI

Jun 3, 2025 · 40:18

Abhishek Bhardwaj, founder of Arrakis, explains why MicroVM-based AI sandboxes are the next unlock for AI agents, detailing how Arrakis provides secure, fast code execution and computer-use environments. He argues that sandboxes are essential for tool-calling models, reinforcement learning, and multi-tenant security, with Arrakis booting in under 7 seconds and supporting backtracking via snapshot/restore. The talk covers the choice of Cloud Hypervisor over other VMMs, overlayFS storage with per-sandbox read-write layers, iptables-based networking, and a built-in code execution server. A demo shows Claude using Arrakis via MCP to build a collaborative Google Docs clone and then revert to a snapshot, illustrating how a full Linux sandbox enables agents to autonomously debug and iterate without extensive prompting.

MCP Agent Fine tuning Workshop - Ronan McGovern

Jun 3, 2025 · 35:30

Ronan McGovern demonstrates how to fine-tune a Qwen3 model on high-quality reasoning traces from an MCP agent with browser tools. Using Playwright's 25 tools via Model Context Protocol, he generates multi-turn traces by running a 30B Qwen agent on RunPod, saving both tool calls and reasoning content. Those traces are then used to supervised fine-tune a 4B Qwen model with Unsloth, applying LoRA adapters to attention and MLP layers. The process includes converting MCP tool schemas to OpenAI format, extracting Hermes-style tool calls, and unrolling conversations to multiply training examples. Even with only nine curated traces, the fine-tuned model shows improved tool-calling behavior on multi-step tasks like navigating trellis.com to extract specific content.

Will Agent evaluation via MCP Stabilize Agent Networks? - Ari Heljakka

Jun 3, 2025 · 14:11

Ari Heljakka, CEO of Root Signals, argues that agent evaluation via the Model Context Protocol (MCP) can stabilize agent networks by enabling self-improvement loops. Using a hotel reservation agent example, he shows that without MCP the agent wrongly recommended a competitor hotel, but with MCP it invoked policy evaluators and corrected its behavior automatically. He also demonstrates marketing message optimization via Cursor, where the agent scored and improved text using an MCP-connected evaluation charge. Heljakka emphasizes that success requires a powerful evaluation library with systematic lifecycle maintenance, and introduces Root Signals' free MCP server. The approach promises more controllable, transparent, and dynamically self-correcting agents across different frameworks.

Rust is the language of the AGI - Michael Yuan

Jun 3, 2025 · 29:14

Michael Yuan argues that Rust, with its strong type system and compiler feedback, is the ideal language for AI code generation, unlike human-friendly Python or JavaScript. He presents Rust Coder, an open-source project supported by two Linux Foundation Mentorship grants, which uses MCP tools to generate, compile, and fix Rust projects. The system integrates a coding LLM (e.g., Qwen Coder) with a self-improving knowledge base of compiler errors, enabling it to generate correct code and automatically fix bugs. Yuan demonstrates its use in a Rust camp of 1000+ students and envisions future AI agents generating and deploying Rust code autonomously for tasks like drone control. He invites contributions to expand the knowledge base and enhance the tools for AGI.

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.

The Future of Qwen: A Generalist Agent Model — Junyang Lin, Alibaba Qwen

Jun 3, 2025 · 25:14

Junyang Lin from Alibaba Qwen presents the latest developments in the Qwen model series, including Qwen3's hybrid thinking mode that combines thinking and non-thinking behaviors in a single model, supporting over 119 languages and dialects. The flagship 235B MOE model activates only 22B parameters and competes with top-tier models like O3-mini, while a 4B model deployable on mobile devices rivals Qwen 2.5 72B. Qwen3 introduces dynamic thinking budgets for inference-time scaling, achieving over 80% on AIME 2024 with 32K thinking tokens, and enhances agent capabilities with MCP support. The vision-language model Qwen2.5-VL excels in benchmarks like MMU and MathVista, and the omni model Qwen2.5-Omni accepts text, vision, and audio inputs while generating text and audio, achieving competitive vision-language performance. Future directions include scaling reinforcement learning with environment feedback, extending context to at least 1M tokens, and unifying understanding and generation across modalities, marking a shift from training models to training agents.

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.

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.

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.