All episodes

Building agent fleet architectures your CISO doesn't hate — Lou Bichard, Gitpod

Jun 27, 2025 · 13:52

Lou Bichard explains how Gitpod evolved from a managed SaaS to a 'bring your own cloud' architecture that satisfies CISOs in regulated industries by running secure dev environments—and now agent fleets—on customer infrastructure via a simple runner (a single ECS task) instead of complex Kubernetes. The platform, used by banks and healthcare firms for 37 hours per week per developer, reduces operational overhead through a cloud-formation-based setup that takes three minutes. For agents, the same infrastructure provides source code access and audit logging, ensuring privacy and compliance. Bichard argues that vendors should simplify architectures to lower customers' day-two costs, and advises buyers to prioritize security and ownership models when selecting AI tools.

Don’t get one-shotted: Use AI to test, review, merge, and deploy code — Tomas Reimers, Graphite

Jun 27, 2025 · 5:45

Tomas Reimers, CPO and co-founder of Graphite, argues that AI-generated code accelerates the inner loop (development) but bottlenecks the outer loop (review, test, merge, deploy), necessitating AI-native tooling across the entire workflow. He presents Graphite's AI code reviewer, Diamond, which achieves a 52% acceptance rate on its comments—exceeding the 45–50% rate for human comments—while only 4% of its comments are dismissed. Reimers emphasizes that AI tools must deeply understand the codebase, integrate with CI/testing pipelines, and provide high-signal, low-noise feedback to handle the increasing volume of AI-assisted code. He cites that 46% of GitHub code is now written by Copilot, and predicts the outer loop will break without AI-driven prioritization, review automation, and optimized deployment. The talk advocates for self-driving code review that lets developers focus on product features rather than manual processes.

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.

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.

Vibe Coding at Scale: Customizing AI Assistants for Enterprise Environments - Harald Kirshner,

Jun 27, 2025 · 15:26

Harald Kirshner, a Principal Product Manager at Microsoft working on VS Code and GitHub Copilot, argues that 'vibe coding' must evolve from ad-hoc experimentation to structured, spec-driven approaches for enterprise environments. He breaks vibe coding into three stages: YOLO (rapid prototyping with auto-accept and voice dictation), structured (using templates, custom instructions, and tools like MCP for consistency), and spec-driven (iterating from a plan for scale and reliability). Kirshner demonstrates VS Code Insiders' agent mode, new workspace flow, and auto-approve features, emphasizing that developers should commit often, review agent pauses, and leverage workspace instructions to maintain quality. He advocates for standardizing AI usage through team-defined prompts and modes, preserving developer autonomy while ensuring maintainable code even in complex, polyglot codebases.

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.

AI Red Teaming Agent: Azure AI Foundry — Nagkumar Arkalgud & Keiji Kanazawa, Microsoft

Jun 27, 2025 · 19:31

Keiji Kanazawa and Nagkumar Arkalgud of Microsoft present the AI Red Teaming Agent in Azure AI Foundry, arguing that adversarial testing is essential for building trustworthy AI agents. Nagkumar demonstrates the tool: it runs scans against RAG apps or models directly, using attack strategies like Caesar encoding and Base64 to simulate adversarial prompts across four risk categories (violence, hate and fairness, etc.). In a demo with GPT-4.0 with full guardrails, no attacks succeeded; switching to Phi-3 without guardrails yielded 5 out of 40 successful attacks in hate and fairness. The tool integrates with Azure AI Foundry's content filters, which apply both input and output guardrails, allowing engineers to iteratively test and mitigate vulnerabilities. The talk emphasizes that red teaming should be part of a broader risk mapping and evaluation lifecycle, and that trust is a team sport requiring collaboration between engineers and security experts.

Collaborating with Agents in your Software Dev Workflow - Jon Peck & Christopher Harrison, Microsoft

Jun 27, 2025 · 1:04:06

GitHub's Christopher Harrison and Jon Peck explain how to collaborate with Copilot Coding Agent as a peer programmer, emphasizing that context—through clear code, comments, instructions files, and MCP servers—is key to success. They walk through a lab where Copilot works on assigned issues in ephemeral GitHub Actions environments without internet or write access to the main repo, creating draft PRs that require human review. Harrison advises against being passive-aggressive, advocating specific prompts and instructions files to guide the agent. The episode covers MCP's role in providing external tools, the need for code review and security checks even with AI, and pricing: $39.99/month for Enterprise tier with coding agent. They also highlight .instructions files for reusable patterns and note that coding agent currently supports only tools, not resources.

Agentic Excellence: Mastering AI Agent Evals w/ Azure AI Evaluation SDK — Cedric Vidal, Microsoft

Jun 27, 2025 · 20:01

Cedric Vidal, Principal AI Advocate at Microsoft, demonstrates how to systematically evaluate AI agents using the Azure AI Evaluation SDK and AI Toolkit. He argues that evaluation must start early, covering four layers: model/safety system, system message, grounding, and user experience. He shows spot-checking models side-by-side in VS Code, building a web-scraping agent with Playwright MCP, and running batch evaluations with built-in quality and safety metrics like groundedness and fluency. Vidal also covers multi-turn and multimodal evaluation, using a violent image example where the SDK returned a score of 4 out of 5, allowing teams to set custom thresholds based on application context.

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.

How fast are LLM inference engines anyway? — Charles Frye, Modal

Jun 27, 2025 · 16:07

Charles Frye presents benchmarks from hundreds of runs on Modal comparing open-source inference engines VLM, SGLang, and TensorRTLM across models like Qwen 3 and Gemma 27B, arguing open weights models have caught up to proprietary ones, making self-hosting viable. He shows, for example, that Qwen 3 (MoE) on VLM achieves ~1 request/sec with 128 input tokens and 1024 output tokens, while switching to a RAG-like workload (1024 in, 128 out) yields a 4x throughput improvement. Frye warns that optimizing for context over reasoning can improve latency without sacrificing quality, and notes that the engines' out-of-the-box performance varies by model—e.g., SGLang underperforms VLM on Gemma due to less optimization. He also highlights the gap between prefill (parallel) and decode (autoregressive) speeds, which a rationalist would expect from transformer architecture. The benchmarks, available at modal.com/llmalmanac, aim to help engineers choose hardware and engines, with contributions welcome for optimized configs like TensorRTLM's knobs.

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.

The State of AI Powered Search and Retrieval — Frank Liu, MongoDB (prev Voyage AI)

Jun 27, 2025 · 12:35

Frank Liu from Voyage AI (now part of MongoDB) presents the state of AI-powered search and retrieval, arguing that embedding quality is core but not sufficient—systems must integrate structured data filtering and agentic query decomposition for real-world RAG applications. He details three live use cases: chatting with codebases (where Continue.dev found Voyage Code 3 best, emphasizing domain-specific evaluation), legal document search requiring pre-filtering by metadata, and agentic retrieval where LLMs decompose queries into multiple sub-queries. Looking ahead, Liu predicts three trends: multimodal embeddings that combine text and images (e.g., Voyage Multimodal 3 embedding Claude 3.5 blog posts), instruction tuning to steer embeddings toward specific document aspects, and the rise of agent-native databases (like MongoDB integrating Voyage for embedding, reranking, and query augmentation within a single platform).

Architecting Agent Memory: Principles, Patterns, and Best Practices — Richmond Alake, MongoDB

Jun 27, 2025 · 17:37

Richmond Alake from MongoDB presents memory management as the key pillar for building believable, capable, and reliable AI agents, arguing that agentic systems require structured memory types—persona, toolbox, conversational, workflow, episodic, and entity—to achieve statefulness and reduce reliance on prompt engineering. He introduces MemoRiz, an open-source library implementing these memory design patterns, and positions MongoDB as a flexible memory provider with its document model and hybrid retrieval capabilities (vector, text, graph). Alake details practical patterns: storing tool schemas for scalable tool use, persisting conversation history with timestamps and recall signals, leveraging workflow memory to learn from failures, and using MongoDB's upcoming integration of Voyage AI embedding models to simplify chunking and retrieval. He connects these advances to neuroscience, citing how feline visual cortex research inspired CNNs and noting recent collaborations with neuroscientists to further agent memory research.

Building Multimodal AI Agents From Scratch — Apoorva Joshi, MongoDB

Jun 27, 2025 · 36:58

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

Why Your Agent’s Brain Needs a Playbook: Practical Wins from Using Ontologies - Jesús Barrasa, Neo4j

Jun 27, 2025 · 13:54

Jesús Barrasa, AI Field CTO at Neo4j, argues that ontologies are the secret weapon for building robust GraphRAG applications, providing both a formal, implementation-agnostic schema for knowledge graph creation and a dynamic data layer that drives retriever behavior. He explains how ontologies replace rigid code-orchestrated workflows and chaotic LLM-generated ones by guiding entity extraction from unstructured data and mapping structured sources into a property graph. During retrieval, storing the ontology in the graph enables dynamic Cypher queries that automatically navigate contextualizing relationships — such as "acted-in" rather than "directed" — based on annotated subproperties, without hard-coded logic. This allows developers to change retrieval behavior on the fly by modifying the ontology as a data artifact. The talk covers two practical wins: using ontologies as a shared domain model for graph construction, and leveraging them to build adaptive, schema-driven retrievers that improve result completeness and relevance.

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.

Graph Intelligence: Enhance Reasoning and Retrieval Using Graph Analytics - Alison & Andreas, Neo4j

Jun 27, 2025 · 1:41:16

Alison Cossette and Andreas Kollegger from Neo4j demonstrate how graph data science algorithms enhance GraphRAG systems by connecting, clustering, and curating unstructured data. They walk through running KNN similarity (K=25) on document embeddings, then applying Louvain community detection to identify clusters of near-identical chunks—one community had 49 documents with 0.98 average similarity—which can be collapsed via APOC to improve retrieval efficiency while preserving lineage. Using page rank and betweenness centrality, they show how to surface influential documents and track conversation paths across communities. The session uses a preloaded Neo4j AuraDB database with 17K nodes and 774K relationships from the Agent Neo project, and includes practical cipher queries for projecting graphs and running algorithms. They emphasize using graph analytics to diversify retrieval, manage content hygiene, and build accountable agent systems.

GraphRAG methods to create optimized LLM context windows for Retrieval — Jonathan Larson, Microsoft

Jun 27, 2025 · 15:09

Jonathan Larson of Microsoft Research presents GraphRAG methods, arguing that LLM memory with structure is a key enabler for effective AI applications, and that agents paired with these structures amplify their power. He demonstrates GraphRAG for Code, which uses graph-based understanding to outperform regular RAG on code comprehension, translation from Python to Rust, and even multi-file feature addition like adding jumping to the original DOOM codebase. Larson announces Benchmark QED, an open-source evaluation framework for measuring local and global query quality across comprehensiveness, diversity, empowerment, and relevance. He introduces Lazy GraphRAG, which beats vector RAG on 92% of local and 90% of global queries at one-tenth the cost of million-token context windows, and is being integrated into Azure Local and Microsoft Discovery.

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.

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.

"Data readiness" is a Myth: Reliable AI with an Agentic Semantic Layer — Anushrut Gupta, PromptQL

Jun 27, 2025 · 17:02

Anushrut Gupta of PromptQL argues that 'data readiness' is a myth — perfect, clean data is unattainable — and instead advocates for an agentic semantic layer that learns from user corrections. He contrasts traditional approaches like manual semantic layers and knowledge graphs, which break as business definitions change, with PromptQL's design: a deterministic domain-specific language (PromptQL) that lets an LLM generate a plan executed by a runtime, avoiding hallucination. The system behaves like a new hire analyst: day zero it can handle messy tables (e.g., 'Morc, Plug, Zorp'), and through human guidance it self-improves — learning 47 business terms, mapping six systems, and discovering 12 calculation variants within 30 days. Gupta demonstrates a multi-step query across databases, Zendesk, and Stripe, with explainable steps and editable 'brain'; the AI achieves 100% accuracy on complex tasks for customers like a Fortune 500 food chain and a fintech company.

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.

Events are the Wrong Abstraction for Your AI Agents - Mason Egger, Temporal.io

Jun 27, 2025 · 14:40

Mason Egger, a Senior Developer Advocate at Temporal, argues that event-driven architecture (EDA) is the wrong abstraction for AI agents and proposes durable execution as the correct one. He compares EDA to a geocentric model—complex and error-prone—and durable execution to a heliocentric model that simplifies development by automatically preserving state, retrying failures, and decoupling logic from infrastructure. Egger critiques EDA for lacking clear APIs, scattering business logic, creating ad hoc state machines, and causing race conditions, noting that EDA is only loosely coupled at runtime, not design time. He presents Durable Execution, implemented by Temporal's open-source platform, as a crash-proof approach that virtualizes execution across machines and languages (Go, Python, TypeScript, etc.), letting developers focus on core logic instead of queues and events. The talk concludes that all AI agents are distributed systems, and durable execution abstracts away event complexities, making failures inconsequential.

Prompt Engineering is Dead — Nir Gazit, Traceloop

Jun 27, 2025 · 14:19

Nir Gazit, CEO of Traceloop, argues that manual prompt engineering is ineffective and demonstrates an automated, test-driven alternative. He improves a RAG-based documentation chatbot by 5x without hand-tuning prompts, using an LLM-as-a-judge evaluator with 20 example questions (each with 3 expected facts) and a CrewAI agent that iteratively optimizes the prompt based on evaluation scores. The initial score of 0.4 jumps to 0.9 after just two iterations. Gazit warns of overfitting to the small dataset and suggests splitting into train/test sets. The approach replaces manual tweaking with a 'gradient ascent' on evaluators, effectively vibe-engineering prompts.

The Eyes Are The (Context) Window to The Soul: How Windsurf Gets to Know You — Sam Fertig, Windsurf

Jun 27, 2025 · 13:37

Sam Fertig, Deployed Engineer at Windsurf, explains how the AI coding IDE achieves its uncanny ability to predict developer intent by focusing on relevant context rather than merely expanding context windows. He breaks context into two pillars: heuristics (user behavior like cursor position, open files, clipboard) and hard evidence (codebase, rules, memories). The core challenge is generating code that fits existing codebases, adheres to personal and organizational standards, and remains future-proof. Windsurf optimizes retrieval quality over quantity, using techniques like embedding search, reranking, and AST parsing to balance latency and scale. Fertig also addresses privacy, stating that while code is sent to servers, data is not stored or used for training.

Mastering Engineering Flow with Windsurf - Eashan Sinha, Windsurf

Jun 27, 2025 · 15:20

Eashan Sinha, a Deployed Engineer at Windsurf, explains how engineering teams can master agentic IDEs using Windsurf's Cascade agent. He argues that developers should treat AI as a teammate rather than a tool to abuse, emphasizing Windsurf's flow awareness—tracking user actions, edits, and terminal commands to infer intent. Sinha details Windsurf's evolution from copilots to agents, combining collaborative chat with autonomous tool calling, and introduces features like state-of-the-art context engine, workflows for deterministic steps, rules, memories, and simultaneous Cascades. He provides a practical four-step framework—explore, plan, build, test—for maximizing agentic flow, including using planning files, checkboxes, and automated test generation. The episode delivers a concrete guide to integrating AI into development without sacrificing quality, recorded at the AI Engineer World's Fair in San Francisco.

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

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

Jun 27, 2025 · 14:50

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

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

Jun 25, 2025 · 18:47

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

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

Jun 24, 2025 · 17:57

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

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

Jun 23, 2025 · 16:03

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

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

Veo 3 for Developers — Paige Bailey, Google DeepMind

Jun 21, 2025 · 20:37

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

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.

The Geopolitics of AI Infrastructure - Dylan Patel, SemiAnalysis

Jun 19, 2025 · 18:29

Dylan Patel of SemiAnalysis argues that despite US sanctions, Huawei has engineered a 384-chip cluster (Cloud Matrix 384) that Nvidia failed to deploy, while accessing TSMC via Softgo and HBM from Samsung via shell companies — all legally. China's SMIC will soon produce 7nm AI chips in high volumes, debunking the notion that China lacks compute. Meanwhile, Middle East players like G42 (UAE) and Datavolt (Saudi Arabia) are building multi-gigawatt data centers, with G42's deal letting it keep 20% of 500,000 GPUs yearly for itself while 80% goes to US companies like OpenAI. Patel highlights the US's 63-gigawatt power shortfall vs. 100 GW of planned data centers, explaining why US companies rely on Middle East capacity and why China's superior power buildout gives it a geopolitical edge.

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.

How to Build Trustworthy AI — Allie Howe

Jun 16, 2025 · 24:22

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

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.

Supercharging developer workflow with Amazon Q Developer - Vikash Agrawal

Jun 10, 2025 · 13:22

Vikash Agrawal and Linda show how Amazon Q Developer can drive every stage of the software development lifecycle. They build a 2048 game with FastAPI and Poetry using Q's /dev command in the CLI, then add unit tests with /test, generate documentation with /doc, and integrate with GitHub for automated pull requests. After deploying to AWS, they use Q in CloudWatch to debug a runtime import error by analyzing logs and resource topology. The episode emphasizes that planning infrastructure and prompts upfront, along with security scans, are critical for production-ready AI-assisted development.

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.

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.

Beyond Conversation: Why Documents Transform Natural Language into Code - Filip Kozera

Jun 10, 2025 · 10:57

Filip Kozera argues that chat-based interfaces like ChatGPT create ephemeral, polluted context windows and lack forced clarity, making them poor for specifying complex systems, while documents naturally force rigor and structured thinking. He advocates shifting from conversational brainstorming to document-driven workflows, where humans precisely articulate intent for AI agents. Kozera introduces background agents that run asynchronously, triggered by events like emails or meetings, and surface only when needing human approval, turning the human role into one of 'swiping left or right' to approve or edit outputs. He envisions a future where humans manage swarms of such agents, first adopted by prosumers and later by enterprises, with taste and intent becoming critical for imbuing personal brand into agent outputs. The episode presents a clear progression from chat-based brainstorming to structured document-driven agent systems.

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.