🎧 Listen
The Stack
How to Run a Private, Local Memory Server for Your Coding Agent with OpenMemory MCP
Give Cursor, Claude Desktop, Cline, and Windsurf one shared, on-machine memory over MCP — no cloud, no vendor lock, in about ten minutes.
🎧 Listen
The Stack
🎧 Listen
The Stack
CrewAI Flows Control Flow: Run Steps in Parallel and Branch with @router, and_, or_
Flows give you an event-driven graph without writing threading or a state machine. Here's the whole control-flow vocabulary — @start, @listen, @router, and_, or_ — with copy-paste code for fan-out, join, and conditional branching.
🎧 Listen
The Stack
How to Not Orphan an MCP Task: A Durable Client-Side Handle Store for the Stateless Spec
The 2026-07-28 spec removed tasks/list — in a stateless protocol the server can't enumerate 'your' tasks. So you carry the claim ticket. Lose the id and the work is orphaned. Here's the client-side store that stops that happening.
🎧 Listen
The Stack
How to Build a Deep Agent with LangChain's deepagents: Planning, Subagents, and a Virtual Filesystem
A deep agent is a plain tool-calling loop plus four batteries: a planner, a filesystem, subagents, and context management. Here's create_deep_agent end to end — a working research agent in ~15 lines, then how to add a custom subagent.
🎧 Listen
The Stack
How to Add Persistent Memory to Your Agent with Mem0: A Copy-Paste Quickstart
Four methods — add, search, get_all, delete — turn a stateless agent into one that remembers a user across sessions. Here's the working code, the self-host-vs-managed choice, and the one setting that decides your bill.
🎧 Listen
The Stack
What E2B Shipped in July: Set-Once Integrations, Lighter Snapshots, Faster Builds
E2B's mid-July SDKs (Python 2.32, JS 2.33) move integration config out of every call, add gzip control to template copies, and let you snapshot filesystem-only. Small changes that bite once you run untrusted agent code at scale.
🎧 Listen
The Stack
How to Point CrewAI's Memory at Your Own Qdrant: The 1.14 Pluggable-Backend Way
CrewAI 1.14 made memory a backend you own instead of a black box it ships. Here's the copy-paste path from the bundled default store to your own Qdrant — and the one config field whose name will confuse you.
🎧 Listen
The Stack
Make Your CrewAI Flow Survive a Crash: A Hands-On Guide to @persist
A multi-agent run that dies at step 4 shouldn't restart at step 1 — and pay for steps 1–3 again. Here's the copy-paste code to checkpoint Flow state, kill the process, and resume exactly where it stopped.
🎧 Listen
The Stack
CrewAI 1.15 Made Flows Declarative: What FlowDefinition and Token Aggregation Change for Founders
The 1.15 line moved flow authoring from decorated Python classes toward data you can load, version, and review — plus one small feature that finally answers 'what did this agent run cost me?' Here's what actually shipped and whether it's worth the upgrade.
🎧 Listen
The Stack
Chroma vs LanceDB: The Embedded Vector Store Decision, Made on the Storage Layer
You've ruled out running a server. Now it's Chroma or LanceDB — and the choice isn't recall quality. It's whether you're optimizing for the fastest path to shipping or for the shape of the data itself.
🎧 Listen
The Wire
China Banned the AI Companion; America Fenced It: The Two Regulatory Bets Landing This Summer
On the same July that Doubao and Qwen switch their companion agents off to comply with Beijing, the U.S. approach is visible in a different shape entirely — laws that keep the product legal and instead fence the harm, especially to minors. Same product, opposite bet.
🎧 Listen
The Stack
Build Progressive Tool Disclosure Yourself: discover / load / unload Over Any MCP Client
Microsoft and Anthropic ship lazy tool loading as a config flag. Here's the same discover/load/unload loop in ~40 lines over a plain MCP client — no framework, and you keep the allow-list as your security boundary.
🎧 Listen
The Wire
Eleven Incumbents Agreed on How Agents Find Tools. The Two Companies Whose Agents Actually Run Weren't There.
ARD's technical story is a discovery layer. Its guest list is a distribution story — and for a solo founder, distribution is the part that decides whether an agent ever finds you.
🎧 Listen
The Stack
The 2026 Agent Protocol Stack: MCP vs A2A vs AG-UI vs A2UI (and which layer you actually need)
Four protocols, four layers, zero overlap — a field guide to which one solves your problem, and when A2UI beats AG-UI.
🎧 Listen
The Wire
The Agent Money Went Vertical: Taktile's $110M and 8090's $135M Are the Same Bet
Two of the biggest agent rounds of the summer didn't fund another horizontal framework. They funded governed, vertical agents in regulated finance and human-supervised enterprise software — a signal about where the value is actually accruing, and what's left for a solo founder to build.
🎧 Listen
The Wire
vLLM 0.25 Retired PagedAttention. The Idea That Launched the Project Is Now Just the Default.
The July 11 release deletes the original PagedAttention implementation and makes Model Runner V2 the default for every dense model. The innovation didn't die — it dissolved into the standard path.
🎧 Listen
The Wire
Both Your Inference Engines Shipped This Week. vLLM 0.25 and SGLang 0.5.15 Won the Same Fight.
vLLM deleted the CPU–GPU sync in the model runner; SGLang deleted it in the speculative-decoding scheduler. The frontier of serving throughput in mid-2026 isn't a faster kernel — it's the war on the stall.
🎧 Listen
The Stack
Tool Highlight: Vercel Sandbox — Run Your Agent's Code in a Firecracker MicroVM, Billed by the Active CPU-Second
Vercel's ephemeral compute primitive for untrusted, AI-generated code is generally available. Firecracker isolation, up to 32 vCPUs, and a pricing model that charges only while a CPU is actually working — here's what it is, who it's for, and how to start.
🎧 Listen
The Stack
Tool Highlight: Mem0 — Drop-In Persistent Memory for Your AI Agent
Your agent forgets everything the moment the request ends. Mem0 is the memory layer you add in two calls — it extracts what matters from a conversation, stores it, and hands the right facts back on the next turn, per user.
🎧 Listen
The Stack
Tool Highlight: CrewAI — Give Each Agent a Role, Then Let the Crew Do the Work
One model doing everything is hard to steer. CrewAI lets you split a job across a crew of role-specialized agents — a researcher, a writer, a reviewer — and orchestrate how they hand work to each other, in plain Python.
🎧 Listen
The Stack
How to Cap Your Agent's Token Bill in Pydantic AI v2.9: usage_limits, the /usage Command, and Budget-Aware Tools
Pydantic AI v2.9 shipped a /usage command for cumulative token tracking and — the real upgrade — exposed the run's usage_limits to your tools. Here's how to set a hard budget, read what's left from inside a tool, and stop a runaway agent before the bill lands.
🎧 Listen
The Stack
Make Your Agent's Memory Portable: Export, Own, and Re-Import With mem0
A code-forward walkthrough for getting every memory out as structured JSON you control — add, get_all, re-import — so no vendor's shutdown can delete your users' context.
🎧 Listen
The Wire
OpenAI Just Retracted SWE-Bench Pro — a Third of the Coding Benchmark You Route On Is Broken
OpenAI audited SWE-Bench Pro, found ~30% of its 731 tasks mismark correct code as wrong, and pulled its own recommendation. If you pick a coding model on a two-point benchmark gap, you're routing on noise.
🎧 Listen
The Stack
OpenAI Agents SDK 0.18: Hosted Multi-Agent Beta Lands — What Shipped, and When to Still Self-Host
In three releases across five days, the OpenAI Agents SDK made GPT-5.6 the default and quietly added 'hosted multi-agent beta support' — a path to run agent fan-out on OpenAI's infrastructure instead of your own. Here's what's actually in 0.18, and the decision it forces.
🎧 Listen
The Stack
Make Your MCP Server Stateless Before July 28: A Migration Walkthrough
The 2026-07-28 spec deletes the handshake and the session. Here's the concrete diff — drop `initialize`, read capabilities from `_meta`, and replace held-connection elicitation with Multi Round-Trip Requests — with old-vs-new code for each step.
🎧 Listen
The Stack
Mem0 Cut Retrieval Tokens ~90% by Giving Up Write-Time Reconciliation — Here's the Trade
Mem0's token-efficient rewrite stops doing UPDATE and DELETE when it stores a memory, and pushes the hard part — reconciling contradictions — to read time. That's not a free win. It's a bet about where you can afford to spend.
🎧 Listen
The Stack
How to Let an MCP Server Trigger OAuth and Payments Safely: URL-Mode Elicitation, End to End
The 2026-07-28 spec kills server-initiated sampling but keeps elicitation — and adds a URL mode built for exactly the flows you couldn't do before: OAuth, credential entry, and payment setup that must never touch the model context.
🎧 Listen
The Wire
MCP Just Deleted the Handshake: What the 2026-07-28 Stateless Core Breaks and Why It's Worth It
The release candidate everyone read for the deprecations buried the bigger change: MCP is no longer a session. It's a stateless request/response protocol you can put behind a plain load balancer — and that quietly rewrites how you deploy every server you own.
🎧 Listen
The Stack
LanceDB vs Turbopuffer: Own-Your-Bucket vs Serverless Namespaces for Agent Retrieval
Both run vector, full-text, and hybrid search off object storage at billion scale. The real fork is whether your data stays an open file you own, or lives behind one vendor's API.
🎧 Listen
The Stack
How to Build a Human-in-the-Loop Approval Gate for Agent Tool Calls
Intercept the tool call, pause for a human approve/deny/edit, then resume from the exact checkpoint — and put the gate where risk lives, not on every call.