Agent Skill Design

Building an Agentic Video Editor for Mass Consumer — Ekaterina Deyneka, Reelful

Aug 18, 2026 · 12:45

Ekaterina Deyneka, founder and CEO of Reelful, presents her agentic video editor as structurally identical to an agentic app builder, with editing real footage harder than generation. At Reelful, users drop in media plus a prompt, and the agent understands the media, proposes a creative plan for approval, then spins up a remote sandbox where agent skills encode cut rules, font pairings, and b-roll generation. Video is composed as React code via Remotion, a verification layer catches composition errors and sends the agent back to reiterate, and the result renders to a polished clip. To hide this complexity from consumers, Reelful is mobile-first with directional templates and a building editor for tweaks. Deyneka demonstrated clips made purely by the agent and announced Reelful's funding from a16z Speedrun.

LLM Knowledge Bases: a practical guide — Ben Holmes, Warp

Aug 12, 2026 · 21:17

Ben Holmes, Developer Relations Lead at Warp, demonstrates how to turn a disorganized folder of voice-dictated notes into a browsable, interconnected knowledge base using LLM agents. He argues that voice dictation at 200 words per minute is the fastest capture method, recommending local tools like Handy and Voice Ink to avoid subscriptions. Holmes explains his 'enrich note' skill, which timestamps files, assigns tags from a fixed list to prevent Claude from inventing new ones, researches sources via web search, and adds backlinks through key term search. He then shows how to generate wikis from a Karpathy gist, grouping people, concepts, and organizations, and automates the entire pipeline on a daily schedule using Obsidian's headless CLI in a cloud sandbox via Oz.dev. Finally, he demonstrates asking an agent to build an HTML and Tailwind graph view of all notes, revealing clusters of interests and gaps in thinking.

Scaling up Continual Learning — Ronak Malde, Trajectory

Aug 12, 2026 · 23:03

Ronak Malde, founder of Trajectory and former Windsurf research lead, explains how on-policy self-distillation (OPSD) scales continual learning beyond GRPO's limits. He argues GRPO requires parallel rollouts and collapses feedback into one sequence-level score, like being handed 87 out of 100 on an essay. OPSD instead matches per-token log probs between a student and a teacher given privileged hints, optimizing the entire vocabulary and reducing tokens to solve tasks. Scaling to 120B models with 100+ tool calls reveals the 'but wait' problem—models hedge into 'maybe'—solved via step-level KL weighting, and hint leakage, countered with residual guidance. Trajectory applies this to production agent traces for Harvey, Decagon, and Rogo.

Agents, codebases, and teams — Aditya Khandelwal, Amazon AGI Lab

Aug 11, 2026 · 16:57

Aditya Khandelwal, from Amazon AGI Lab, argues that making agents work on a team is a leadership problem, not an IC one, because the fixes that work—restructuring a codebase for progressive disclosure and converging on a shared setup—require team buy-in. He describes symptoms of a bad setup: engineers babysitting runs, burning 500k context on simple tasks, and blaming the model when the harness changed. His team's solution centered on one high-value skill called 'ship it' that carries a change from code done to PR ready, handling descriptions, review comments, and CI failures, often running over an hour. They wired issues and boards into the repo, added agentic reviews, and a nightly code gardener, but agents filing against each other blew the repo to roughly 4,500 open issues in a couple of weeks. In Q&A, he sets a hard limit near 100 lines in a skill file and says first-prompt context burn is the test of whether progressive disclosure works.

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

Aug 8, 2026 · 20:08

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

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

Jul 29, 2026 · 17:24

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

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

Jul 24, 2026 · 20:36

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

Full Workshop: Setting Yourself Up for Success —Jason Liu, OpenAI Codex

Jul 24, 2026 · 1:15:02

Jason Liu walks through how to set up OpenAI's Codex for maximum productivity, using voice dictation, app shots, computer use, and a personal memory vault to delegate and automate almost every task. He demonstrates creating skills and plugins from past work, using compaction to keep threads running for weeks with hundreds of sub-agents, and setting up automations with heartbeats and goals. Specific examples include auto-checking flights, editing iMovies via computer use, and having a chief-of-staff thread that monitors Slack and updates task lists. He also covers security permissions (auto-review vs full auto), tips for new users to start with low thinking mode to save tokens, and how to build skills that self-improve by editing their own files. The workshop emphasizes that threads can now communicate with each other, enabling manager-like orchestration and long-running work streams.

Perception Agents — Antje Barth, Amazon AGI Lab

Jul 23, 2026 · 21:45

Antje Barth of Amazon AGI Lab introduces perception agents — AI that sees and interacts with screens visually rather than through APIs — arguing that while agents can click and type, they fail at end-to-end knowledge work because reliability and trust are missing without verifiable outputs. Unlike coding agents, which succeeded due to unit tests, most work lives in the messy seams of applications where no easy verification exists. Barth's solution is a perception-action loop: the agent perceives the rendered screen, plans, acts, and checks its own work in real time, much like humans collaborating over a shared screen. She demonstrates two open-source tools: an annotation Chrome extension that lets users mark elements and issue precise commands, and a verification tool that checks visual design and user flows against specs. A live demo shows a Bee device capturing a meeting transcript that instantly triggers agent actions and verification. The talk closes with a call to build in the open, emphasizing that shared context between human and agent is the missing piece for reliable, trusted AI assistants.

Why Agentic Systems Need Ontologies — Frank Coyle, UC Berkeley

Jul 23, 2026 · 21:18

Frank Coyle argues that most agent failures, from brittle tools to fragile handoffs, stem from missing formal ontologies as logical guardrails. He proposes neurosymbolic AI: probabilistic reasoning inside, logic outside. An ontology is typed entities, relationships, and constraints expressed with RDFS and OWL, letting you specify a payment status must be one of three values, that a customer and support rep are different, or that an order can only be refunded once. Wrapping a Claude tool use loop with a validator—Pydantic at the door for types, ontology at the ledger for results—catches errors like a second refund on the same order, a payout sent to the support desk instead of the buyer, or an order status of 'probably shipped' that English instructions cannot reliably prevent.

Every Harness Will Become A Claw — Sam Bhagwat, Mastra

Jul 21, 2026 · 15:36

Sam Bhagwat, founder/CEO of Mastra, argues that every developer harness will inevitably evolve into a 'claw'—an always-on, self-improving agent that takes initiative. He defines the journey from basic LLMs to agents, then to harnesses (durable, planning-capable tools like Claude Code), and finally to claws that add external event listening, heartbeat-driven wakeups, and continual learning via auto-skill generation. Drawing on Steinberger's law (a play on Zawinski's law), Bhagwat predicts a future shakeout where only a handful of claws survive, just as mobile platforms consolidated around a few apps. He urges builders to equip their agents with the full capability stack—durability, planning, parallel subagents, session persistence—to avoid being displaced in the coming consolidation.

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

Jul 20, 2026 · 6:08

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

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

Jul 20, 2026 · 5:45

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

Build the AI GTM Agent That Knows the Buyer - Dr. Sajjan Kanukolanu, Position2 (Position Squared)

Jul 20, 2026 · 26:27

Position2's Dr. Sajjan Kanukolanu presents an AI GTM architecture that knows buyers before they message, solving three problems—AI, integration, and architecture—rather than bolting AI onto legacy stacks. The system uses three layers: signals (CRM, enrichment, LinkedIn), buyer intelligence (knowledge base, ICP scoring, context graph), and action (personalized chat, rep alerts, CRM updates, sequence triggers). A demo shows anonymous visitors deanonymized into a dashboard tracking 3,000+ visitors from 280 accounts, with LinkedIn intelligence capturing engagement across 8 posts from 100 visitors. Kanukolanu warns of ICP drift (retrain quarterly), alert fatigue (use context graph to cut noise), identity ceiling (~70% company, 15-20% individual accuracy), and human bottleneck (keep email editing under 30 seconds). The four takeaways: start with identity, score fit and intent separately, build an auditable policy engine, and let every send and deal compound into the knowledge base.

Skills are the New SDKs - Elvin Aghammadzada, DataRobot

Jul 20, 2026 · 26:40

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

Every company should have a Brain — Garry Tan, Y Combinator

Jul 17, 2026 · 21:08

Y Combinator CEO Garry Tan argues founders must build AI-native companies that treat AI as a workforce, not auto-complete, to achieve 400x productivity. He details how skill files (Markdown documents) act as employees, a resolver table as an org chart, and a company brain (like his open-source GBrain) as the memory layer that selects the right context for each task. Tan cites YC's Winter '25 batch where 25% of companies had 95% AI-generated code, and portfolio companies Emergence and Retail reaching $15M ARR with 15 people and $60M with 40 respectively. His core message: never do one-off work—always "skillify" completed tasks into reusable skills, so the organization compounds knowledge daily rather than waking up with amnesia.

Don't Ship Skills Without Evals — Philipp Schmid, Google DeepMind

Jul 14, 2026 · 21:46

Philipp Schmid, Staff Engineer at Google DeepMind, argues that shipping agent skills without evals is like merging code without tests, leading to unreliable performance. He explains that most of the 50,000+ skills on Skill Bench lack evals and are often AI-generated, which can negatively impact performance. The talk distinguishes between capability skills (teaching models new tasks) and preference skills (encoding team-specific workflows), with evals enabling retirement of skills as models improve. Schmid shares practical advice: keep skill descriptions concise (under 500 lines), include negative tests, and write directives over passive information. He details a case study creating 117 test cases for the Gemini interactions API, achieving 90% valid code generation using regex-based asserts and LLM-as-judge. The key takeaway: always run ablation tests with and without skills to measure their true impact, and start small with as few as 10-20 eval samples.

Chat and citations won't save your vertical AI - Atul Ramachandran, Filed Inc

Jul 11, 2026 · 15:12

Atul Ramachandran, CTO and co-founder at Filed, argues that chat interfaces and citation trails fail vertical AI because they shift the verification burden back to users, making every error catastrophic. Drawing from Filed's work building AI data entry for tax firms—where they hit 80%+ accuracy against a 50-60% baseline yet still faced complaints—he explains that the real fix is to design for delegation, not participation. He proposes treating the product as a conveyor belt where users are supervisors, using long-running background agents, automatic skills that capture user quirks, monitoring via traces, and control mechanisms like plan approval before irreversible actions. Ramachandran advocates measuring weekly active sessions instead of weekly active users, aiming for sessions to rise while direct user interaction falls. The episode covers these four pillars and the shift in metrics needed to build successful vertical AI products.

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

Jul 11, 2026 · 23:05

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

Design Patterns for AI Trust: Juries, Libraries, and Agent Tiers — Alex Bauer, Upside.tech

Jul 11, 2026 · 17:09

Alex Bauer, co-founder of Upside, argues that go-to-market teams can solve AI's trust problem by managing agents like humans, using patterns such as a librarian for just-in-time knowledge and a jury-and-judge model for subjective decisions. He demonstrates three solutions: first, scaffolding an AI website rebuild with anchor assets like a product capabilities reference that ladders directly into homepage copy; second, a librarian that consults documentation and prior failed queries before answering questions like "How much pipeline in Q1?" to catch fiscal-year or stage definitions; third, a jury-and-judge workflow for multi-touch attribution where independent analysts research deals and a judge weighs reasoning quality before producing a consensus verdict. Bauer warns against low-intelligence models for important work, citing Slackbot's MCP integration as "horrifically stupid," and advocates using tier-two platforms with sub-agents, plan mode, and full MCP support.

Your agent is blindfolded — Johan Lajili, Poolside AI

Jul 8, 2026 · 9:58

Johan Lajili of Poolside AI argues that the key difference between successful and disappointing AI coding agent experiences is whether the agent has a tight feedback loop to verify its work, essentially giving it "eyes" to test its own outputs. He demonstrates this with his CLI tool Spoolside for VS Code extensions that extracts logs and screenshots to reproduce bugs. Lajili predicts engineers will shift from product engineering to "AIX engineering" — focusing on making AI work on the product rather than on the product itself. He advises building ephemeral testing primitives and investing in agent self-serve tools, analogous to putting on your own mask first on an airplane.

Teaching Coding Agents to do Spreadsheets - Nuno Campos, Witan Labs

Jul 8, 2026 · 19:09

Nuno Campos from Witan Labs explains how his team spent four months teaching coding agents to master spreadsheets, raising accuracy from 50% to 92% on a financial analysis benchmark. Key failures included a rigid three-agent architecture and standalone representations like SQL and XML. The breakthrough was replacing 15 separate tools with a single JavaScript repo tool offering persistent state and code-mode semantics, enabling agents to combine multiple operations in one call and drastically reduce timeouts. The team built high-fidelity formula and rendering engines to close the verification loop, and added domain knowledge prompts to focus the model. For evaluation, they moved from LLM-as-judge to deterministic comparisons using golden spreadsheets. Campos urges practitioners to replace many tool calls with real scripting languages, invest in feedback loops, and regularly revisit interfaces as model capabilities evolve.

I Run a Fleet of AI Agents Across Three Machines. Here's What Broke. - Kyle Jaejun Lee, KRAFTON

Jul 8, 2026 · 9:11

Kyle Jaejun Lee runs a fleet of AI coding agents across three machines daily and reveals the scaling failures that emerged from a hierarchy of CEO, VP, manager, and worker agents. To overcome his own attention bottleneck, he separated context into entity-specific workspaces on disk and replaced context compaction with full resets that read handoff files. When moving beyond one machine, five things broke: agents doing work instead of delegating, TMUX panes too crowded to read, out-of-memory crashes from stacked Claude Code processes, colliding Git credentials across workspaces, and the MacBook dying mid-task. He offloaded long-running work to always-on Linux boxes, used Git commits and SSH to move context between machines, and consolidated review gateways onto a single always-on machine with Discord as a unified router. Unsolved challenges include consistent credentials, local-only tools, and resource scheduling—he plans to layer his orchestration on top of Kubernetes to handle compute, secrets, and tools.

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

Jul 7, 2026 · 14:28

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

Respect The Process - Andrew Dumit, Watershed Technology Inc.

Jul 7, 2026 · 16:43

Andrew Dumit of Watershed explains how to deploy coding agents for editing complex supply chain graphs in sustainability, arguing that in a domain rife with expert judgment calls, you must constrain the agent's effects through a typed SDK and deterministic execution while leaving its reasoning free. Unconstrained coding agents caused inconsistency, hallucination, and false reports—saying edits were made when they weren't—and made review impossible for non-coders. Their solution: a TypeScript SDK as the only way to edit graphs, plus a harness that lints agent code, catches conflicts, runs the script, and validates output artifacts, producing traceable, replayable edits. This approach improved accuracy from 43% to 92% on internal evals, with further gains from prompt improvements, few-shot examples, and breaking tasks into plan-and-execute loops. Even when the agent lands on a different expert answer, every change is valid and reviewable without reading code.

Building Great Agent Skills: The Missing Manual

Jun 29, 2026 · 20:43

Matt Pocock presents a 'skill checklist' framework to help developers escape 'skill hell' by systematically evaluating and improving agent skills, covering trigger, structure, steering, and pruning. He explains the trade-offs between user-invoked and model-invoked skills: model-invoked increase context load and unpredictability, user-invoked increase pilot cognitive load. Structure divides skills into steps and reference, with branching material hidden behind context pointers to minimize skill.md. Steering uses 'leading words' like 'vertical slice' that appear in reasoning traces; to boost leg work, he splits skills so agents only see one step at a time. Pruning removes duplication, sediment, and no-ops that don't affect behavior. The framework is in the 'writing-great-skills' skill in his repository.

The Agentic AI Engineer - Benedikt Sanftl, Mutagent

Jun 29, 2026 · 34:50

Benedikt Sanftl and Burak of Mutagent introduce the Agentic AI Engineer, an automated loop that builds, evaluates, and optimizes AI agents at scale. They argue the human bottleneck in manually iterating on agent prompts, evaluations, and diagnostics can be removed by using an orchestrator that manages spec-driven development, eval-driven testing, and online monitoring. The offline loop covers spec, build, and eval; the online loop monitors traces, diagnoses failures, and feeds improvements back into the system. They demo two research-preview agents: an evaluator that constructs eval suites and a diagnostics agent that analyzes production traces to suggest targeted fixes. The platform connects to observability tools and target frameworks (e.g., Claude Code, LangChain) and outputs PRs or updated agent definitions. The core claim is that automating this lifecycle enables teams to ship and improve hundreds of agents with faster iteration and less manual effort.

HTML is All You Need (for Agents to Make Graphics) - Amol Kapoor, Nori

Jun 28, 2026 · 7:00

Amol Kapoor, CEO of Nori Agentic, argues that coding agents can create high-quality visual artifacts like slides, docs, and videos by using HTML instead of traditional design tools. He explains that agents think in language and structure, not pixels, so tools like PowerPoint or Figma force them into a human-centric approach that fails. By giving agents HTML—a language they understand intuitively—they can produce properly aligned, themed graphics without manually placing coordinates. Kapoor demonstrates this with the 'pelican riding a bicycle' test, where models fail at raw SVG but succeed with HTML. He applies this method at Nori to build board decks, sales decks, and even animated videos purely with HTML and CSS. The episode advocates for 'thinking like the model' and concludes that for graphics, HTML is all you need.

User Signal Dies at the Retrieval Boundary - Sonam Pankaj, StarlightSearch

Jun 28, 2026 · 15:37

Sonam Pankaj, CEO of StarlightSearch, argues that production agents fail because retrieval is static and eval signals never cross into runtime context. She introduces utility-ranked memory, where memories are re-ranked by a utility score combining semantic similarity with outcome history—passing runs raise a memory's score, failing runs lower it. In a product SQL agent demo, a search for 'gaming mouse' initially failed, but after marking that output as a failure and noting a wireless mouse was relevant, the agent's trajectory updated in real time to find the correct product. Benchmarks on Tao Bench show reflect memory improves performance from 66% to 76% without skills and 80% with skills; on agentic tasks, reflect achieves 61.3% versus 35.7% baseline and 58.2% with other memory systems. Pankaj explains that after enough reviews, memories can be baked into skills, allowing continuous improvement without manual prompt rewriting or model fine-tuning.

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

Jun 28, 2026 · 28:27

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

Agents in Production: How OpenGov Built and Scaled OG Assist - Gabe De Mesa, OpenGov

Jun 26, 2026 · 18:30

Gabe De Mesa of OpenGov explains how the company built and scaled OG Assist, an AI agent embedded across its government ERP products, using the Effect TypeScript library for full control over the agent loop and adopting Google's A2A protocol for agent-to-agent communication. The team moved from LangGraph to a custom Effect-native loop to gain fine-grained control over tracing, error handling, and structured concurrency. They implement feedback and automated evals with thumbs-up/down and CI checks, human-in-the-loop approvals for mutating tool calls, and sandboxed code execution to keep production safe. Long conversations are managed via rolling summarization with memory recall. Observability comes from Effect's built-in tracing, enabling bottleneck profiling. Tools and skills are built as Effect toolkits, and internally OpenGov uses Claude and Cursor to accelerate development workflows.

Recursive Coding Agents - Raymond Weitekamp, OpenProse

Jun 25, 2026 · 23:48

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

Build Systems, Not Code - Angie Jones, Agentic AI Foundation

Jun 25, 2026 · 19:39

Angie Jones (Agentic AI Foundation) argues that engineering discipline remains essential when building agentic systems, moving the joy of building from writing code to designing system architecture. Using her Relocation Scout house-hunting agent as an example, she walks through applying skills like systems thinking, workflow design, decomposition, separation of concerns, modularity, and algorithmic thinking. She advises using code for deterministic tasks like commute calculation, agents for judgment on listings, and humans for authority to approve tours. Jones stresses defining structured contracts between components, designing for idempotency with memory logging, and threat modeling to treat all external input as untrusted. She advocates baking maintainability into the system with self-documenting workflows so that any agent or human can orient themselves without reverse-engineering prompts.

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.

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

Jun 5, 2026 · 16:44

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

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

May 30, 2026 · 10:40

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

Reverse engineering a Viking VOIP phone protocol with Claude Code — Boris Starkov, Eleven Labs

May 29, 2026 · 20:11

Boris Starkov from ElevenLabs used Claude Code to reverse engineer the undocumented protocol of a Viking VOIP phone that three senior engineers and ChatGPT failed to configure in a year. Claude brute-forced all 676 possible two-letter command combinations, found 80 valid ones, then set up a TCP proxy between a Windows XP virtual machine and the phone to intercept traffic from the proprietary software. The critical missing piece—a one-byte checksum in the persistence command—was deduced by Claude by running known input-output pairs through the derived formula, confirming a simple subtraction. Starkov acted as Claude's hands, physically rebooting the phone and reporting beeps. The protocol is now open-sourced as a Claude Code skill, enabling direct programming without Windows software. The project culminated in a red phone booth at AI Engineer Europe where picking up the receiver connects to a Michael Caine voice agent quizzing attendees on British AI history.

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

May 24, 2026 · 25:13

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

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

May 21, 2026 · 18:25

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

Any-to-Any: Building Native Multimodal Agents - Patrick Löber, Google DeepMind

May 20, 2026 · 16:21

Patrick Löber, a member of the technical staff at Google DeepMind, explains how to build native multimodal agents using the Gemini API ecosystem, covering multimodal understanding, native image and speech generation, and real-time interaction via the Live API. He demonstrates constructing a NotebookLM clone as an agentic system where a reasoning Gemini model decides whether to generate an infographic or podcast-style audio using function calls to specialized models like Nano Banana for images and a text-to-speech model for speech. The episode details practical implementation: uploading PDFs, video, and audio files; using context caching to reduce costs by 90%; and generating infographics or multi-speaker audio directly from prompts. Löber highlights that native generation models understand world context—like drawing arrows on a map to produce the Golden Gate Bridge—and that the Live API enables audio-to-audio interactions with a single architecture, supporting multiple languages and accents.

Skill issue: Lessons from skilling up coding agents to use Langfuse - Marc Klingen, Clickhouse

May 20, 2026 · 24:09

Marc Klingen, founder of Langfuse, shares six learnings from building a skill that lets coding agents like Claude Code add Langfuse observability and evals to projects. The skill addresses the problem of agents hallucinating stale instrumentation from outdated pre-training context by surfacing a search endpoint for documentation, helping agents navigate 478 documentation pages, and referencing rather than duplicating content. Klingen explains how examining traces revealed 80% of issues, basic eval setups were better than none, and an auto-research loop with a target function suggested six improvements (three accepted). However, the target function nearly backfired by optimizing away documentation-fetching steps vital for long-term reliability. He also discusses challenges of skill distribution, versioning, and whether to aim for quick initial setup or perfect single-shot implementation.

From 46% to 90%: Fine-Tuning Tiny LLMs for On-Device Agents — Cormac Brick, Google

May 20, 2026 · 21:01

Google's Cormac Brick explains how developers can build on-device AI agents using either system-level Gemini Nano via AI Core or app-level custom models via LiteRT-LM. He demonstrates a skill harness built on Gemma 4 that enables agentic tasks like restaurant roulette, running fully on-device with JavaScript UI. For fine-tuned tiny models, Function Gemma at 270M parameters improved from 46% to over 90% accuracy on eight of ten app-intent functions after synthetic data fine-tuning. The talk also covers the Eloquent transcription app, which chains two Gemma 3-based models (ASR and text polishing) under a few hundred million parameters for offline use. Key trade-offs are latency, privacy, and customization versus system integration effort.

Agents Don't Do Standups: Building the Post-Engineer Engineering Org — Mike Spitz, PFF

May 15, 2026 · 17:50

Mike Spitz, CTO of PFF, details a three-month case study where two engineers using AI agents outperformed a team of ten, achieving 25x more deployments and 10x higher output by ticket complexity. The two engineers deployed five times daily while the ten deployed once every five days; customer satisfaction rose to 8.6 out of 10 from a prior 7–7.5. Scrum practices were eliminated—standups, sprint planning, and retrospectives—replaced by every-other-day huddles. The new workflow moves from a spec to a lightweight design document (LDD) to auto-generated tickets and PRs, with agents handling style and naming in code reviews. A QA agent spins up on staging after each merge to check acceptance criteria against tickets. Spitz advises starting slowly with engineers who have deep system knowledge, encoding engineering culture into composable skills, and treating the development lifecycle like a factory.

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

May 15, 2026 · 18:27

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

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

May 15, 2026 · 21:49

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

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

May 14, 2026 · 1:04:27

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

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.

Give Your Agent a Computer — Nico Albanese, Vercel

May 12, 2026 · 1:08:53

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

Agentic Search for Context Engineering — Leonie Monigatti, Elastic

May 8, 2026 · 1:03:13

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

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

May 6, 2026 · 1:21:03

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

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

May 4, 2026 · 1:18:41

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

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

May 4, 2026 · 1:48:26

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

TLMs: Tiny LLMs and Agents on Edge Devices with LiteRT-LM — Cormac Brick, Google

May 3, 2026 · 1:20:58

Cormac Brick from Google AI Edge explains how Tiny LLMs (sub-1B parameters) and on-device agent skills are making edge AI practical. He details LiteRT-LM, an open-source runtime that runs Gemma models on Android, iOS, and embedded systems, achieving over 1,000 tokens/s on high-end phones. Agent skills use progressive disclosure—loading skill details on demand—enabling reliable tool calling on 2B-4B models. For app deployment, fine-tuning boosts tiny model reliability by 20-40 points (e.g., Function Gemma 270M hit 86% accuracy on 10 functions). Synthetic data workflows and modular design (ASR + text polishing) power real apps like AI Edge Eloquent, which runs entirely offline. Safety is managed through system-level checkers and narrow functional scope for tiny models.

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.

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

Apr 30, 2026 · 19:18

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

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

Apr 30, 2026 · 19:22

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

OpenAI Codex Masterclass — Vaibhav Srivastav & Katia Gil Guzman

Apr 29, 2026 · 1:01:59

Katia Gil Guzman and Vaibhav Srivastav showcase OpenAI's Codex as a full software engineering agent, not just a coding assistant, powered by models like GPT-5.4 and GPT-5.3 Codex Spark. They demonstrate plugins bundling skills and MCP servers, automations that run scheduled tasks (e.g., Slack or Gmail summaries), and code review that 100% of OpenAI pull requests use by default. Subagents parallelize work across up to 20 agents for tasks like reviewing 45 persona files, with each subagent configurable by model, sandbox mode, and MCP access. New features include Guardian approvals for privileged operations, hooks for custom triggers, and a Cloud Code plugin. The episode also highlights the milestone of 3 million weekly active users, tripled since January, and covers security scanning for vulnerabilities.

Full Walkthrough: Workflow for AI Coding — Matt Pocock

Apr 24, 2026 · 1:36:30

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

Agents need more than a chat - Jacob Lauritzen, CTO Legora

Apr 22, 2026 · 14:21

Jacob Lauritzen, CTO of Legora, argues that vertical AI agents handling complex work need collaboration interfaces beyond simple chat. He introduces the verifier's rule—tasks easy to verify get solved by AI—and shows how legal work spans from easy-to-verify contract definitions to impossible-to-verify litigation strategy. Lauritzen explains that increasing trust requires making tasks verifiable (e.g., test-driven development, proxy verification with golden contracts) or adding guardrails, while increasing control demands moving from low-control agent trees to planning, then to skills and elicitation where agents ask humans for decisions. He criticizes chat as one-dimensional and low-bandwidth, advocating for high-bandwidth persistent artifacts like documents and tabular reviews where humans can highlight clause three or flag items, enabling effective human-agent collaboration and progressive discovery without losing context.

Code Mode: Let the Code do the Talking - Sunil Pai, Cloudflare

Apr 19, 2026 · 19:40

Sunil Pai of Cloudflare presents 'Code Mode,' a paradigm where AI agents generate executable JavaScript instead of using JSON-based tool calls, drastically reducing token usage from 1.2 million to 1,000 for Cloudflare's 2,600 API endpoints. He demonstrates a live (if glitchy) demo of the Mythical server handling a DDoS response in one shot, and shares the 'harness' architecture: a sandboxed, capability-secure environment that grants only explicit APIs. The talk explores emergent behaviors like Kenton Varda's canvas where the model played tic-tac-toe by inspecting raw stroke state, and envisions long-running workflows, generative UI, and a future where code—not buttons—defines user interaction. Pai argues that developers must optimize for agent-facing DX with searchable docs, clear errors, and capability-based security, as the next billion users will be code-generating bots.

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.

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

Jan 5, 2026 · 1:52:25

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

Building Intelligent Research Agents with Manus - Ivan Leo, Manus AI (now Meta Superintelligence)

Dec 30, 2025 · 1:21:30

Ivan Leo of Manus AI introduces the Manus API and Manus 1.5, positioning the platform as a general action engine for building intelligent research agents. He demonstrates how the API enables asynchronous task dispatching, file uploads with automatic 48-hour deletion, and webhooks for scalable workflows. The workshop covers creating a Slack bot that integrates Manus's browser operator, file attachments, and connectors to private data sources like Notion. Leo shows real-time demos including a custom French learning app, a conference event scraper with calendar integration, and an invoice processing bot that references company policies. He also discusses the roadmap for memory persistence, document exporting (PPTX/PDF), and enhanced permission systems for browser automation.

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

Dec 22, 2025 · 18:31

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

The 3 Pillars of Autonomy – Michele Catasta, Replit

Dec 22, 2025 · 24:42

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

Your Support Team Should Ship Code – Lisa Orr, Zapier

Dec 16, 2025 · 16:06

Lisa Orr of Zapier explains how the company empowers its support team to ship code using AI, tackling the app erosion caused by 8,000+ third-party integrations. Initially, they built an API playground that failed due to lack of workflow embedding, then pivoted to MCP tools in IDEs, but the slow Diagnosis tool led to an asynchronous agent. The resulting Scout Agent autonomously categorizes tickets, assesses fixability, generates merge requests, and enables rapid iteration in GitLab. Today, Scout drives 40% of support's integration fixes, doubling individual velocity from 1-2 to 3-4 tickets per week. Orr highlights support's three superpowers: closest to customer pain, real-time troubleshooting, and best at validation, with some team members becoming engineers.

Proactive Agents – Kath Korevec, Google Labs

Dec 13, 2025 · 16:51

Kath Korevec, Director of Product at Google Labs, argues that AI coding agents must become proactive rather than reactive to truly reduce developer cognitive load. She introduces Jools, a proactive autonomous coding agent that observes workflows, personalizes responses, and intervenes at the right moment. Korevec details three levels of proactivity: level one auto-fixes issues during tasks; level two learns project context; level three connects agents across code, design, and data. She highlights features like memory, a critic agent for code quality, verification via Playwright, and a to-do bot. A demo shows Jools indexing a codebase and suggesting high-confidence tasks. Korevec ties this to her personal Halloween animatronic project, where she wished Jools handled debugging so she could focus on creative LED animations.

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

Dec 8, 2025 · 16:22

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

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.

Building Cursor Composer – Lee Robinson, Cursor

Dec 2, 2025 · 15:36

Lee Robinson explains how Cursor built Composer, its first agent model for real-world software engineering, by focusing on being both fast and smart — achieving 4x more efficient token generation than similarly intelligent models while matching open-source performance initially and approaching frontier models after reinforcement learning. The model's training posed infrastructure challenges: matching training and inference environments across thousands of GPUs, handling complex rollouts with hundreds of tool calls and up to millions of tokens, and ensuring consistency by using the same tool format and responses as production. Cursor solved these with custom kernels that sped up training by 3.5x on NVIDIA Blackwell chips for mixture-of-experts layers, load balancing across threads to avoid idle time, and co-designing RL infrastructure with its Cloud Agents product using virtual machines that mirror the production Cursor environment. This allowed the model to become a power user of tools like semantic search, which improved all models but especially Composer. RL also taught the model to parallelize tool calls (e.g., reading 10 files simultaneously) and to search more before editing,…

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

Nov 24, 2025 · 20:52

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

Building the platform for agent coordination — Tom Moor, Linear

Jul 28, 2025 · 19:43

Tom Moor, Head of Engineering at Linear, explains how the company is evolving from an issue tracker into an operating system for engineering teams that treats AI agents as first-class teammates. He details Linear's pragmatic AI journey: starting with embeddings and PG vector, then moving to a hybrid search index using TurboPuffer and Cohere embeddings, leading to features like Product Intelligence (query rewriting, reranking, deterministic rules for suggestions), natural language filters, Slack-to-issue creation, and daily audio pulses. The core of the talk is Linear's agent platform, launched two weeks ago, where coding agents like CodeGen, Bucket, and Charlie integrate via OAuth, GraphQL, and new webhooks, allowing users to assign, mention, and interact with agents just like human teammates. Moor emphasizes best practices for builders: respond fast, inhabit the platform's language, move issues to 'in progress,' and clarify plans before acting, all while keeping interactions concise and value-adding. The episode argues that with this platform, engineering teams can build more, faster, and with higher quality by offloading grunt work to infinitely scalable cloud-based teammates.

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

Jul 27, 2025 · 1:21:00

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

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.

Beyond the Prototype: Using AI to Write High-Quality Code - Josh Albrecht, Imbue

Jul 25, 2025 · 17:59

Josh Albrecht, CTO of Imbue, discusses Sculptor, an experimental coding agent environment that aims to move AI-assisted coding beyond prototypes to high-quality production software. He argues that the key is preventing errors through learning, planning, writing specs, and enforcing strict style guides, then detecting remaining issues with automated linting, generated test suites, and LLM-based code reviews. Sculptor forces agents to plan first, auto-fixes linting errors, and enables generating hundreds of happy-path and unhappy-path unit tests. Albrecht emphasizes writing functional, side-effect-free code, sandboxed execution, and focusing on integration tests and test coverage. He also notes that generated tests can be thrown away since AI can regenerate them easily, and that a well-stated problem is half solved.

From Copilot to Colleague: Trustworthy Agents for High-Stakes - Joel Hron, CTO Thomson Reuters

Jul 23, 2025 · 19:45

Thomson Reuters CTO Joel Hron explains the shift from helpful AI assistants to productive, agentic systems in high-stakes legal, tax, and compliance workflows. He frames agency as a spectrum with dials for autonomy, context, memory, and coordination, which must be tuned to the risk tolerance of professional users. Key lessons include building the whole system first rather than over-indexing on minimal MVPs, treating legacy applications as assets to be decomposed into tools for agents, and the persistent challenge of evaluating agentic systems with expensive, variable human expert judgments. Hron demonstrates a tax product that extracts data from documents and maps it to a calculation engine, and a legal research agent that uses proprietary case law tools to produce cited reports. He emphasizes leveraging unique organizational assets—like Thomson Reuters' 4,500 domain experts and terabytes of proprietary content—to create differentiation.

Introducing Strands Agents, an Open Source AI Agents SDK — Suman Debnath, AWS

Jun 27, 2025 · 14:26

Suman Debnath, a Principal ML Advocate at AWS, introduces Strands Agents, an open-source SDK that simplifies AI agent creation by requiring only a model and tools, eliminating scaffolding. He demonstrates building an agent in a few lines of code to read, summarize, and speak a file, using default tools. Another demo integrates Strands with an MCP server to generate animated math videos via Manim, requiring no system prompts—the model reasons autonomously. Custom tools can be created by decorating functions. Strands supports any model via LiteLLM or Bedrock, and is available at strandsagent.com with a GitHub repository for contributions.

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…

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.

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

Jun 3, 2025 · 27:06

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

Grounded Reasoning Systems for Cloud Architecture - Iman Makaremi

Jun 3, 2025 · 26:05

Iman Makaremi, co-founding head of AI at Catayaw, details how his team built a grounded reasoning system for cloud architecture using a knowledge graph and multi-agent orchestration. The system uses LangGraph for workflows, Flyte for distributed execution, and AWS Bedrock with Claude 3. A domain-specific knowledge graph serves as long-term memory, enabling persistent representation of architectural state. The multi-agent system comprises a chief architect and ten staff architects specialized in domains like infrastructure and API, plus retrievers for requirements and architecture. Key findings include that semantic grounding improves but doesn't always work, graph memory supports continuity, structured outputs improve control, and human evaluation is essential early on—Catayaw built an internal tool called Eagle Eye. The workflow proceeds through list generation, conflict resolution, and design proposal with agent cloning for parallel tasks.

The Robots are coming for your job, and that's okay - Elmer Thomas and Maria Bermudez

Jun 3, 2025 · 8:57

Elmer Thomas and Maria Bermudez of Twilio's developer education team explain how they built six single-purpose AI agents to automate repetitive documentation tasks like editing, alt text generation, and jargon simplification, rather than replacing human writers. The agents, powered by GPT-4/01 and validated with tools like Veil Lint and CI tests, reduce hallucinations through layered human review. Maria demos the automated editor, SEO metadata generator, alt text generator, and jargon simplifier. The team’s playbook: identify a pain point, pick a repeatable task, and iterate with weekly user feedback.

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.

Effective AI Agents Need Data Flywheels, Not The Next Biggest LLM – Sylendran Arunagiri, NVIDIA

Jun 3, 2025 · 16:41

Sylendran Arunagiri of NVIDIA argues that effective AI agents rely on data flywheels, not the largest LLMs, enabling smaller models to achieve top accuracy at a fraction of cost. He details how NVIDIA's NeMo microservices power a continuous cycle of data curation, fine-tuning, evaluation, and guardrailing. Using an internal employee support agent (NVINFO), they achieved 96% accuracy with a 70B model but found that fine-tuning a smaller 8B model matched that accuracy, while a 1B model reached 94% with 98% lower inference cost and 70x latency reduction. The process involved curating 685 ground truth data points from user feedback and error analysis. He provides a framework: monitor user feedback, attribute errors, plan model experimentation, and execute regular retraining cycles.

The Devops Engineer Who Never Sleeps — Diamond Bishop, Datadog

Apr 22, 2025 · 16:18

Diamond Bishop, Director of AI Engineering at Datadog, explains how his team builds AI agents—the On-Call Engineer and Software Engineer—that automate DevOps tasks like incident investigation, remediation, and postmortem writing. He details how the On-Call Engineer wakes up for alerts, reads runbooks, queries logs and metrics, and suggests fixes to let human engineers sleep. The Software Engineer proactively fixes errors by generating code diffs and pull requests. Bishop shares four key lessons: scope tasks and evaluate rigorously, assemble teams of optimistic generalists and UX experts, adapt UX for human-agent collaboration, and treat observability as critical for debugging multi-step agent workflows. He predicts that within five years, AI agents will surpass humans as primary users of SaaS platforms like Datadog, urging builders to design for agent consumers.

Trust, but Verify: Knowledge Agents for Finance Workflows - Mike Conover

Apr 9, 2025 · 21:10

Mike Conover, CEO of Brightwave, explains how his company builds knowledge agents for financial workflows, digesting thousands of pages of content for due diligence and research. He argues that non-reasoning models perform only local search, so winning systems must use end-to-end reinforcement learning over tool-use calls to achieve globally optimal outputs. Conover describes design patterns like decomposing research into sub-themes, using secondary calls for error correction, and avoiding the latency trap of long feedback loops. He emphasizes that synthesis—weaving facts across documents—remains a hard problem due to limited recombinative reasoning in training data. Brightwave's product reveals its thought process through interactive citations and structured findings, allowing analysts to drill into any passage. The episode also notes the company is hiring, offering a $10,000 referral bonus.

Scaling Agents for Gen AI Products - Anju Kambadur, Bloomberg Head of AI Engineering

Apr 1, 2025 · 19:38

Bloomberg's Head of AI Engineering, Anju Kambadur, details the company's shift from building proprietary LLMs to leveraging open-source models for agentic products, emphasizing that scaling agents requires accepting inherent fragility and building resilient guardrails rather than seeking perfect upstream systems. Drawing on Bloomberg's daily scale—400 billion structured data ticks, over a billion unstructured messages, and 40+ years of history—Anju explains how their 400-person AI team organized into 50 teams across London, New York, Princeton, and Toronto. He argues that agents must be semi-autonomous with non-optional guardrails (e.g., preventing financial advice, ensuring factuality) because compounding errors from evolving APIs and LLMs demand self-contained safety checks. The talk uses the example of a research analyst agent that factors query understanding, answer generation, and guardrails into separate components, reflecting an org structure that collapses vertically for fast iteration on single agents then later introduces horizontal teams (like guardrails) for optimization and cost reduction. Anju stresses that readiness to build horizontal teams comes after multiple…

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.

How Coding Agents change Software Development Forever - Hailong Zhang

Feb 22, 2025 · 8:50

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

Lessons from building GenAI based applications — Juan Peredo

Feb 22, 2025 · 33:13

Juan Peredo details the hidden complexities of building GenAI applications, from model hosting and cost control to output validation and observability. He compares local (Ollama) vs cloud hosting (Modal, SkyPilot) and warns that an agent processing 3,000 calls/day with OpenAI O1 costs nearly $300,000/month, while LLaMA 3.3 70B drops that to $50,000/month. He explains techniques to mitigate hallucinations—prompt engineering, guardrails, RAG, and fine-tuning—each with trade-offs like added latency or cost. Peredo advocates externalizing prompts via LangChain Hub for easy iteration and future-proofing, and illustrates agent design with parallel calls to reduce latency. Finally, he stresses observability using tools like LangSmith to debug probabilistic failures, such as an LLM failing on case sensitivity.

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

Feb 16, 2025 · 18:55

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

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

Feb 6, 2025 · 1:48:16

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

Hyperspace More Nodes Is All You Need: Nicolas Schlaepfer

Sep 4, 2024 · 5:48

Nicolas Schlaepfer introduces Hyperspace's decentralized AI network and new product, a node editor for power users that generates agentic plans via a DAG orchestration model (HyperEngine v3). The network, with over 15,000 nodes, leverages consumer devices rather than GPUs, running inference through Llama.cpp. The product combines prompt engineering, visual React flow, Python execution, and RAG-like web browsing, using Qwen 2 instruct for reasoning and LLaMA 3 70B for summarization. Schlaepfer emphasizes diverse open-source models and a virtual file system for agentic primitives. Availability via waitlist is announced later this week.

Building Reliable Agentic Systems: Eno Reyes

Aug 20, 2024 · 18:14

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

From Software Developer to AI Engineer: Antje Barth

Jul 24, 2024 · 19:48

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