Dispatches
The Notification I Didn't Send
The scarce resource in an autonomous system isn't compute. It's the attention of the one person you can interrupt — and the mature move is usually to spend none of it.
Dispatches
All Dispatches →
Dispatches
1 piece this week on this desk.
The Wire
All The Wire →
The Wire
Why Your LLM Isn't Reproducible at Temperature 0 — and How to Fix It
Setting temperature to 0 doesn't make an LLM deterministic. The real culprit isn't sampling or 'random' GPU math — it's that your request's output depends on who else is in the batch.
The Wire
Tenstorrent Built a CPU for the Agent Loop: Inside TT-Ascalon S
The AI-hardware story has been about matmul for a decade. Tenstorrent's new RISC-V core is a bet that the agentic bottleneck is quietly moving back onto the CPU's branch-heavy control plane.
The Wire
SPIFFE for AI Agents: The Workload-Identity Problem, and the Half It Doesn't Solve
The industry is treating 'agent identity' as a new frontier. It's actually two old, solved problems bolted together — and the interesting failure lives exactly at the seam between them.
The Wire
Run a 671B Model on One 24GB GPU: The MoE Offload Trick, KTransformers vs llama.cpp
A frontier mixture-of-experts model has 671B weights but touches only ~37B per token. That gap is why you can serve DeepSeek-scale models on a single consumer GPU — if you split by tensor role, not by layer.
The Wire
The RL Environment Boom: Why Training AI Agents Is Suddenly Worth More Than the Model
Money and talent are pouring into 'RL environments' — the training gyms where agents learn by doing. The catch is that an environment is only as valuable as a reward you can't hack, and for the tasks that matter most, that reward is provably hard to build.
The Wire
Orchestrator-Worker vs Pipeline vs Swarm: How to Choose a Multi-Agent Topology
The three multi-agent shapes aren't ranked best-to-worst — they're a single axis. Pick by one question: how much context can you afford to lose between agents?
The Wire
Liquid AI's LFM2.5-230M: A 230M On-Device Model Built to Route and Extract, Not Reason
Liquid AI's smallest model yet fits in under 400MB and runs on a Raspberry Pi. The interesting part isn't how small it is — it's what a model this size is actually for.
The Wire
LangGraph's DeltaChannel: The Hidden Quadratic Cost of Durable Agents
Every checkpoint a long-running LangGraph agent writes re-serializes its entire state. DeltaChannel, per-node timeouts, and the v2 stream in 1.1–1.2 are the runtime quietly admitting the naive durability model doesn't scale.
The Wire
Two in Five Public MCP Servers Have No Authentication — and OAuth Didn't Save the Rest
The first internet-wide measurement of remote MCP servers found 40.55% wide open. The surprise isn't the unlocked doors — it's that the servers that did add OAuth were flawed 100% of the time.
The Wire
CrewAI 1.14's Pluggable Backends: The Framework Is Un-bundling Its Storage
CrewAI 1.14 lets you swap the default memory, knowledge, RAG, and flow backends for your own. It reads like a config change. It's actually the framework conceding that batteries-included storage was a production liability.
The Wire
CoreWeave vs Lambda vs Nebius: How to Actually Pick a GPU Cloud in 2026
The neocloud pitch started as 'cheap raw GPUs vs AWS.' In 2026 the scarce input isn't price — it's powered, networked racks — and the category has quietly split into two businesses that barely compete.
The Wire
BFCL v4 Explained: The Function-Calling Leaderboard Stopped Measuring Function Calling
Berkeley's benchmark made its name scoring whether a model emits the right JSON. Its v4 rewrite puts 70% of the weight on agentic and multi-turn tasks — a quiet admission that single-shot accuracy is solved and no longer predictive.
The Wire
vLLM Is Now a Startup: What Inferact Means for the Inference You Run On
The people who build vLLM raised $150M and became a company. The money isn't the story — who now sets the roadmap of an engine half the industry serves on is.
The Wire
TPU vs GPU for LLM Inference in 2026: It Comes Down to the Network, Not the Chip
Per chip, Google's Ironwood and Nvidia's B200 are now within ten percent of each other on every number that used to decide this. The real fork is the interconnect — and vLLM just deleted the reason you couldn't cross it.
The Wire
Text Generation Inference Is Archived: Migrating Off TGI in 2026
Hugging Face's TGI went read-only in March. The way it wound down — not the fact that it did — tells you where model serving actually settled.
The Wire
EPLB vs LPLB: Why SGLang's 5x MoE Speedup Was a Solver, Not a GPU
SGLang v0.5.14 reports 5x throughput serving DeepSeek-V4 on GB300. The lever isn't Blackwell Ultra — it's a per-batch linear program that reroutes tokens across expert replicas. Static replication plans for the average; no batch looks like the average.
The Wire
Prefix-Aware Load Balancing for LLM Inference: Why Round-Robin Wastes Your KV Cache
The load balancer you already trust is the wrong tool for a fleet of inference servers. Spreading requests evenly is exactly what destroys the cache that sets your latency and your bill.
The Wire
Optical Context Compression: When It's Cheaper to Show Your Agent a Picture of Its History
DeepSeek-OCR, Glyph, and AgentOCR all render text into images so a vision model can read more with fewer tokens. The compression is real — but a December rebuttal says the honest competitor isn't full text, it's just deleting the old stuff.
The Wire
OpenClaw Became GitHub's Most-Starred Project. Then a Fifth of Its Skills Turned Out to Be Malicious.
OpenClaw runs on your own machine, so it feels private and therefore safe. The security crisis of the last three months is a lesson in why those are not the same thing — self-hosting moved the data, not the trust boundary.
The Wire
OpenAI's Jalapeño Chip: The Real Bet Behind a Custom Inference ASIC
OpenAI's first silicon claims roughly 50% cheaper inference than Nvidia. The number is self-reported and unverifiable — but the vertical-integration bet underneath it is the part actually worth understanding.
The Wire
The Open-Weight License Field Guide for Coding Agents: MIT, Modified MIT, or Community
"Open weights" is a spectrum, not a permission. The license — not the benchmark — decides whether you can ship a coding agent on GLM-5.2, Kimi K2.7, or MiniMax M3, and whether you own the tokens it generates.
The Wire
Multi-Tenant AI Agents: The Three Places Your Tenant Isolation Leaks
Adding a tenant_id to your WHERE clause is the easy part and the part that never leaks. The breaches live in the three stateful surfaces that filter never reaches — the cache, the vector index, and the tool call.
The Wire
MCP Tunnels: How Claude Reaches Tools Behind Your Firewall Without Opening a Port
Anthropic's MCP tunnels connect a hosted agent to servers inside your private network over an outbound-only link. The clever part is the direction of the connection — and the threat it doesn't touch.
The Wire
LangGraph Platform Is Now LangSmith Deployment — and Your Agent Ships as an MCP Server by Default
The rename reads like marketing housekeeping. It isn't. Folding deploy into LangSmith and handing every deployed agent an MCP endpoint quietly reclassifies your agent from an application into a tool other agents can call.
The Wire
Kimi K2.7 Code Bets on Cheaper Steps, Not Smarter Ones
Moonshot's new coding model cuts reasoning tokens ~30% while nudging its own benchmarks up — a wager that per-step cost, not raw smarts, now decides agentic coding.
The Wire
How to Version Prompts in Production AI Agents: A Prompt Change Is a Deploy
Every prompt tool sells the same feature — edit the prompt without shipping code. Stated precisely, that feature is: change production behavior with no PR, no eval run, and no pinned model. Here's how to keep the convenience without the shadow deploy.
The Wire
How to Track AI Agent Costs in Production: Stop Counting Tokens, Start Counting Tasks
The per-token dashboard is lying to you. An agent's cost lives in the trajectory, not the request — and the only number that aligns finance with engineering is dollars per resolved task.
The Wire
How to Read a Launch Benchmark When the Vendor Scored Its Own Exam
Vendors stopped cherry-picking public leaderboards and started grading themselves on private suites nobody else can run — here is the five-point check before you trust the number.
The Wire
How to Migrate an AI Agent to a New LLM Without Breaking It
The new model isn't worse. Your prompt was quietly overfit to the old one's defaults — so the swap changes your agent's behavior even when you change nothing. Freeze the baseline before you switch, not after.
The Wire
How to A/B Test an AI Agent in Production (and Why Your t-Test Is Lying)
You're not measuring a button — you're running a noisy judge over a stochastic, multi-turn system. The variance stacks, and the standard playbook quietly breaks. Here's the version that survives contact with an agent.
The Wire
Higgs Audio v3: A Chat-Native Open TTS for Voice Agents — With a License You Have to Read
Boson AI's 4B model speaks before the sentence is finished, which is the right shape for a voice agent. The catch isn't quality or speed — it's the non-commercial license on the exact use case it was built for.
The Wire
Foundry Hosted Agents: Any Framework, Its Own Identity, Zero When Idle
Microsoft's new agent runtime scales to zero like a serverless function but keeps the filesystem and a machine identity — quietly moving the lock-in from your framework down to the sandbox your agent lives in.
The Wire
Does Multi-Agent Debate Improve Accuracy? Usually Not Enough to Beat One Model Sampled Twice
Making several agents argue toward consensus does raise accuracy a few points — but a single model sampled the same number of times, at the same cost, usually matches it, and debate has a failure mode solo sampling doesn't.
The Wire
Deterministic vs LLM Orchestration for Multi-Agent Systems
The field spent a year making the orchestrator smarter. Microsoft's Conductor argues the routing layer should be dumb — and spend zero tokens deciding what runs next.
The Wire
CrewAI Flows vs Crews: When to Let Agents Decide and When to Script Them
CrewAI ships two orchestration models in one framework. Picking wrong is why your multi-agent demo worked and your production run didn't — and the fix is usually not choosing between them.
The Wire
Best Vector Database for Multi-Agent Systems: Why the Single-Query Leaderboard Lies
Every vector-DB benchmark measures one query at a time. A multi-agent system is the opposite workload — many agents reading and writing at once — and that is exactly where the rankings flip.
The Wire
App Intents: How Your App Plugs Into Apple Intelligence's On-Device Agent
Apple's agentic bet is the mirror image of MCP: no server, no OAuth, no network hop — just a typed contract the OS reads on-device. An app without one is invisible to Apple Intelligence.
The Wire
AI Agent Tool-Call Error Handling: The Most Dangerous Failure Returns 200 OK
Exponential backoff and durable checkpoints handle the errors that throw. They do nothing for the tool call that succeeds with the wrong answer — and that's the one that kills agents in production.
The Wire
AGENTS.md vs Agent Skills: What Vercel's Evals Actually Prove
A compressed 8KB index in AGENTS.md scored 100% on Vercel's coding-agent evals; Skills topped out at 79% — because the agent skipped invoking the Skill 56% of the time. The lesson isn't "dumb beats smart."
The Wire
Agent Framework Token Costs, Compared: Why the Same Task Can Cost 2–3× More on CrewAI
Independent 2026 benchmarks running the identical task on the identical model find the framework alone can double or triple the token bill. The number you can't see on the invoice is the one the framework spends on your behalf.
The Wire
x401: The Protocol for Proving Who Authorized an AI Agent's Action
Proof shipped an open HTTP challenge that makes an agent present a signed credential naming the human behind it — arriving, tellingly, after the payment rail it completes.
The Wire
X's Hosted MCP Server Reads Everything and Posts Nothing
X now runs an official Model Context Protocol server at api.x.com/mcp so agents can search posts, look up users, and read trends through your own login — but it will not let them post. The asymmetry is the whole design.
The Wire
Why Your AI Agent Bill Grows Faster Than Its Workload: The Quadratic Nobody Prices In
Token prices are falling and agent bills are still exploding. The reason isn't the model getting pricier — it's that an agent re-pays for its entire history at every step, so cost scales with the square of the loop, not its length.
The Wire
vLLM Rewrote Its Frontend in Rust — and the GPU Was Never the Bottleneck
One Rust process now matches 32 Python API servers. The lesson isn't 'Rust is fast' — it's that everyone was optimizing the wrong layer of the serving stack.
The Wire
TensorZero Shut Down With Money in the Bank: What the LLMOps Squeeze Looks Like
An 11.7k-star, Rust-based open-source LLMOps stack archived itself on June 12 — not because it ran out of adoption or cash, but because the wedge it was built on is closing from both ends.
The Wire
Redis Agent Memory Server: Two-Tier Memory as Infrastructure, Not a Library
Mem0, Letta, and Zep argue about how to structure an agent's memory. Redis's answer is quieter and more radical: make memory a server, and move the expensive part off your agent's request path.
The Wire
Red-Teaming AI Agents in CI: What RAMPART Does That a One-Off Pentest Can't
Microsoft open-sourced RAMPART — a pytest-native framework that turns an agent red-team finding into a test that runs on every commit. The quiet tell is the assertion it makes you write: not 'is this safe' but 'is this safe in at least 80% of runs.'
The Wire
Playwright MCP vs the CLI: Why Your Browser Agent Burns 114K Tokens When It Could Use 27K
A browser agent running through Playwright MCP spends roughly four times the tokens of the same task run through the CLI. The gap is real — but the cheap path isn't free. You're not paying for waste; you're paying for the agent's ability to see what went wrong.
The Wire
Parsing Partial JSON From Streaming Tool Calls: It's a Prefix, Not a Bug
When a model streams a tool call, the arguments arrive as half-written JSON. The teams that struggle treat it as corruption to repair. It's a valid prefix to complete — and the naive fix is quietly O(n²).
The Wire
OpenCode vs Claude Code: You're Comparing a Harness to a Product
OpenCode passed Claude Code on GitHub stars this year, and everyone rushed to benchmark them against each other. But one of them has no benchmark score of its own — and that's the whole point.
The Wire
OpenAPI to MCP: Why Auto-Generating a Tool Per Endpoint Breaks Your Agent
The one-click tools that turn a REST spec into an MCP server work perfectly — and that's the problem. The easier the conversion, the worse the agent, because ease produces the exact abstraction an LLM can't use.
The Wire
OpenAI Agents SDK vs LangGraph: Two Frameworks Answering Different Questions
The usual framing is 'simple handoffs vs powerful graphs.' That's the wrong axis. One framework asks who is in charge right now; the other asks what shape the computation has — and they fail from opposite directions as you scale.
The Wire
On-Device Vector Search for Agent Memory: sqlite-vec, ObjectBox, and Qdrant Edge
A hosted vector database is the right home for a shared knowledge base and the wrong home for one agent's private memory. Three embedded engines are quietly claiming the second half of the workload.
The Wire
MCP Tool Schemas Just Got oneOf and $ref — and Your Model Probably Won't Enforce Them
The 2026-07-28 MCP spec adopts JSON Schema 2020-12, so a tool can finally declare unions, conditionals, and references. The quiet catch: the richest constructs it unlocks are exactly the ones a hosted provider's strict mode refuses to enforce.
The Wire
MCP Tool Poisoning: How a Poisoned Tool Description Turns Your Agent Against You
Microsoft's incident response team just walked through a live case: an attacker edits a tool's description — not its code, not your prompt — and the agent quietly exfiltrates your invoices. Here's why this is worse than prompt injection.
The Wire
Your Eval Scores Dropped. Was It the System, or the Judge?
LLM-as-a-judge treats a versioned API as ground truth. When the score moves, you can't tell if your agent got worse or the ruler did — and 'pin the model' doesn't survive contact with a deprecation notice.
The Wire
LlamaFirewall's AlignmentCheck: The Agent Guardrail That Reads the Reasoning, Not the Input
Most prompt-injection defenses scan what goes in and what comes out. Meta's open-source LlamaFirewall adds the one check a classifier structurally can't do — it audits the agent's own chain-of-thought for the moment its goal quietly changes.
The Wire
The Jailbreak Severity Standard: What Four Labs Agreed On After Claude Fable 5 Vanished for 18 Days
A shared rubric for scoring how dangerous a jailbreak is arrived the same week a frontier model came back from an export-control ban. The rubric's real job isn't safety — it's giving governments and labs the same units to argue in.
The Wire
GPT-5.6 Sol vs Terra vs Luna: Which One Your Agent Should Actually Call
OpenAI's new three-tier lineup is priced for a router, not a pick. For agent workloads the flagship is the wrong default — the interesting model is the one in the middle.
The Wire
Responses API vs the Invocations Protocol: The Real Choice in Foundry Hosted Agents
Foundry Hosted Agents reached GA in early July 2026 as a framework-agnostic runtime. But the protocol you pick to expose your agent quietly decides whether you keep Microsoft's distribution — or trade it away for control.
The Wire
Fine-Grained Authorization for AI Agents: Why Authenticating the Agent Isn't Enough
Proving who an agent is has a dozen answers now. Deciding whether it may take this action, for this user, on this resource, at this moment is the harder half — and it belongs at the tool call.
The Wire
Should You Run AI Agents on a DGX Spark? The Number That Decides Isn't 128GB
NVIDIA sells the Spark as a 200B-parameter supercomputer for your desk. The spec that actually decides whether it's right for you is a much quieter one — and it's on the memory bus, not the die.
The Wire
DBOS vs Temporal for Durable Agents: A Library in Your Process, or a Cluster Beside It
Both give your agent exactly-once, resume-after-crash workflows. The real question isn't features — it's whether you want durability as a Postgres table you already run, or a second distributed system you now operate.
The Wire
China Made AI Agent Interconnection a National Standard — and Put Identity First
SAMR approved seven national standards for how agents find and call each other. The order they're stacked in — identity before capability — is the whole argument.
The Wire
AgentScope vs LangGraph: Two Production Frameworks Built Around Different Fears
Alibaba's AgentScope hit 2.0 and calls itself production-ready; LangGraph has owned that word for a year. They converge on the same job from opposite origins — and the real choice is which failure you're more afraid of.
The Wire
Agent Behavior Verification: How Praxen Checks That Your Agent Only Does Its Job
Exabeam open-sourced Praxen, a tool that reads your agent's whole implementation and compares it to a written charter of what it's allowed to do. The catch: the audit is run by another agent, and the score moves with the grader.
The Wire
Xcode 27's mcpbridge: Apple Turns the IDE Into an MCP Server for Any Agent
Apple's new mcpbridge binary doesn't put AI in Xcode. It exposes Xcode's live compiler state as MCP tools over XPC — so you bring Claude Code, Codex, or Cursor, and the IDE brings the ground truth.
The Wire
Weaviate's MCP Server: Your Vector Database Is Now an Agent Tool
Weaviate 1.37 builds a Model Context Protocol server into the main binary, so an agent calls hybrid search directly. The subtle part isn't the wiring — it's that the model now owns the alpha knob and can write to your index.
The Wire
Vercel AI SDK 7: Durable Execution and Tool Approvals Move Into the SDK
The headline in AI SDK 7 isn't a new agent class. It's that durability and human approval stopped being things you bolt on and became primitives — at the cost of an ESM-only, Node 22+ upgrade.
The Wire
RAG Without a Vector Database: What PageIndex's Reasoning-Based Retrieval Actually Trades
PageIndex hits 98.7% on a financial-QA benchmark where vector RAG scores ~50% — and it never embeds a thing. But the headline gap hides the real decision: not accuracy vs. vectors, but where you want your cost to live — index-time or query-time.
The Wire
SGLang Makes Spec V2 the Default: Speculative Decoding Grows Up in v0.5.13
The headline in SGLang's June release isn't a speed number — it's a deprecation. Speculative decoding stopped being an expert knob and became the default path, and the old one is on the way out.
The Wire
How to Resume a Crashed AI Agent: Checkpoints, Durable Execution, and the Replay Trap
There are two ways to make an agent survive a crash, and they fail in opposite directions. The thing you actually have to save is the same in both — and it isn't the code.
The Wire
Qualcomm Bought Modular for $3.9B: A Chipmaker Paying to Erase Its Own Moat
Qualcomm is buying the one software layer designed to make every chip interchangeable — including its rivals'. When you can't dig a moat as deep as CUDA, you commoditize the thing the moat protects.
The Wire
Programmatic Tool Calling, Explained: When to Let Claude Orchestrate Your Tools in Code
Claude's newest tool-use mode writes a script that calls your tools in a sandbox and returns only the answer. It cuts tokens and round trips — and quietly removes the trace your evals were reading.
The Wire
Why Prefix Caching Silently Dies on Mamba-Hybrid Models: The 528-Token Cliff
Prefix caching assumes every token leaves a reusable KV entry. Mamba layers don't — they carry one recurrent state — so serving engines align the cache block to the Mamba page, and short prompts fall off a throughput cliff.
The Wire
Pinecone Nexus and KnowQL: When Retrieval Becomes a Compile Step
Pinecone says the RAG era is ending and agents should query compiled knowledge artifacts through a new language called KnowQL. The idea is real. The benchmarks are Pinecone's own — and the hard part is the one they don't measure.
The Wire
OpenAI Is Retiring Agent Builder and Evals: Shutdown Dates and the Migration Path
Eight months after launching a no-code way to build agents, OpenAI is telling everyone to write code again — and pointing its own eval users at a competitor.
The Wire
Nemotron 3's Latent MoE: How NVIDIA Runs 550B of Experts at 55B of Cost
Nemotron 3 Ultra activates 55B of 550B parameters per token — the ordinary MoE trick. The new part is Latent MoE, which routes experts through a shared compressed space so 'more experts' stops meaning 'more cost.'
The Wire
Microsoft Agent Framework's CodeAct: When the Sandbox Stops Being the Hard Part
Code-execution agents always ran into the same wall — running model-written code safely is expensive. Hyperlight's sub-2ms micro-VM moves that wall, and changes what the pattern costs.
The Wire
MCP Enterprise-Managed Authorization: Zero-Touch OAuth Without the Consent Screens
The June 2026 spec extension didn't shave clicks off MCP's login flow — it moved the authorization decision away from the one person who was never equipped to make it.
The Wire
MCP's 2026-07-28 Auth Rewrite: The Six SEPs That Change How Agents Log In
The largest MCP revision since launch adds zero new authorization mechanisms. All six auth SEPs do the opposite — make MCP behave like a boring OAuth 2.1 resource server so it works with the identity providers enterprises already run.
The Wire
How to Test a Non-Deterministic AI Agent: Flakiness Is a Sample Size, Not a Bug
Your agent test went green, then red on a commit that changed nothing. The instinct is to quarantine it. The instinct is wrong — that red is a measurement, and you took it wrong.
The Wire
How to Evaluate a Multi-Agent System
A single pass/fail score is worse than useless once you have more than one agent — it hides which one broke. The real unit of evaluation is the handoff, not the outcome.
The Wire
How to Put a Hard Spending Cap on an AI Agent
An agent can't enforce its own budget, because the runaway loop is the failure. The cap has to live one layer down — and even there, it's a distributed-consistency problem wearing a config flag.
The Wire
GPT-5.6 Sol for Agents: The Coding Record and the Cheating Problem Are the Same Result
Sol tops Terminal-Bench 2.1 and posts the highest detected reward-hacking rate METR has ever measured. For anything you run in an agent loop, those two facts are not separable.
The Wire
Gemini 3 Flash vs Pro for Agents: The Tier Inverted
Google shipped a Flash model that beat its own Pro on SWE-bench Verified. For agent builders, that doesn't mean 'Flash is good enough' — it means the axis you escalate on just moved.
The Wire
DeepSeek V4 Pro vs Flash: Which One Goes in Your Agent Loop
Both open-weight variants ship the same 1M-token attention and the same agentic training. For an agent, the choice isn't a smartness tier — it's a per-turn cost knob.
The Wire
Cursor's DuneSlide Flaws: When a Path Check Fails Open, Prompt Injection Becomes RCE
Two zero-click Cursor flaws let a poisoned MCP response overwrite the editor's own sandbox binary. The root cause wasn't a bad command — it was a path validator that failed open.
The Wire
ClickHouse Bought Langfuse: What It Means for Your LLM Traces — and Whether It Stays Open Source
A database company acquiring an observability startup looks like a tooling deal. It isn't. It's a bet that whoever stores your agent traces owns the loop that trains the next model.
The Wire
Claude Sonnet 5's Tokenizer Tax: Why the Same Rate Card Costs More Per Task
Sonnet 5's rate card matches Sonnet 4.6's — $3/$15 per million tokens. A new tokenizer that emits more tokens for the same work means your bill doesn't.
The Wire
Claude Code Agent Teams vs Subagents: When Your Workers Need to Talk to Each Other
Claude Code's new experimental Agent Teams let parallel sessions message each other and share a task list. The real question isn't 'do I want parallelism' — subagents already give you that — it's whether your workers need to disagree.
The Wire
Localhost Stopped Being a Trust Boundary the Moment Your Agent Started Browsing
Microsoft's AutoJack shows how a single web page can RCE the host running an AI agent — not by forging an origin, but because the agent's own browser is localhost.
The Wire
Mem0 vs Zep vs Letta: Why Agent-Memory Benchmarks Don't Agree
The whole agent-memory leaderboard war — 84% vs 58% vs 75% — is being fought over a ten-conversation dataset called LOCOMO. Once you see how the numbers are made, you stop shopping on accuracy.
The Wire
Agents' Last Exam: Frontier Agents Pass 2.6% of Hard Professional Work — and the 2.6% Is the Point
Berkeley's ALE scores whole deliverables, all-or-nothing, the way a client would. That single methodology choice is why the number is 2.6% and not the 90s vendors keep quoting.
The Wire
Agentic Resource Discovery (ARD): The Search Layer That Sits in Front of MCP and A2A
Eleven vendors just agreed on how agents find tools across the open web. The interesting part is what ARD refuses to be — not a protocol, not a registry of record, just the step before invocation.
The Wire
Do AI Agents Self-Correct? Why Reflexion Works and 'Check Your Work' Backfires
Telling an agent to review its own reasoning usually makes it worse, not better — and the reason it fails is the same reason Reflexion succeeds. Both come down to one asymmetry: verifying is only easier than generating when the verifier knows something the generator doesn't.
The Wire
Agent Registry vs MCP Registry: The New Discovery Layer, and Why It's Already Fragmenting
The MCP registry catalogs tools. The agent registry catalogs agents — and AWS, Google, and Microsoft each shipped one this quarter that can't see the others.
The Wire
Agent Client Protocol (ACP): The Third Protocol Named ACP, and Why It's LSP for Coding Agents
MCP gives an agent tools. ACP gives an agent an editor. The role swap between them is the whole architecture — and it's the reason the same three letters now point at three unrelated standards.
The Wire
Zero Trust for AI Agents: Why the New Frameworks Treat Your Agent as an Insider Threat
Anthropic and Google DeepMind converged on the same uncomfortable premise in 2026: the agent already has legitimate credentials, so the honest security model assumes it's compromised and bounds what it can do — not whether it can get in.
The Wire
vLLM vs SGLang vs LMDeploy: Picking a Self-Hosted Inference Engine in 2026
With TGI archived and Hugging Face pointing everyone at vLLM and SGLang, the open-source serving field narrowed to three real choices. They hit nearly the same throughput ceiling from opposite directions — so speed is not the thing you're actually picking.
The Wire
Text-to-SQL Accuracy in 2026: Why the Benchmark Says 90% and Your Warehouse Says 40%
Top systems clear 90% on academic SQL benchmarks and 30–60% on real enterprise warehouses. The gap isn't the model's syntax — it's your schema. And the leaderboards are half wrong.
The Wire
Stainless Is Winding Down: Where to Generate SDKs and MCP Servers Now
The two best independent SDK generators got bought in 2026 — Fern by Postman, Stainless by Anthropic, which is retiring its shared generator. The layer that turns an API into agent-usable tools stopped being neutral infrastructure.
The Wire
Faithfulness vs Groundedness vs Correctness: Which RAG Hallucination Check Catches a Wrong Answer
A faithfulness score of 1.0 doesn't mean your RAG answer is right. It means the model didn't stray from the context — even when the context was wrong. Here's what each check actually audits.
The Wire
The Best Small Model for Your Agent Isn't the Smallest — or the Smartest
Qwen3-4B, Phi-4-mini, Gemma, Nemotron 3 Nano: the pick forks on a question no leaderboard prints — are you short on memory or short on tokens-per-dollar? And the score that decides an agent isn't MMLU.
The Wire
Pydantic AI V2 Is Out: What 'Capabilities' and the Harness Actually Change
V2 went stable on June 23 after seven betas, then shipped four releases in nine days. The real news isn't the version bump — it's a bet that the winning agent abstraction is a harness, not a graph.
The Wire
Pi's System Prompt Is Under 1,000 Tokens: The Case Against Heavy Coding-Agent Harnesses
Most coding agents open with a ~10,000-token system prompt. Pi opens with under 1,000 and lets the model write its own tools. The bet underneath: the model already knows how to be an agent, and every instruction token is a task token you don't get back.
The Wire
The NSA's MCP Security Guidance: The First Advice That Defends Against Your Own Agent
The NSA's Security Design Considerations for MCP reads like every other threat list until you notice its signature control points the wrong way — at the outbound wire, not the untrusted server. That inversion is the whole document.
The Wire
MiniMax M3: Frontier Coding and 1M Context on Open Weights — Read the Latency, Not the Leaderboard
M3 claims to beat GPT-5.5 on SWE-bench Pro while running weights you can host yourself. The benchmark row is the least trustworthy thing in the release — and the architecture is the most.
The Wire
MCP Is Deprecating Sampling, Roots, and Logging: What the 2026-07-28 Spec Cuts and Why
The stateless rewrite got the headlines, but the quieter change is the one that tells you what MCP has decided to be. Three original primitives are on the way out — and they're the exact three where the server reached back into your runtime.
The Wire
MCP's Stateless Spec Fixes Session Hijacking — and Hands You Three New Attack Surfaces
The 2026-07-28 revision closes the holes the protocol used to own. The same three headline features quietly relocate the security burden onto server code that mostly doesn't exist yet.
The Wire
The Mastra npm Attack: AI Agent Frameworks Are the New Supply-Chain Target
A North Korean crew republished 140+ Mastra packages in 88 minutes with a poisoned dependency. The scary part isn't the payload — it's that the whole attack ran before any of your agent's guardrails woke up.
The Wire
LLM Cascade vs Router: Escalate to a Bigger Model, or Route Around It?
A router picks a model before it sees the answer; a cascade tries the cheap one first and escalates only if a judge says so — and that judge, not the models, decides whether you actually save.
The Wire
Interleaved Thinking: When Should an AI Agent Reason Between Tool Calls?
The point of thinking between tool calls isn't a smarter first plan — a model can plan up front without it. The point is that the model can notice a tool returned something wrong and re-plan on the spot, instead of barreling ahead.
The Wire
How to Enforce a Token Budget on an AI Agent (Not Just Measure It)
Most 'agent budgets' are alerts wearing a brake's uniform: they tell you after the money is gone. Real enforcement is a prediction problem, because the cost of the next step is a bound you can only ever estimate — never a number you can look up.
The Wire
How MCP Servers Actually Ship: The Registry Is a Phone Book, OCI Is the Supply Chain
The official MCP registry deliberately refuses to host code — so the hard part, trust, lands wherever the artifact lives. Docker's answer is to make that place an OCI image.
The Wire
Google Open-Sourced an Agent Memory System With No Vector Database. Read the Design.
A Google PM's 'Always On Memory Agent' stores everything in SQLite and consolidates it with an LLM every 30 minutes. The 30-minute number tells you exactly what it's for — and what it isn't.
The Wire
Does Structured Output Hurt LLM Accuracy? The Format Tax, Measured
Forcing JSON can cost a reasoning model 10–15% — but the tax is paid during thinking, not from structure itself. The fix is where you put the reasoning, not whether you constrain.
The Wire
Claude Sonnet 5 vs Opus 4.8 for Agents: The Cheaper Model and the Tokenizer Catch
Sonnet 5 lands at 40% below Opus and beats it on terminal work — but a new tokenizer quietly inflates every token count by ~30%, so the rate card is not the price. Do the cost math in your own units.
The Wire
What Anthropic's 'Dreaming' Does to Agent Memory — and Why a Bad Dream Doesn't Wash Out
Claude's new consolidation loop replays an agent's day and writes down what it learned. The same mechanism that lifted one customer's task completion ~6x is the one that makes a poisoned lesson permanent.
The Wire
Batch API vs Real-Time Inference: The 50% Discount Isn't Why You Should Use It
Every provider now sells the same deal — hand over your requests, wait up to 24 hours, pay half. The savings are real, but the reason to reach for batch is the thing nobody puts on the pricing page.
The Wire
AWS Will Now Let You Charge AI Agents Per Request: How x402 Metering at the CDN Edge Works
AWS WAF Bot Control can now return an HTTP 402 with a machine-readable price and settle USDC before the request ever reaches your origin. The real shift isn't crypto — it's that a web page finally has an enforceable price for a machine.
The Wire
Agent Skills Are an Open Standard: What Portability Buys — and What It Can't Enforce
A Skill is a folder with a SKILL.md and an Apache-2.0 license — no server, no transport, no auth. That's why another runtime can adopt it in an afternoon, and why a Skill can't revoke, throttle, or contain anything.
The Wire
Agent Handoffs in LangGraph, OpenAI Agents SDK, and Google ADK: What Actually Transfers With Control
Every multi-agent framework now has a handoff primitive, and they all look the same in the demo. The difference that bites you in production is what rides along when one agent passes the baton to the next.
The Wire
Tool Choice: auto vs required vs Forcing One Tool
tool_choice looks like a switch for making a model use tools. It's really the decision of whether a turn is allowed to end the conversation — and leaving 'required' on traps the agent loop with no way out.
The Wire
TeleMem vs Mem0: When a Drop-In Memory Layer Is Really a Different Bet
TeleMem ships as a one-line replacement for Mem0 — import telemem as mem0 — and claims a 16-point accuracy edge. Read where that number comes from and you learn exactly which agent it's for.
The Wire
Right to Be Forgotten in RAG: How to Actually Delete a User From a Vector Database
The DELETE call is the easy five percent. A user's data has already fanned out into the index, the chunk store, the cache, your trace logs, and maybe a fine-tune — and in most vector engines the delete is a tombstone the graph keeps walking until compaction.
The Wire
When Prompt Injection Becomes Remote Code Execution: Why Agent Command Allowlists Keep Failing
Three critical 2026 CVEs — in ModelScope's MS-Agent, Microsoft's Semantic Kernel, and Cursor — share one root cause. The agent filtered the command it was about to run. It never controlled the ground that command would run on.
The Wire
MCP Server Cards: How an Agent Will Vet a Server Before It Connects
A new .well-known discovery file lets clients read an MCP server's identity, transport, and auth requirements without a handshake — and it pointedly refuses to list the tools.
The Wire
The Confused Deputy Problem in MCP: Why Agent Auth Keeps Failing the Same Way
A 1988 access-control bug is the shape of 2026's worst MCP breaches. Understanding the confused deputy tells you why 'just add OAuth' doesn't fix your agent — and what the spec actually changed.
The Wire
MCP-Bench vs MCPToolBench++ vs MCPAgentBench: How to Benchmark an Agent's MCP Tool Use
Function-calling leaderboards test a model against a handful of curated tools. A real MCP host hands it thousands — and that is a different benchmark, with a different failure mode.
The Wire
How to Attribute LLM Costs Per Agent, Tenant, and Feature
The invoice arrives and no one can say which customer spent the money. Cost attribution isn't a report you run later — it's a schema decision you make at request time, and for agents the gateway total lies about where the spend went.
The Wire
Hyperlight vs Firecracker: The Micro-VM That Deleted the Guest Kernel to Sandbox Agent Code
Firecracker gives each agent a whole Linux to boot — 125 ms of it. Hyperlight keeps the hardware wall and throws away the OS behind it, and that deletion is what makes per-tool-call isolation affordable.
The Wire
How Vulnerable Are MCP Servers? A Scan of 39,884 Repos Found 106 Zero-Days
A new automated auditor didn't just flag risky code in Model Context Protocol servers — it wrote the prompts to prove the holes were real. 67 already carry CVE IDs, and almost none are AI-specific.
The Wire
How to Tune HNSW: The Three Knobs Behind Vector Search Recall
M, ef_construction, and ef_search decide whether your vector search is fast, accurate, or neither. Only one of them can be changed after you build the index — and it's the one most teams never touch.
The Wire
How to Summarize a Document That Doesn't Fit in the Context Window: Map-Reduce vs Refine vs Not at All
Map-reduce's 'reduce' step quietly re-creates the exact overflow you were escaping. Refine can't parallelize. And in 2026 the fastest-improving option is often to stop summarizing and put the whole document in a million-token window — if you can pay the middle.
The Wire
How to Handle a Truncated LLM Response: finish_reason, max_tokens, and the Reasoning-Token Trap
A cut-off completion isn't an error your code catches — it's a 200 OK whose only tell is a stop-reason field most callers never read. And on reasoning models, the fix everyone reaches for can hand you an empty response.
The Wire
How to Evaluate an AI Coding Agent
Public leaderboards answer 'which model is smartest,' not 'will it fix my bugs' — the only test that predicts your outcome is a private eval built from your own repo.
The Wire
How to Deploy a Long-Running AI Agent Without Losing In-Flight Work
A web server drains its in-flight requests in 30 seconds and restarts. An agent's in-flight request is a multi-hour, side-effecting loop — so graceful shutdown stops being a deploy setting and becomes an architecture decision you had to make weeks earlier.
The Wire
How AI Agents Decide What to Forget: Memory Consolidation in Mem0, Zep, and the Memory Tool
Every serious agent-memory system is really a forgetting system. The hard part was never storing what the agent learns — it's pruning the contradictions and stale facts that quietly poison retrieval.
The Wire
The Best AI Model for Coding Agents in 2026 Is Half a Harness
GPT-5.5 and Claude Opus 4.8 are tied on SWE-bench Verified at ~88.6%. That means the leaderboard number stopped being the answer — and your agent's scaffolding started being it.
The Wire
Kubernetes' Gateway API Inference Extension: When the Load Balancer Starts Reading GPU Metrics
Round-robin is the wrong way to route an LLM request. Kubernetes now has a GA'd standard that lets the gateway pick a model server by live KV-cache pressure and queue depth instead — and it changes what a load balancer is.
The Wire
Every AI Agent Framework Became a Graph in 2026 — and the Hard Part Is Still Unsolved
With ADK 2.0's GA, LangGraph, OpenAI's Agents SDK, Google's ADK, and Microsoft's Agent Framework all now run on a graph execution engine. The programming model war is over. It settled the easy question.
The Wire
Declarative Agents: When a YAML File Should Define Your Agent — and When It Can't
Microsoft and Google both now let you define an agent in YAML instead of code. The split isn't about simplicity — it's about whether your agent's logic lives in its wiring or in its decisions.
The Wire
Context Compaction Is Quietly Deleting Your Agent's Guardrails
The summary your long-running agent writes to stay under its token budget is lossy in one direction: it keeps the rules that fire and drops the rules that forbid. New research puts a number on how fast safety erodes.
The Wire
Brute-Force vs Approximate Vector Search: Do You Even Need a Vector Database?
Approximate nearest-neighbor search is a tax you pay to survive scale you may not have. Below a few hundred thousand vectors, exact brute-force is faster, perfectly accurate, and has no index to rot.
The Wire
When \"Trust This Folder\" Means Remote Code Execution: The Amazon Q Flaw Every Coding Agent Shipped
Amazon Q auto-ran an MCP config out of any repo you opened, with your live AWS keys in the process. It got a CVE. The identical bug in Claude Code, Cursor, Gemini CLI and Copilot got declared working-as-designed — because the trust prompt you inherited from your editor was never a consent to run code.
The Wire
Why AI Browsers Still Can't Stop Prompt Injection
Nearly a year after the first Comet and Atlas exploits, the browsers' own makers say prompt injection may never be fully solved. The reason is structural, not a bug waiting for a patch.
The Wire
AI Agents Are Finding Real Zero-Days at Scale — and Drowning Maintainers in Fake Ones
An autonomous agent found 21 genuine zero-days in FFmpeg for about $1,000. The same technology just made curl kill its bug bounty. Discovery got cheap; disposition didn't.
The Wire
AI Agent Goal Drift: Why Long-Running Agents Quietly Abandon the Task You Gave Them
The failure isn't that the agent forgets the goal. It's that, step by step, a louder goal replaces it — and the fix is a ratio, not a bigger memory.
The Wire
How Many Tokens Does an Agent Memory Layer Use? From 7K to 3.26M per Query
A June 2026 paper clocks three popular memory frameworks on the same benchmark: 118K, 632K, and 3.26M tokens per query. The 500x spread isn't noise — it's a design choice most teams never realize they're making.
The Wire
Web Bot Auth, Explained: How a Site Will Tell Your AI Agent From a Scraper
For 25 years the web tried to detect bots by behavior and kept losing. Web Bot Auth gives up on detection and asks the bot to sign its name instead — and the big agent makers have already started doing it.
The Wire
Vercel eve vs Microsoft Agent Framework: Portable Agent, or Portable Runtime?
Both shipped the same six production features in 2026. The choice isn't capabilities — it's which half of your agent you're willing to lock to a vendor.
The Wire
Unisound U2 and the Bet on 'Native Agentic' Models: When the Loop Moves Into the Weights
A Chinese lab shipped a 266B/10B-active model that claims to decompose and finish 100+ step tasks on its own. The benchmark line isn't the story — the category claim is.
The Wire
Spot GPUs for LLM Inference: How to Cut Serving Cost Without Dropping Requests
Interruptible GPUs scare people because of training horror stories. For stateless inference the math inverts — there's nothing to checkpoint, so the only real tax is cold start.
The Wire
Skyvern vs Browser Use: You're Not Picking a Browser Agent, You're Picking How It Sees the Page
Both drive a real browser from natural language. But one reads the DOM and one looks at pixels — and that single perception choice decides your cost per step, your reliability on ugly sites, and whether you can even ship it in a closed product.
The Wire
Provider-Agnostic AI Agents: The Lock-In Isn't Where You Think
Swapping LLM providers in one line is true for a chatbot and a lie for an agent. The cage is one layer up, in tool-calling behavior — and no gateway unlocks it for you.
The Wire
MCP vs REST: Do Your Agents Need a Protocol, or Just Your API?
Most MCP servers are REST APIs underneath. The honest question isn't which transport to use — it's how much of your API to expose, and the data says the answer is about a fifth of it.
The Wire
MCP Goes Stateless: What the 2026-07-28 Spec Changes for Agent Builders
The biggest Model Context Protocol revision since launch deletes the session, the handshake, and even the client-side LLM call. The headline isn't new features — it's that the protocol got smaller.
The Wire
Agent Memory Benchmarks: LoCoMo vs LongMemEval vs BEAM
The benchmarks that grade an agent's memory just moved the finish line from 9,000 tokens to 10 million — and the new one proves a million-token context window doesn't buy you long-term memory.
The Wire
Your LLM Judge Is Biased: Position, Verbosity, and Self-Preference — and Which Ones You Can Fix
An LLM judge flips up to a third of its verdicts when you swap the answer order, and scores its own writing 10–25% higher. Three biases corrupt your evals — and only one has a cheap fix.
The Wire
LangChain 1.0 and LangGraph 1.0: What Actually Changed for Agent Builders
After a year of churn that made it a punchline, LangChain shipped a 1.0 whose headline feature is the thing frameworks never promise: that it will stop moving under you.
The Wire
Jailbreak vs Prompt Injection: Two Attacks That Live in Different Layers
They get used as synonyms, and that confusion is why teams 'add a guardrail' and stay wide open. A jailbreak attacks the model's policy; prompt injection attacks your application's trust boundary.
The Wire
How to Write a System Prompt for an AI Agent
A chatbot's system prompt sets a personality. An agent's is control logic the model rereads on every turn of the loop. Stop writing a persona and write a policy.
The Wire
How to Ship an AI Agent Change Without Breaking It: Eval Gates, Shadow Replay, and Why Canaries Lie
You can't A/B test an agent the way you A/B test a button. The unit of variance is a trajectory, not a click — so the gate has to be offline, and "shadow mode" means something different than it does for a model.
The Wire
How to Read an Agent-Memory Benchmark: The LoCoMo and LongMemEval Number Wars
Mem0 says 92.5% on LoCoMo. Mastra says 95% on LongMemEval. Zep corrected its own 84% to 58%. They can't all be right — and the baseline that beats them all is the one no vendor charts.
The Wire
How to Evaluate an Embedding Model on Your Own Data
The MTEB leaderboard is a prior, not an oracle. The model that wins your RAG system is the one you measure on a few hundred of your own labeled queries — here is how to build that eval.
The Wire
How to Evaluate a Deep Research Agent: Report Quality vs. Citation Accuracy
A deep research agent hands you a long, confident, well-structured report. Grading it means measuring two different things at once — how good it reads, and whether a single sentence is actually supported.
The Wire
GLM-5.2 Matched the Closed Models on Agentic Coding — for a Sixth of the Cost
An open-weight model is now within a point of Claude Opus on long-horizon coding benchmarks. The benchmark delta is the least interesting number; the token price is the one that moves what you'll actually run.
The Wire
Your Agent Is Now an MCP Server: What Exposing an Agent as a Tool Quietly Throws Away
Deploy a LangGraph agent and it auto-publishes a /mcp endpoint, so any client can call it as a tool. Convenient — and lossy. A tool call is a flattened agent, and the parts it flattens are the parts that made it an agent.
The Wire
Eval-Driven Development: How to Ship an AI Agent Without Guessing
Write the eval before the prompt. The test suite you build first is the only thing that lets you change models next month without praying — and in 2026, you will change models.
The Wire
The EU AI Act Deadline Didn't Really Move: What Still Hits AI Agents on August 2
The Digital Omnibus pushed the high-risk rules to 2027 — and most builders read that as a reprieve. But the deadline that actually catches a typical agent never moved at all.
The Wire
Claude Agent SDK vs OpenAI Agents SDK: A Harness vs an Orchestration Library
Both vendors shipped an official agent SDK, so the choice looks like a feature bake-off. It isn't. They sit at different layers and bet on different hard parts — and their defaults decide which one your problem is one line of code away from.
The Wire
Bedrock AgentCore vs Vertex Agent Engine vs Foundry Hosted Agents: The Managed Agent Runtime, Compared
All three hyperscalers now sell a managed home for your agent. Each one makes a different bet on which hard part of running an agent you don't want to own — and all three quietly move your agent's memory onto their substrate.
The Wire
Autoscaling LLM Inference on Kubernetes: Scale on the Queue, Not the GPU
The metric you'd reach for first — CPU, then GPU utilization — is the one that lies. A 70B pod can read 5% CPU and a calm GPU dial while its request queue backs up for miles. Scale on queue depth instead.
The Wire
Any-LLM vs LiteLLM: You're Comparing a Library to a Building
Mozilla's any-llm and LiteLLM get pitted against each other constantly, but they answer different questions — the only one that matters is whether you actually need a proxy.
The Wire
Agent Sprawl: Why AI Agent Governance Now Starts With a Registry
Microsoft, Okta, and AWS all shipped the same first move against unmanaged agents — an inventory. It's the shadow-IT playbook again, except this time the thing you can't see replicates itself.
The Wire
The AI AGENT Act, Explained: Warner's Bill Treats Blocking Your Agent as the Harm
A new Senate discussion draft reads like a privacy bill, but its teeth are an interoperability mandate — the first U.S. attempt to give users a right to bring an agent onto platforms that would rather keep it out.
The Wire
A2A at One Year: Is Agent-to-Agent Interoperability Actually Happening?
The Agent2Agent protocol now claims 150-plus organizations and a slot in every major cloud. The number that matters isn't logos — it's whether agents from different vendors are really negotiating work across a trust boundary, and the honest answer is "barely, and not for the reason you think."
178 pieces this week on this desk.
The Stack
All The Stack →
The Stack
The Best Open-Source MCP Gateways for Self-Hosted Agents
Five real, self-hostable gateways that put one endpoint in front of many MCP servers — and why the stateless spec is about to change what a gateway is even for.
The Stack
The Best Open-Source Frameworks for Training AI Agents with Reinforcement Learning
Seven real, self-hostable RL frameworks for post-training tool-using agents — and why the one you pick should be decided by the environment, not the algorithm.
The Stack
Semantic Caching vs Prompt Caching: Which One Actually Cuts Your LLM Bill (and Which Can Return a Wrong Answer)
They both have 'caching' in the name and both promise to slash your token spend, but they cache different things at different layers with different safety profiles. One's worst case is a cache miss. The other's worst case is a confidently wrong answer.
The Stack
RL Frameworks for Training AI Agents: SkyRL, Agent Lightning, RLinf, AgentGym-RL
Everyone ships the same PPO. This year's agent-RL frameworks all fight over the one thing that's actually hard — the rollout.
The Stack
The Self-Hosted AI Gateway: 7 Open-Source Proxies That Became the Agent Control Plane
The 'AI gateway' stopped being a cost-tracking load balancer and turned into the policy layer for autonomous agents — and that shift is why the newcomers are all written in Go and Rust, benchmarking themselves against LiteLLM.
The Stack
Generative UI for Agents: The Repos That Let an LLM Render Real Components
The field for making an agent 'speak UI' has split into two camps — your codebase owns the components, or the protocol does. Which repo you reach for is really a bet on who controls the widget.
The Stack
Deep Agents on Pydantic AI: The Repos for a Self-Hosted, Model-Agnostic Claude Code
Claude Code proved the 'deep agent' pattern — planning, a filesystem, sub-agents, skills. A small cluster of Python repos now rebuilds that harness on Pydantic AI, so it runs on any model you own.
The Stack
LangMem vs Mem0: Memory You Program vs Memory You Call
They get compared like rivals, but one is memory you program and the other is memory you call — and the benchmark leaderboard only measures one of them.
The Stack
Qdrant vs Milvus vs Weaviate: Filtered Search Is the Question That Separates Them
They all scale now, and they all do hybrid search. The axis that still forks the decision is the one nobody puts on a benchmark chart: how each keeps a metadata filter from wrecking recall.
The Stack
Cross-Cluster LLM Serving: Why KServe, llm-d, and Dynamo Stop at the Cluster Line
The Kubernetes-native serving stack got very good at spreading a model across a cluster. But in 2026 your GPUs aren't in one cluster — they're scattered across clouds by price and availability, and that's a different problem.
The Stack
Open-Source Deep Research Agents: 7 Repos to Build (or Run) Your Own
OpenAI and Google ship deep-research as a closed feature. These seven open repositories let you run the same plan-search-read-synthesize loop on your own models, your own sources, and — if you want — entirely on your own machine.
The Stack
Kafka vs NATS vs Redis Streams: Choosing the Event Backbone for AI Agent Systems
All three move messages between agents. The question that actually separates them is the one most throughput benchmarks never ask — can you replay the log?
12 pieces this week on this desk.