OpenClaw

From coding to Knowledge work agents — Karan Vaidya, Composio

Sep 3, 2026 · 20:42

Karan Vaidya, cofounder and CTO of Composio, argues coding agents raced ahead not because models are better at code but because code already had six primitives knowledge work lacks: centralization, history, context, verification, governance, and reversibility. He walks each one, from the repo as a single source of truth versus a deal scattered across Salesforce, Notion, Gmail, Slack, and Zendesk, to git history against agents that start blank every time. He recounts pointing his own OpenClaw at hiring outreach that mass-emailed candidates and ended up on Twitter, noting every technical check passed while nothing tested whether the outreach should have gone at all. He cites a Meta alignment director whose email agent kept deleting messages until 200 were gone, showing prompts get compacted away and walls must live outside the agent. He concedes reversibility is hardest, since sent emails and wires cannot be recalled, so Composio uses sandboxes to catch mistakes before they reach the real world.

Beyond the Lethal Trifecta: Agentic Commerce on the Open Internet — David Levine, Kiduna Club

Sep 1, 2026 · 21:40

David Levine, founder of Kiduna Club, argues that the lethal trifecta — Simon Willison's term for private data, untrusted content and the ability to act — keeps true agentic commerce off the open internet. Enterprises responded by penning agents inside Slack and Salesforce, losing context. His fix is the DUNA, a decentralized nonprofit under a West Virginia law that took effect the day before his talk, registered as organization 62847. Agents gain legal standing to own assets, sign agreements and answer in court, but cannot distribute profits without memberships becoming securities. Each agent carries JWT tokens resolving to a registered organization like DNS names; governance runs on decision markets trading pass-and-fail tokens on proposed policies instead of votes.

Healthcare’s Agent Bytecode: X12 as the Harness for AI Agents — Vasant Kearney, Onlay

Aug 19, 2026 · 20:25

Vasant Kearney of Onlay argues that X12, the healthcare claims data standard, is the harness for AI agents: every step of the claim lifecycle—from eligibility (270) through acknowledgment (999) to payment (835)—has an X12 correspondence, and an agent calling a payer or driving a portal is emitting the same transaction by another route. He says phone, portal, and X12 surfaces are built by different teams and can all agree on the wrong answer, so no surface is ground truth; his system keeps a semi-correct internal X12 representation, correct only until downstream evidence says otherwise. Enterprise memory must live in a database rather than local disk, and swapping in a stronger model is not automatically better inside a system built around the old one—evals and validation must be redone. The goal is cutting insurance costs and improving patient experience, and that means being AI pilled but also AI skeptical.

Security Firewall for Agents — Ryan Dahl, Deno

Aug 17, 2026 · 19:06

Ryan Dahl, CEO of Deno, argues agents must be treated as untrusted software and introduces Claw Patrol, an MIT-licensed proxy that parses every byte leaving an agent below the HTTP layer. At Deno Deploy, agents with write access to Postgres, Kubernetes, ClickHouse, and AWS can be prompt-injected through the support system, so Opus refusing to delete the users table is not enough. Claw Patrol blocks destructive actions even when an agent spawns psql through an EKS endpoint, using HCL rules checked into Git, holds credentials so agents never see them, and can route actions to an LLM judge or Slack approval. A demo shows Codex in yolo mode trying to delete the users table and being blocked. It also includes a unit test system with fixture requests to ensure rules work.

Bringing agents onto the world wide web — Paul Klein IV, Browserbase

Aug 14, 2026 · 18:26

Paul Klein IV, founder of Browserbase, argues browser agents are no longer held back by models; the missing piece is engineering. He details a three-part harness: multimodal agents that write code and intercept network requests, skills and memory that compress page context, and consistent infrastructure, mocking the 'SOC 2 compliant Mac Mini at scale' problem. Klein says the web itself must improve for agents, pointing to accessibility trees, Chrome's new Web MCP, and unsolved problems of agent login and trust certification. He contends the payoff is the logistics company in Singapore, the bank in South Africa, and the lumber factory in Mexico running on PHP forms, not San Francisco, and introduces Browserbase Agents as a battery-included solution.

Lessons from Studying Every Memory System — Shlok Khemani, Independent

Aug 12, 2026 · 19:31

Shlok Khemani, an independent researcher, reverse-engineered the memory systems of ChatGPT and Claude to show how consumer AI personalization evolved from user-managed fact lists to background-updated running profiles. He details that ChatGPT's v2 profile is ~4,000 tokens of dense keyword clues, updated every few days, while Claude's is 1,000 tokens of full sentences, refreshed daily and visible in settings, arguing memory is a function of compute with trade-offs between serving and update costs. He highlights a false memory where ChatGPT claimed he visited Turkey in 2025 (he went to Thailand), blaming a product problem—no system notices conflicts or reasons over email and calendar—rather than a technology limitation. He concludes that memory cannot be outsourced, continual learning already happens outside model weights, and the real bottleneck is context gathering across fragmented products.

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.

The State of Model Routing — NVIDIA, Cognition, OpenRouter

Aug 6, 2026 · 48:17

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

The Model Was Right. The Harness Failed. — Vinoth Govindarajan, OpenAI

Jul 29, 2026 · 18:26

Vinoth Govindarajan of OpenAI argues that most agent failures are harness failures, not model failures. Using OpenClaw as a case study, he details five failure shapes: state hole (delivered but not remembered), overlapping writers (last write silently erases previous), dangling tool call (run waits for an event that never arrives), approval drift (expired approval blocks later work), and missing edge proof (internal success but user didn't see result). The through line: a model proposes, the harness commits, and the receipt proves it. He prescribes three invariants—own the state, order the mutation, prove the action—and a five-question run receipt audit: what woke it up, what state did it inherit, what authority did it use, what executed, and what evidence survived.

Loop Engineering from First Principles — Kyle Mistele, HumanLayer

Jul 25, 2026 · 17:57

Kyle Mistele argues that the fix for AI-generated 40,000-line pull requests is not a better prompt but a better loop, borrowing from control theory: a sensor measures the gap between current and desired codebase state, a controller picks the smallest incremental change, and an actuator agent applies it using hand-written golden patterns. Mistele illustrates with HumanLayer's own loop that migrates their RPC API to Effect one procedure at a time, using AST grep as a deterministic sensor, a controller that selects the smallest unmigrated procedure, and an actuator agent gated by deterministic CI running a single iteration per day. The loop tracks its own PRs in version control, refuses to stack a new change while an earlier one is still open, and includes a feedback file and comment trigger for humans to re-steer it. Mistele concludes that this design makes the code incrementally better, readable, and verifiable, solving the problem of unreadable mass-generated code.

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

Jul 22, 2026 · 20:42

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

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.

Through the AI Fog: The Architectural Decision Agentic Security Depends On — Manoj Nair, Snyk

Jul 20, 2026 · 23:29

Manoj Nair, Snyk's CTO, argues that generative AI systems cannot serve as their own validators because probabilistic models are unreliable for security. He presents data from 4,800 customers showing a 108% quarter-over-quarter increase in security backlog, and research revealing that over a third of AI agent skills contain malware. Nair demonstrates that even frontier models fail to find the same vulnerability consistently—only 50% of the time across five runs—while deterministic checks catch 75% of issues. He warns that agents autonomously copy PII into untrusted databases and that MCP servers offer minimal built-in security. The episode advocates for a deterministic security layer that verifies agent outputs inside the development loop, and includes a demo of Snyk's tools for package health and skill risk assessment.

It's 10pm. Do You Know Where Your Agents Are? — Kim Maida, Keycard

Jul 20, 2026 · 23:02

Kim Maida of Keycard argues that standard API keys dangerously overprivilege AI agents, enabling incidents like a night-shift agent dropping a production Postgres database because its kitchen-sink credential allowed it. Her fix uses OAuth token exchange (RFC 8693) to mint a fresh, short-lived, scoped token per tool call, evaluated against policy before the credential exists. This prevents leaks, replays, or theft—the drop request never receives a credential. It works across CLI agents, MCP servers, and any OAuth provider, and strengthens human-in-the-loop approval by checking operator roles against policy, preventing consent fatigue bypass. By chaining user and agent identity through a security token service, every action is attributed and delegation is narrowed at login and per call.

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.

Agents Need Receipts, Not More Tool Calls - Armanas Povilionis, Alithea Bio

Jul 18, 2026 · 19:36

Armanas Povilionis of Alithea Bio argues that agents need verifiable receipts, not more tool calls, and introduces Froglet, an open-source protocol for agent-to-agent compute. Froglet enables agents to discover, negotiate, execute, and receive signed, tamper-proof receipts for external services, reducing setup to 2,000 tokens and minutes. The protocol integrates with MCP, OpenClaw, and NemoClaw, and supports payment rails, identity, and workload hashes. In a live demo, he shows Claude using Froglet to publish an 'add two numbers' service locally and remotely, then invoke it to get result 12, with a signed deal ID. Froglet aims to make scientific collaboration repeatable and consistent across organizational boundaries without requiring uniform software stacks.

Agents Need Feature Flags - Sachin Gupta

Jul 18, 2026 · 19:17

Sachin Gupta argues that agent systems urgently need feature flags—prompt variants, tool access, model routing, memory policy, autonomy level, and kill switches—to avoid catastrophic incidents like Cursor Sam's false policy citations, Replit's database deletion and fabricated users, LangChain's $47,000 loop, and PocketOS's unintended GraphQL drop. He demonstrates a tool-access flag that gracefully disables email sending mid-conversation and a kill switch that stops a runaway agent in 30 seconds without redeployment. Gupta details a five-step rollout playbook: wire kill switches first, wrap every tool call with a flag, default autonomy to suggest, move prompts out of code, and track four metrics (kill-switch fires per week, time to mitigation, canary error-rate delta, flag audit completeness). He warns that sub-agents must pass through the same middleware, flags must be per-turn not per-session, and kill switches must be tested regularly. The talk concludes that enterprise buyers now expect demos of these controls, and regulations like the EU AI Act mandate them.

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

Jul 17, 2026 · 17:35

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

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.

From fork() to Fleet: Designing an Agent Sandbox Cloud — Abhishek Bhardwaj, OpenAI

Jul 13, 2026 · 44:34

Abhishek Bhardwaj from OpenAI explains the design of a secure, scalable agent sandbox cloud, arguing that microVMs (like Firecracker and Cloud Hypervisor) provide the strongest isolation for running untrusted AI-generated code despite performance trade-offs, and that persistent disk storage is the next frontier for unlocking long-running, stateful agent tasks. He compares runtime isolation technologies from simple fork-exec to containers (with namespaces and cgroups) to gVisor, and advocates for hardware-backed virtualization via microVMs to prevent guest exploits from reaching the host kernel. For persistence, he details incremental block-level snapshotting using copy-on-write filesystems and always-on distributed filesystems, enabling reliable checkpointing and Monte Carlo-style exploration. Orchestration challenges include low-latency sandbox creation through pre-warming or memory snapshots, and intelligent routing based on cached snapshot layers to minimize restore time. The talk positions storage and fast snapshot restore as key enablers for advanced agent capabilities, such as long-horizon tasks and failure recovery.

The Agentic Web and the Bazaar Era of AI - Ramesh Raskar, MIT Media Lab

Jul 12, 2026 · 12:11

Ramesh Raskar and Maria from MIT's Project Nanda argue that the emerging web of AI agents requires an open infrastructure for discovery, commerce, and coordination, moving beyond today's walled-garden platforms. They outline three layers: the Discovery Layer (Nanda index for agent identity, trust, and adaptive resolution), the Commerce Layer (knowledge pricing markets for intelligence), and the Bazaar Layer (machine co-learning). The Nanda index enables agents to find each other across vendors via signed agent facts and adaptive routing, while Nanda town simulates the entire agent economy to test protocols at scale. The goal is a permissionless web where any agent can discover, transact, and learn across organizational boundaries, analogous to the transition from AOL to the open web.

What Does Done Even Mean? Agents and Paperclip's Liveness Model - Dotta, Paperclip

Jul 12, 2026 · 7:14

Dotta, creator of Paperclip, argues that "done" for agents must be a structured claim bundle rather than a boolean checkbox, as agents produce more work than humans can verify. He introduces Paperclip's Liveness Model which balances liveness (keeping work moving) with verification (human review) through three invariants: productive work continues, only real blockers stop work, and infinite loops are bounded. The model uses explicit task transitions, first-class blockers, interactive human approvals, watchdogs (goal-enforcing agents), and separation of verifier from author. Dotta advises defining "done" with artifact, evidence, rubric, owner, and next action, and providing agents tools to verify their own work. The episode presents a protocol for agentic work that avoids approval theater and enables safe delegation.

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

Jul 11, 2026 · 17:12

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

Develop at Idea Velocity - Jeffrey Lee-Chan, Snapchat

Jul 11, 2026 · 15:28

Jeffrey Lee-Chan (Snapchat) and Austin (CMUX) explain how to achieve 'idea velocity' by building parallel multi-agent harnesses that let one engineer direct 10–20 coding agents instead of becoming the bottleneck. Lee-Chan argues the key is separating 'Agent Orchestrator Managers' from specialized workers to prevent low-level implementation bias, using OpenClaw for frictionless Slack-based communication and CMUX terminals for real-time parallelization and unbiased manager oversight. He demonstrates two apps—an AI RPG with dice-roll mechanics and a multi-AI analysis tool—built with this stack, and discusses token-burn tradeoffs between models like Codex 5.3, GPT-5.4, and Minimax. The episode also covers staging environments to avoid doubling token usage, the benefit of persistent memory and contextual guardrails, and the importance of pushing human interaction to the start or end of the workflow for improved parallelization.

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

Jul 10, 2026 · 21:35

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

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

Jul 9, 2026 · 25:13

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

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

Jul 8, 2026 · 18:19

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

The Future Is Domain-Specific Agents - Justin Schroeder, StandardAgents

Jun 29, 2026 · 30:38

Justin Schroeder of StandardAgents argues that domain-specific agents—small, focused AI agents each limited to a single domain—will outperform general-purpose agents that rely on accumulating tools and context via inheritance, and that composition of such agents is the key to building practical, cost-effective AI systems. He defines an agent as deterministic software harnessing non-deterministic model outputs, then critiques the current approach of piling tools and skills into a single agent (inheritance), proposing instead a coordinator agent that delegates to many specialized sub-agents (composition), each with its own minimal context, system prompt, and tools. He claims these domain-specific agents achieve over 80% token efficiency, enable use of cheaper small models (e.g., DeepSeek V4 Flash is 137x cheaper than a frontier model), improve safety by limiting capabilities, and scale easily. Schroeder predicts rapid adoption through 2026-2027, with multi-agent orchestration becoming mainstream and tokens no longer getting cheaper—up 29% when adjusted for IQ. He describes an ideal agent architecture with hooks, rules, and recursive sub-agents, and invites listeners to try…

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

Jun 28, 2026 · 24:36

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

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.

How to talk to statues — Joe Reeve, ElevenLabs

Jun 1, 2026 · 33:28

Joe Reeve, an ElevenLabs growth engineer, built an app that lets users talk to statues by pointing their phone at one—it identifies the statue via OpenAI deep research, generates a matching voice with ElevenLabs' voice design API, and starts an ElevenLabs agent conversation—all in 30 seconds. He created it in two hours on a Sunday using Cursor and a single prompt, posted it on Tuesday, got 50,000 impressions, then reposted about vibe coding and hit 1.5 million. Museums, auction houses (Bonhams, Christie's), and travel platforms reached out; one CEO tracked down his WhatsApp, saying a team of 10 had worked on a similar project for a year. The episode explores voice interaction patterns, the challenge of interrupting agents, the need for multimodal interfaces (voice plus visual), and the potential of vibe coding to democratize software creation, with Joe noting that music and captions are key to viral videos.

Agentic Evaluations at Scale, For Everybody — Nicholas Kang & Michael Aaron, Google DeepMind

May 25, 2026 · 20:03

Nicholas Kang and Michael Aaron from Google DeepMind's Kaggle team argue that AI evaluations are broken due to being scattered, stale, and lacking transparency, citing a competing lab publishing inflated results by using custom compaction settings. They introduce four solutions: hackathons to channel community expertise, a standardized agent exam that returned 500+ submissions in its first week without promotion, a Game Arena where models play poker, chess, and werewolf for an ELO rating that cannot saturate, and an open benchmarks platform. A wastewater treatment plant engineer in Turkey built a novel safety benchmark from 20 years of field experience. They note that on SWE-Bench Pro, six frontier models land within a couple of percentage points, but the harness shifts performance by 22%, complicating comparisons. Challenges include high cost (400,000 poker hands for statistical significance), maintaining community engagement, and dealing with fast model deprecation cycles.

The Missing Primitive for Agent Swarms — Lou Bichard, Ona

May 23, 2026 · 18:37

Lou Bichard, field CTO at Owner, argues that agent swarm infrastructure for coding agents is missing a coordination primitive, while runtimes and orchestration are largely solved. He defines a Software Factory as incrementally removing humans from the SDLC and highlights internal systems from Stripe (Minions) and RAMP (Inspect) as real-world examples. Owner provides VM-level isolation for agent fleets and sub-agent patterns, demonstrated with a demo of process-based and VM-based swarms. Bichard identifies GitHub as a poor coordination layer for hundreds of parallel pull requests and proposes solutions like state machines, durable execution, and a CLI gateway that any local agent can invoke to check progress. He notes context rot and agents skipping steps as key challenges, and announces a public two-week project to build a Software Factory from scratch starting next week.

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

May 22, 2026 · 21:56

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

Scaling Agents on Kubernetes with acpx and ACP — Onur Solmaz, OpenClaw

May 21, 2026 · 19:00

Onur Solmaz, a founding engineer at textcortex and OpenClaw maintainer, built acpx, a headless CLI for the Agent Client Protocol (ACP), to automate processing of 300–500 daily AI-generated pull requests on OpenClaw. He replaces manual PTY scraping with structured agent-to-client communication, driving Codex sessions through a node-based workflow: reproduce the bug, judge the implementation, check for conflicts, run a review loop, and emit structured JSON. Solmaz runs parallel Codex sessions from five Discord channels while traveling, one channel per task. He also presents an open-source Kubernetes operator called Spritz (from textcortex) that provisions disposable full-compute pods per task, wires them into Slack, and tears them down when work is done, advocating for on-demand disposable agents over persistent chat apps.

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.

Malleable Evals: Why Are We Evaluating Adaptive Systems with Static Tests? — Vincent Koc, OpenClaw

May 12, 2026 · 15:05

Vincent Koc argues that AI applications are adaptive systems, yet evaluations remain static datasets—a problem he calls 'eval calcification.' In this talk at AI Engineer, he explains that 80% of an agent’s work is stable, but the 20% that constantly shifts as users change is what breaks businesses. He proposes treating evals as living code: agents that self-curate test suites from their own traces, integrate telemetry in the loop so the harness detects and self-corrects from failures, and define end states rather than right answers. Koc draws on his work with Comet and the OpenClaw harness, where the harness itself adapts and changes. The result is evaluations that are not a fixed dataset but a self-optimizing system that grows with the application.

A Piece of Pi: Embedding The OpenClaw Coding Agent In Your Product — Matthias Luebken, Tavon

May 11, 2026 · 20:42

Matthias Luebken explains how to embed Pi, the minimal coding agent SDK from OpenClaw, into real products, arguing that the key architectural principle is to make systems easy for agents. He demonstrates a B2B sales pipeline application where incoming RFP emails are routed to customer-specific agent sessions, CLIs expose CRM and ERP data cleanly, and the only human output is a draft in the user's inbox. The agent is purely an LLM calling tools in a loop, with Pi's extensions enabling UI interactions and session management. Luebken emphasizes that coding agents will become core building blocks for software, and Pi's minimal design is ideal for tinkering and learning.

Viktor: AI Coworker That Lives in Slack — Fryderyk Wiatrowski

May 11, 2026 · 19:30

Fryderyk Wiatrowski, co-founder of Viktor, explains how his AI employee lives in Slack—no web UI—participating in channels and threads like a teammate, inheriting integrations from whoever connected them first, and handling tasks that take ten minutes. He details the challenges of scaling a personal agent to a company agent: memory management across hundreds of users, managing Slack's complex input surface (threads, DMs, edits, emoji reactions), and preventing context leakage between channels. He shares that swapping the underlying model from Opus to GPT-5.4 caused user backlash due to personality differences, and describes the need to earn proactivity trust to avoid security alarms. Viktor's advantage is shared context—only one person needs to connect an integration for the whole team—but warns against giving it personal email access, as illustrated by a customer story. The episode argues that a great AI coworker requires helping get work done, knowing the company context, and being friendly.

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.

I Gave an AI Agent the Keys to My Life (Here's What Happened) — Radek Sienkiewicz (@velvetshark-com)

May 2, 2026 · 19:34

Radek Sienkiewicz, maintainer of OpenClaw, details how he incrementally gave his AI agent full control over his digital life—from reading files to handling emails, backing up memory at 4am, and drafting business replies. Starting with a single chat channel, he expanded trust step by step, integrating his 3,000-page Obsidian vault for search and memory. The agent now performs ambient operations (overnight updates, indexing), attention filtering (flagging Netflix payment failures, domain renewals), and execution support (drafting email replies) via dedicated Discord channels. Challenges include bad memory compounding, brittle automations, and noisy nodes, which he addresses by keeping the system inspectable in markdown files. The philosophy: optimize for your future self by starting with one pain, growing trust incrementally, and building a knowledge base in markdown.

Agents on the Canvas in tldraw — Steve Ruiz, tldraw

May 1, 2026 · 19:54

Steve Ruiz of tldraw details the evolution of AI on the infinite canvas, from early one-shot demos like MakeReal (draw to functional prototype) to multi-agent 'fairies' that collaborate, delegate, and even rewrite the canvas in real time. He explains how the tldraw SDK enables agents to act as virtual collaborators, using structured outputs and tool use to draw, animate, and modify designs. Ruiz demonstrates fairy agents that can work independently or in leader-follower mode, coordinating on tasks like creating wireframes or filling out forms. He also unveils a desktop prototype that lets Claude directly inject JavaScript into the canvas, enabling agents to edit code, modify UI, and even hack other apps like Spotify. The talk emphasizes the shift from sidebar agents to canvas-native collaborators, the challenges of vision model training for 2D spaces, and the safety trade-offs of giving LLMs runtime access in local-first apps.

Building Conversational Agents — Thor Schaeff and Philipp Schmid, Google DeepMind

Apr 30, 2026 · 1:47:34

Thor Schaeff and Philipp Schmid of Google DeepMind demonstrate building conversational agents with the Gemini Interactions API and Live API, arguing that the new Interactions API simplifies agent development by introducing server-side state management, unified content blocks, and remote MCP support. They walk through creating a coding agent with read/write file and bash tools using Gemini 3 Flash, highlighting how the model uses tool calling to execute commands and return results. The Live API, powering real-time voice and video interactions, supports native multilingual audio, tool calling, and Google Search grounding, though the presenters acknowledge its current limitations in production, including lack of session transcript retrieval and shorter context windows (15 minutes audio-only). They showcase a Live Jukebox demo integrating Lyria 3 music generation and discuss business use cases like Shopify Sidekick, Waymo, and elderly companion apps, emphasizing that while the technology is ready for experimentation, production readiness depends on partner integrations for observability and compliance.

Build & deploy AI-powered apps — Paige Bailey, Google DeepMind

Apr 29, 2026 · 1:03:20

Paige Bailey, engineering lead for developer relations at Google DeepMind, demonstrates how the company's latest multimodal models and AI Studio platform enable rapid prototyping of AI-powered apps at minimal cost. She showcases Gemini 3.1 Flash Lite analyzing YouTube dinosaur videos for under a penny, the new Build feature constructing a fully functional bookshelf cataloger with Firebase database and Google login, and Gemini Live providing real-time multilingual screen interaction. Other demos include Genie 3 generating playable world models from text prompts, NanoBanana 2 performing cost-effective image editing, Veo 3.1 Lite producing stock footage (e.g., a "vegan basketball food truck" featuring Chef Curry), Lyria 3 creating custom music tracks, and Gemma 4 offering open-source multimodal models that run on mobile devices. Bailey emphasizes that the entire stack—grounded by Google Search and code execution—allows developers to ship ideas that would have been startups years ago, with all code exportable for production use.

AgentCraft: Putting the Orc in Orchestration — Ido Salomon

Apr 25, 2026 · 11:18

Ido Salomon, creator of AgentCraft, argues that the bottleneck in multi-agent orchestration is not the agents but the humans managing them, and that the skills needed—borrowed from real-time strategy games—are already familiar to gamers. AgentCraft visualizes agents as physical units on a map that projects the file system, allowing users to see which files agents modify and detect collisions via a heat map. To reduce babysitting, Salomon implemented a campaign feature where agents autonomously decompose tasks and plan within containers, shifting the human role to review. Review bundles present changes with screenshots and videos for efficient inspection. Workspaces enable real-time collaboration between humans and agents across teams, with shared visibility and soft coordination. The goal is to raise the ceiling of collaboration through visibility, autonomy, and human-agent interaction.

The End of Apps — Kitze, Sizzy.co

Apr 23, 2026 · 20:18

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

The New Application Layer - Malte Ubl, CTO Vercel

Apr 20, 2026 · 18:52

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

State of the Claw — Peter Steinberger

Apr 17, 2026 · 44:12

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

Building pi in a World of Slop — Mario Zechner

Apr 16, 2026 · 18:25

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

Paperclip: Open Source Human Control Plane for AI Labor — Dotta Bippa

Apr 15, 2026 · 24:34

Dotta Bippa introduces Paperclip, an open-source human control plane for AI labor that lets you manage an org chart of agents to run a zero-human company. The tool enables you to hire employees, set goals, automate jobs, and bring your own agent (e.g., Gemini, Claude, Codex) with skills and instructions. Paperclip supports reliable workflows like QA reviews and approvers, and routines for recurring tasks such as summarizing PRs or writing changelogs. Dotta demonstrates creating a Remotion video celebrating Paperclip's 40,000 GitHub stars (now 50,000) by instructing the CEO agent to hire a video writer and apply brand guidelines—something that would have taken a week becomes an afterthought. Paperclip is not just for coding; it handles marketing, sales, and finance. Upcoming features include CEO chat, maximizer mode, multi-user support, cloud deployments, and a desktop app, all aimed at giving humans control over AI labor.

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

Apr 8, 2026 · 11:31

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

Why, and how you need to sandbox AI-Generated Code? — Harshil Agrawal, Cloudflare

Apr 8, 2026 · 38:27

Harshil Agrawal (Cloudflare) argues AI-generated code is untrusted and must be sandboxed via capability-based security (default deny, explicit allow) against hallucinations, over-helpful LLMs, and prompt injection. He details two approaches: isolates for fast lightweight tasks (e.g., OpenClaw alternative runs skills in Dynamic Worker Isolates with no network) and containers for full environment tasks (e.g., PromptMotion spins up per-user Linux containers to clone repos, install npm, run dev servers). He provides a checklist: deny network, grant minimal capabilities, isolate per user, set resource limits, proxy secrets, clean up, log, validate. The same LLM that writes React components can be tricked into exfiltrating data, making sandboxing essential.

Agentic Engineering: Working With AI, Not Just Using It — Brendan O'Leary

Apr 7, 2026 · 27:03

Brendan O'Leary, a Developer Relations Engineer at Kilo Code, argues that agentic engineering means shifting from using AI as a tool to working with it as a collaborator—like an energetic but inexperienced junior developer. He explains that context engineering—managing what goes into the model's context window—is critical, as too much or bad context degrades output quality. O'Leary recommends a research-plan-implement loop: first understand the system without writing code, then create a detailed plan, and finally execute in a fresh session to keep context lean. He advocates for configuring agents with role-based modes (Ask, Architect, Code), along with agents.md and skills files for persistent rules and reusable workflows. O'Leary also cautions against overusing MCP servers, which add token cost and can confuse the agent, and suggests isolating agent work via Git for easy review. The episode emphasizes that AI cannot replace thinking—it only amplifies the human's preparation and judgment.