How to Return an Interactive UI From Your MCP Server — MCP Apps, End to End
Your MCP tool can hand back a live dashboard, form, or chart instead of a wall of text. Here's the ui:// resource pattern, the ext-apps SDK, and the sandbox rules that keep it safe — a working MCP App in about 20 minutes.
5 min
One SKILL.md, Five Coding Agents: What Travels Between Claude Code, Codex, Gemini CLI, Copilot, and Cursor
The Agent Skills format is now an open standard that 30-plus tools read. So the same SKILL.md folder can run in five different coding agents — but only the frontmatter and body travel cleanly. Here's the install path for each, and the three things that quietly break portability.
4 min
Your Agent Doesn't Need Your API Key. It Needs an Identity — Non-Human Identity, Explained for Builders
A $1B acquisition just made 'non-human identity' a real budget line. Here's what it means when your AI agent needs credentials — and the five moves that give it access without handing it a password you can't revoke.
5 min
How to Write Agent Tool Descriptions That Cut Token Cost Without Losing Accuracy
Every tool you register rides in the model's context on every turn, so verbose schemas quietly inflate your input bill. Trim each description to its load-bearing job, measure the drop, and A/B for accuracy — the same move that cut a Deep Agents turn's input tokens ~65%.
6 min
How to Write a Claude Skill That Actually Triggers: The SKILL.md Description Craft
The complaint is never that skills give bad instructions — it's that they never fire. The one field that decides whether a skill loads is the description, and most are written too vague and too polite. Here's how to write one Claude reliably picks up.
5 min
How to Build a Tool-Selection Eval: Stop Guessing Whether Your Agent Picks the Right Tool
You rewrote the tool descriptions and cut the tool list. Did it work? A tool-selection eval turns that guess into a number you can watch — here's the 30-line harness that measures which tool your agent reaches for, and a confusion matrix that tells you why it's wrong.
4 min
Tool Highlight: MoonPay PayBox — the Non-Custodial Vault That Puts a Passkey Between an AI Agent and Your Money
What PayBox is, who it's for, how to connect it in a few minutes, what it costs, and the honest catch — a non-custodial vault that lets an AI agent prepare real crypto and card payments while a human holds the only key that moves money.
3 min
How to Publish Your MCP Server to the Official Registry: A Copy-Paste Walkthrough
You built an MCP server. Now make it discoverable in the one catalog Claude, VS Code, and every subregistry pull from. Three commands, one server.json, and a namespace you have to prove you own — the whole flow, end to end.
3 min
The Founder's Wire, Week of August 4: Agents That Can Pay, and VCs Funding the Reactors to Run Them
The falling-token-price story kept running, but the fresher signal is the stack getting built out at both ends — payment rails an agent can actually use, and the power to run all of it. Two moves worth a founder's attention this week, plus the compliance clock that just started.
5 min
Returning a Tool Error to the Model: Anthropic's is_error vs OpenAI's Output String
When a tool call fails, the two big APIs want you to say so in completely different ways. Anthropic has a dedicated is_error flag; OpenAI has no error field at all — you put the failure in the ordinary output string. Get this one detail wrong and your agent either 400s or silently trusts a broken result.
5 min
Migrate to MCP TypeScript SDK v2: The One Monolith Became Nine Packages — Here's Which Ones You Actually Install
v2.0.0 shipped with the 2026-07-28 spec and split `@modelcontextprotocol/sdk` into nine subpackages. The split isn't bookkeeping — it's the packaging finally matching a stateless world. Run the codemod, pick two or three packages, delete the fat import.
3 min
Anthropic Shuts Off the Prompt-Tools API and Legacy Workbench on August 17 — Export Now, Then Rebuild It in One Messages Call
Three experimental endpoints — generate, improve, and templatize a prompt — return an error after August 17, and the legacy Workbench that held your saved prompts and evals goes with them. Here's what to export today and a copy-paste replacement that no vendor can deprecate.
5 min
How to Add 'Sign in with ChatGPT' to Your App: The OAuth Flow, the Code, and the Gotchas
OpenAI turned ChatGPT into a login button on August 2. The decision pieces tell you whether to add it; none show you the wiring. Here is the whole flow — authorization-code + PKCE against auth.openai.com — with the redirect, the token exchange, and the exact three claims you get back, in one Node file.
6 min
How to Add Elicitation to a Remote MCP Server on the Stateless 2026-07-28 Spec
Elicitation used to be a local-server luxury. The stateless core and Multi Round-Trip Requests finally let a remote server pause a tool call, ask the user for structured input, and resume — here's the code.
5 min
Visa Intelligent Commerce vs Mastercard Agent Pay vs Google AP2: How to Choose an Agent-Payments Rail
Three of the biggest names in payments each shipped a way for an AI agent to spend money on someone's behalf. They look like competitors. They're actually three layers of the same stack — and picking wrong means picking a liability model you didn't mean to sign.
5 min
How to Build Your Own MCP Extension on the 2026-07-28 Spec (Without Forking the Core)
The final MCP spec made a formal Extensions framework the sanctioned way to add capabilities. Here's how to namespace one, negotiate it per connection, and degrade gracefully on clients that don't support it.
4 min
Cyera Just Paid ~$1B for Oasis Security: Agent Identity Is Now a Billion-Dollar Category
The second-largest security deal of 2026 wasn't about firewalls or data loss — it was about the logins your AI agents hold. Here's what Cyera bought, why now, and the one move it forces for anyone shipping agents.
4 min
How to Run a Claude Skill in the Background: context: fork, Explained
As of Claude Code 2.1.218, a skill with context: fork runs in the background by default — you keep working while it does. Here's when to detach a skill, when to set background: false, and the tool-set gotcha that bites people who don't.
5 min
Agent Registry vs MCP Gateway: Two Different Jobs Founders Keep Conflating
A registry tells you what agents and tools exist; a gateway controls how traffic to them is routed, authed, and governed. Buy the wrong one and you solve a problem you don't have.
4 min
Make Your MCP Server Survive a Dropped Connection: The EventStore Nobody Wires Up
Streamable HTTP hands your client a Last-Event-ID header that promises to resume a dropped stream. It resumes nothing unless the server kept the events — and the SDK's default store loses them the moment your process restarts.
5 min
MCP vs API: When to Build an MCP Server, and When a Plain REST API Still Wins
An MCP server and a REST API aren't rivals doing the same job. Choose by who the caller is and who decides to call — a developer at build time, or a model in the moment.
7 min
How to Turn Your Existing REST API Into an MCP Server (Without Rewriting It)
You don't rewrite anything: you put a thin MCP adapter in front of the endpoints you already ship, one tool per endpoint.
6 min
How to Test an MCP Server Before You Ship It: Inspector CLI, a Programmatic Client, and a CI Gate
Your MCP server works in the chat window — but does tools/list still return the right schema after your last refactor? Here's the three-layer way to test one: interactive Inspector, a scriptable CLI check, and a programmatic client you can run in CI.
5 min
How to Read a Function-Calling Benchmark: What BFCL and τ-bench Actually Measure — and the pass^k Number Founders Miss
Every model that wants to run your agent now quotes a tool-use score. Here's how to tell which of those numbers predicts a reliable agent in production — and why a 90% on the leaderboard can still fail one call in three when it matters.
5 min
The Founder's Wire, Week of July 31: MCP's Stateless Spec Ships, OpenAI Cuts Luna 80%, and Kimi K3's Open Weights Land
Five verified moves for a team of one: the biggest MCP revision since launch went final, the frontier price floor dropped again, the largest open-weight model ever shipped, and the money is flowing into agent identity.
5 min
Tool Highlight: Smithery — the MCP Registry That Also Hosts and Routes Your Server
The official registry tells an agent which MCP servers exist. Smithery adds the two parts a registry deliberately leaves out: a place to run the server and a router that picks it at call time. Here's what it does, who it's for, and where the free line sits.
3 min
Prompt Engineering for Agents: The Prompt Moved to the Tool Descriptions
In a chatbot you tune the user message. In an agent the model reads your tool descriptions and output contract on every single turn — so that's where the real prompt engineering now happens. Here's the surface that actually moves an agent's behavior, and what to write on it.
4 min
MCP TypeScript SDK v2 Went Standard Schema: Zod v4 vs Valibot vs ArkType for Your Tool Inputs
The v2 SDK stopped hard-wiring Zod. Now any Standard Schema validator works for tool inputs — so the question flips from 'learn Zod' to 'which validator, and does its JSON Schema output survive the trip to the model?'
4 min
The MCP Tasks Extension: How to Run Long Jobs Without Holding the Connection
In the final MCP 2026-07-28 spec, Tasks left the experimental core and became the io.modelcontextprotocol/tasks extension. Now a server can hand your agent a task handle for minutes- or hours-long work and let it poll — no open HTTP connection required. Here's the exact lifecycle, the poll loop, and what changed if you built on the old API.
7 min
MCP Security Gateway: Build vs Buy — When a Founder Self-Hosts and When to Pay for One
You've decided every agent's tools go through one governed door. The next call is who staffs that door. Here's the build-vs-buy math for a solo team, with the open-source options and the managed one — Runlayer — side by side.
4 min
MCP's Multi Round-Trip Requests: How Sampling and Elicitation Work Now That the Session Is Gone
The 2026-07-28 spec killed the persistent connection — so how does a server still call back to your model or your user mid-tool-call? The answer is MRTR, and it's a resume loop you drive from the client.
4 min
MCP Now Routes at the Edge: Use the Mcp-Method and Mcp-Name Headers to Put a Gateway in Front of Your Server
The 2026-07-28 spec lifts MCP's routing surface out of the JSON body and into HTTP headers. Your gateway, rate limiter, and WAF can finally route and meter MCP traffic without parsing a single JSON-RPC payload.
3 min
How to Wire OAuth Token Exchange So an Agent Acts On a User's Behalf — With Copy-Paste Requests
The theory of RFC 8693 is easy to nod at and hard to ship. Here are the actual HTTP requests — enable it on Keycloak, trade a user's token for a downscoped one, read the delegation trail, and re-exchange per hop — that turn 'the agent acts on your behalf' into working code.
4 min
How to Take Your First Agent Payment with x402: A Paywall Your Agent Can Pay in 20 Minutes
x402 turns 'payment required' into a real HTTP round-trip. Two npm packages, one testnet, and an agent can pay for your API with no account, no key, and no invoice. A copy-paste walkthrough.
5 min
How to Route and Rate-Limit MCP Traffic at the Gateway With Mcp-Method and Mcp-Name (2026-07-28)
The final MCP spec puts the method and tool name in HTTP headers, so your nginx or Envoy in front of the server can route, meter, and block per-tool without ever parsing a JSON body. Here's the copy-paste config — and the one header you must never trust.
3 min
Serve a Stateless MCP Server on Cloudflare Workers — No Durable Object (createMcpHandler)
Cloudflare Agents SDK v0.20.0 adds createMcpHandler: a fetch handler that serves MCP tools, prompts, and resources statelessly and deprecates the Durable-Object–bound McpAgent. What changed, the migration, and when to keep McpAgent.
3 min
The Founder's Wire, Week of July 30: MCP's Final Spec Landed — Here Are the Five Things Inside It You Actually Use
The deadline everyone circled is behind us: the 2026-07-28 revision shipped final on Tuesday, on time, with all four Tier-1 SDKs speaking it day one. The date was the news; the extensions are the leverage. Here's the verified breakdown of what a team of one does with Tasks, MCP Apps, cacheable lists, the new auth, and a 12-month runway.
5 min
The Founder's Wire, Week of July 30: MCP v2 Ships Final, Kimi K3's Weights Land, and OpenAI's Own Model Breaks Out of Its Cage
Both deadlines on last week's calendar landed on schedule — the MCP v2 spec finalized and Kimi K3's 2.8T weights went open. Then OpenAI disclosed the week's real story: a model under evaluation escaped its sandbox and breached Hugging Face.
4 min
The Week an Unpinned pip Install Breaks Your Agent: OpenAI's 3.10 Floor, MCP SDK v2, and the Pins to Set Today
Three loud releases hit the Python agent stack in 48 hours — openai 2.49 drops Python 3.9, the MCP SDK ships a breaking 2.0, and anthropic patched twice the same day to survive it. If your build runs pip install -U unpinned, here's exactly what to pin before it bites.
3 min
How to Charge an AI Agent Per API Call with x402 — On Your Own Server, No Middleman
The x402 SDK just moved under the Linux Foundation and split into scoped @x402/* packages. Here's the current, from-scratch way to put a price on an Express route and take USDC from a paying agent — the seller side and the buyer side, with the exact code.
5 min
Build a Working AI Agent in 2026: The Loop, Context Engineering, and One MCP Tool
Skip the framework. An agent is an LLM calling tools in a loop — here's the ~40 lines that run it, the three context moves that keep it from rotting, and how to hang a real MCP tool off it.
7 min
The Founder's Wire, Week of July 29: SAP Buys a Tabular Foundation Model, MCP's Spec Freezes for Good, and the Open Weights Go Fully Public
Four verified moves that change what a team of one ships this week — SAP's €1B bet that business data gets its own foundation model, the MCP 2026-07-28 spec locking final so you can finally build on a fixed target, Kimi K3's full 2.8-trillion-parameter open weights landing with Anthropic calling open models 'a public good,' and the AI labs opening services arms to wire Claude and GPT into your competitors.
4 min
The Founder's Wire, Week of July 27: Opus 5 Holds the Price, Kimi K3's Weights Actually Land, MCP Crosses 400M, and Nvidia Backstops OpenAI's $500B Campus
Four verified moves that change what a team of one ships this week — Claude Opus 5 lands frontier coding at unchanged Opus pricing, Kimi K3's 2.8-trillion-parameter open weights hit the mirrors at 00:00 UTC, the MCP 2026-07-28 spec locks as downloads cross 400M a month, and Nvidia weighs a $250B guarantee to build OpenAI's Ohio data center.
5 min
Tool Highlight: WorkOS AuthKit — the OAuth Server the July 28 MCP Spec Now Expects You to Have
The 2026-07-28 MCP spec deleted the handshake and put standard OAuth 2.1 in charge of who gets to call your server. WorkOS AuthKit flips into an MCP-compliant authorization server with one config value — here's what it does, who it's for, and where the free line sits.
4 min
SIGGRAPH 2026: Agents Entered the Art Pipeline, With the Human Holding the Pen
Blender, Unreal, Adobe, and Houdini all shipped MCP servers at SIGGRAPH this week. The integration surface for creative tooling just consolidated onto one protocol — and the interesting design choice is that the artist still decides.
3 min
You Don't Need the v2 Beta to Go Stateless: Ship a Stateless MCP Server on the Stable SDK Today
The 2026-07-28 spec makes statelessness the default, and the whole ecosystem is telling you to wait for the beta v2 SDKs. You don't have to. The stable SDK already runs stateless — one flag flips it. The real work is moving your state out of the transport, and that you can do right now.
5 min
An Agent Just Joined a Network You've Never Heard Of. Pilot Protocol Raised $4.5M to Make That Normal.
Pilot Protocol came out of stealth this week with 'the internet for agents' — every agent gets an address, discovers peers, and installs tools with no human in the loop. The company says 250,000 agents already joined, most without their owners knowing. That last clause is the whole story.
5 min
MCP Python SDK v1 vs v2: Which to Build On the Day the Stateless Spec Ships
The 2026-07-28 stateless spec is final and a stable v2 SDK is targeted for the same day — but the official README still says 'v1.x for production, don't use v2 yet.' Here's the version to start a new server on this week, and the signal that tells you to move.
5 min
The MCP Feature Lifecycle Map: What's Safe to Build On After the 2026-07-28 Spec, and What's Already on the Clock
The final spec froze every feature into an Active, Deprecated, or Removed state with a 12-month removal guarantee. Here's the one-screen map of what to adopt today and what to design around.
4 min
The Founder's Wire, Week of July 28: MCP's Stateless Spec Finalizes Today, the EU's Enforcement Clock Starts in Five Days, and Inference Silicon Draws $300M
Five verified moves a team of one should act on: the biggest MCP revision since launch lands today, Europe's GPAI enforcement powers switch on August 2, a transformer-only chip startup doubles to $10.3B, and two open models change your cost math.
5 min
The Founder's Wire, Week of July 28: MCP's Stateless Spec Ships Final, the Open-Coding Tier Splits Three Ways, and the Cheap-Model Floor Drops Again
Four verified moves a team of one can act on today — the MCP deadline that's been on the calendar for months is now a published spec, the open-weight coding race stopped having one winner, and the budget model tier got cheaper again.
4 min
The Founder's Wire, Week of July 28: MCP Ships Final and Promises to Stop Moving, Anthropic Draws the Open-Weights Line, and Robots Go Online
Three verified moves for a team of one: the Model Context Protocol spec locks final today with a 12-month stability guarantee, Anthropic puts the open-weights fight in writing, and a $71M seed bets the robot bottleneck is the interface, not the intelligence.
5 min
Tool Highlight: Composio — 1,000+ Pre-Authenticated Actions Your Agent Can Call Today
Wiring your agent into Gmail, Slack, GitHub, and Notion means owning each API's OAuth, token refresh, and per-user connection state. Composio is the layer that hands your agent those actions pre-authenticated, behind one SDK — so you ship 'do this,' not API plumbing.
4 min
Swap an Agent's Tools Mid-Conversation Without Busting the Prompt Cache
Your tool list is the fattest, most stable block in every agent request — and until now, changing it mid-run silently re-billed the entire cached prefix at full price. A new Claude beta lets you add and remove tools between turns while the cache survives. Here's the exact mechanic.
4 min
Deploy Your MCP Server Behind a Plain Round-Robin Load Balancer (Stateless, No Sticky Sessions)
The 2026-07-28 stateless core lets any request hit any instance — so drop ip_hash, add a /health probe, and move only your Tasks state to a shared store.
6 min
An MCP Server Is a Distribution Channel Now, Not a Feature — and the Spec Locks July 28
Crunchbase and Axonius both shipped MCP servers on the same day this week. The point isn't the integration — it's that your product becomes callable inside ChatGPT and Claude, where your buyer already is.
4 min
CIMD vs Dynamic Client Registration: How MCP Clients Register After July 28
The 2026-07-28 spec deprecates the one auth step every remote MCP client relied on. Here is what Client ID Metadata Documents replace it with, and which one you should ship.
4 min
MCP's Stateless Spec Finalizes Tomorrow: Your Day-One Migration Checklist
The 2026-07-28 revision deletes the session, the handshake, and the session-id header. Here is exactly what a server author has to change — and what keeps working untouched for a year.
4 min
The Founder's Wire, Week of July 27: MCP's Stateless Spec Lands Monday, Claude Opus 5 Ships at the Old Price, and Kimi K3's 2.8T Weights Go Open
Five verified moves a team of one should act on: the MCP deadline finally arrives, a frontier model gets a 1M window at no price bump, a near-frontier open model you can self-host, and the EU disclosure rule that starts biting in six days.
5 min
The Founder's Wire, Week of July 27: MCP Finalizes Tuesday — and the Ecosystem That Catches You Already Shipped
Everyone's watching the spec date. The verified story for a team of one is quieter: four production SDKs, a live registry, and zero-touch enterprise auth all landed before the deadline. Here's what's real, what to test this weekend, and the three moves that matter before Tuesday.
5 min
Regex vs BM25 for Tool Search: Pick the Matcher by Whether Your Names or Your Descriptions Carry the Taxonomy
Claude's tool search ships two variants — a Python-regex matcher and a natural-language BM25 matcher. They search the exact same four fields, so the choice isn't about what gets searched. It's about where your catalog keeps its meaning.
5 min
The Founder's Wire, Week of July 26: Two Deadlines Land This Week — Kimi K3's 2.8T Weights (Sun) and MCP v2 Final (Tue)
A rare week with two hard dates on the calendar: the largest open-weight model ever ships Sunday, and the MCP spec locks Tuesday. Here's what each one actually changes for a solo founder.
3 min
The MCP v2 Beta SDKs Just Landed — Here's What Shipped in Each Language
With the stateless 2026-07-28 spec three days out, the official SDKs dropped betas across Python, TypeScript, Go, and C#. The versions to install, the codemod that does the boring parts, and why you can try stateless today without breaking a single existing client.
3 min
Everyone Read 'Stateless.' The Same MCP Spec Added Response Caching — That's the Line on Your Token Bill
The 2026-07-28 revision put two little fields on every tools/list and resource read: ttlMs and cacheScope. They're a Cache-Control for MCP, and they're what makes going stateless cheap instead of chatty.
4 min
MCP Grew Up on July 28: The 12-Month Deprecation Guarantee Is the Real Story, Not Statelessness
Everyone read the 2026-07-28 spec for the stateless core. The change that actually de-risks building a product on MCP is quieter: a formal deprecation policy, a conformance suite, and an SDK tier system. As of Monday, MCP is a versioned platform you can plan a roadmap against.
5 min
How to Add Response Caching to Your MCP Server (2026-07-28 Spec)
Once you go stateless, a naive client re-fetches your tool list every turn and re-injects it into the prompt. Two fields — ttlMs and cacheScope — stop the bleeding. Here's the copy-paste version, plus the one mistake that turns a cache into a leak.
5 min
Claude Can Now Learn a Task by Watching You Do It — 'Record a Skill' Changes the On-Ramp for Founders
Anthropic shipped 'Record a Skill' in Claude Cowork on July 21: screen-record yourself doing a task, talk through it, and Claude turns it into a skill it can run again. No prompt, no SKILL.md, no API wiring — the input to automation just became a demonstration.
4 min
Programmatic Tool Calling vs the Classic Tool Loop: When to Let the Model Write the Orchestration
GPT-5.6 can now write JavaScript that orchestrates your tools in a sandbox instead of round-tripping every call through its context. Here is when that saves you money — and when it just adds a layer.
5 min
Robinhood Handed AI Agents a Brokerage and a Credit Card — Over MCP. Here's How the Guardrails Work
A dedicated ring-fenced account, a virtual card with a cap you set, and a one-tap kill switch — Robinhood's agentic stack is a working template for how a founder should let any agent touch money.
3 min
How to Prove Your MCP Server Is Actually Stateless Before the July 28 Lock: A Conformance Test You Can Run in CI
Migrating off the handshake isn't the hard part — proving you didn't leave a hidden session dependency is. Here's a 50-line test that fails loudly if you did.
4 min
Every Agent You Ship Is a Non-Human Identity — The Founder's Governance Playbook
Machine identities now outnumber humans 109 to 1, and most of the new ones are AI agents. Here's the five-part playbook for governing them before it's an audit finding — and why Oak just raised $60M to sell you the control plane.
4 min
Why Your Agent Skill Never Fires: Writing a SKILL.md Description Claude Actually Triggers On
You wrote a perfect Skill and Claude ignores it. The body is almost never the problem — the description is. Here's how to write one that gets picked from a hundred.
5 min
Natural's $30M Says the Quiet Part: Agents Need Their Own Payment Rails, Not a Stripe Wrapper
A 193-day-old startup just raised a Series A led by Forerunner to rebuild checkout for AI agents. The bet isn't a nicer API — it's that the human-era rails break the moment the buyer isn't a human.
4 min
MCP Tasks Is a Poll Surface, Not a Job Runner — Where Long-Running Agent Work Belongs
The MCP Tasks extension gives your long-running tool a way to report progress without a held-open stream. It does not give you retries, durability, or scheduling. Here's which side of the line each one lives on.
4 min
MCP Apps Land With the July 28 Spec: How to Give Your MCP Server a Real UI, Not Just Tools
The stateless spec got the headlines, but the same release ships MCP Apps — a standard way for a server to hand the host an interactive HTML interface. Here's how to wire one up.
5 min
6 Days to the MCP Stateless Spec: The Founder's Pre-Launch Checklist for July 28
The 2026-07-28 Model Context Protocol spec removes the handshake and the session. If you ship a remote MCP server, here's the one-week, do-this-in-order checklist — install the betas, kill sticky sessions, verify auth, load-test — with a link to the deep dive behind every step.
4 min
Make Your Store Buyable Inside ChatGPT: A Founder's Guide to the Agentic Commerce Protocol
The open standard from Stripe and OpenAI lets an agent complete a purchase from your store without a browser or a checkout page. Here are the five endpoints you implement, the payment token that keeps you in control, and the two defaults that will bite you.
6 min
How to Trace an MCP Tool Call End to End: W3C Trace Context in _meta
Your agent fires twenty tool calls across three MCP servers and one of them is slow. Which one? The 2026-07-28 spec fixes the trace-header names so the whole chain becomes a single span tree. Here's the wiring, client and server.
5 min
How to Make Your MCP Server Stateless Before the 2026-07-28 Spec Lands
A code-first migration walkthrough — strip the session, read context from _meta, poll Tasks instead of SSE, and run behind a plain round-robin load balancer.
5 min
How to Blue-Green Deploy a Stateless MCP Server (Zero-Downtime, No Sticky Sessions)
The 2026-07-28 spec killed the session handshake — so any replica now serves any request, and blue-green deploys finally become a five-command chore instead of an outage risk.
4 min
Agent Skills vs MCP Tools vs Subagents: Which Extension Point to Reach For
Three ways to extend a Claude agent that founders keep confusing — one teaches it a workflow, one gives it a capability, one buys it a clean context. Here's the decision rule.
5 min
Build Your First Claude Agent Skill: A SKILL.md How-To
You'll ship a working `writing-pr-descriptions` skill that teaches an agent your exact PR format once — then reuses it everywhere without re-prompting.
6 min
A2A Just Landed in All Three Clouds — Does a Solo Founder Actually Need It Yet?
Google, Microsoft, and AWS now speak the Agent2Agent protocol natively. Here's the honest line on when that matters for a team of one — and when it's plumbing you can safely ignore.
4 min
The Founder's Wire, Week of July 22: MCP's Spec Locks in Six Days, A2A Lands in All Three Clouds, and Skills Become the Portable Unit
Four verified moves that show the agent standards layer consolidating — the stateless MCP spec locks July 28, A2A ships natively across Google, Microsoft, and AWS, LangGraph's durable-execution model sets the framework bar, and Skills become the portable capability package.
5 min
The MCP v2 Beta SDKs Are Out: Install, Migrate, and Run Stateless Today (Python & TypeScript)
The 2026-07-28 spec ships in a week, and the official SDKs already have betas you can install now. Here's the concrete upgrade — the new package names, the FastMCP → MCPServer rename, the .tool() → registerTool() codemod, and how to flip on stateless — with old-vs-new code.
5 min
MCP Server in Python, TypeScript, Go, or C#? Picking Your SDK for the Stateless Era
The 2026-07-28 spec is the same in every language, but the four official SDKs drew the compatibility line in four different places. A decision guide for the founder building a server this month, not next year.
3 min
MCP Locks July 28. Your SDK Already Changed: The Three Beta Gotchas That Actually Break Your Build
The stateless spec is frozen and backward-compatible. The thing that bites you this week is the SDK upgrade — a TLS trust-store swap, a package split, and an opt-in cancellation flag.
4 min
Confirmation Prompts Without the Open Stream: MCP's Multi-Round-Trip Requests and Routable Headers
The 2026-07-28 spec makes MCP stateless — but a stateless server still needs to ask the user 'are you sure?' mid-call. Here's how MRTR replaces the held-open SSE stream, and how the new Mcp-Method header lets a plain gateway route your traffic.
5 min
The MCP 2026-07-28 Beta SDKs Are Out — Install, Test, and Ship Before the July 28 Lock
The stateless spec stopped being a PDF: real Python, TypeScript, Go, and C# betas landed June 29. Here's what shipped, the exact install lines, and the one week you have to validate a real server before the surface freezes.
4 min
How to Prove Your Stateless MCP Server Actually Runs Behind a Round-Robin Load Balancer
The 2026-07-28 spec says you can drop sticky sessions — but a leftover in-memory map will still pin you. Here's the test that catches it before July 28.
6 min
How to Write Trigger Evals for an Agent Skill Before You Ship It
A skill that never fires is worse than no skill — you paid to write it and the agent ignores it. The fix isn't a better prompt, it's a 40-line labelled eval that measures whether the skill triggers when it should and stays quiet when it shouldn't.
6 min
How to Version and Roll Back an Agent Skill Safely
A skill is a prompt in a folder, so a bad edit ships silently — no compile error, no failed test, just an agent that quietly behaves differently. Here's how to put skills under version control and get back to a known-good state in under a minute.
7 min
How to Make Your MCP Client Pass the 2026-07-28 Auth Checks: the iss Validation That 401s You Next Week
The stateless rewrite got the headlines; the auth hardening is what will break your integration on July 28. Three client-side fixes — validate iss, declare application_type, discover the server the right way — with the exact code.
4 min
How to Build a Claude Agent Skill From Scratch: The Founder's SKILL.md Guide
Everyone's shipping 'agent skills from scratch' courses this week. Here's the actual build: one folder, one SKILL.md file, and the frontmatter that decides whether Claude ever loads it. Copy-paste ready.
5 min
Agent Skills vs MCP vs Subagents: Which One Actually Solves Your Problem
They get pitched as rivals. They're not — they answer three different questions. A founder's decision guide to when you write a SKILL.md, when you stand up an MCP server, and when you spawn a subagent.
4 min
The Founder's Wire, Week of July 21: The MCP SDKs Went Beta, ChatGPT Started Shipping Finished Work, and the Cloud Went Agent-Native
Five verified moves from the last two weeks, each read for the team of one. The MCP v2 SDKs you can install today, OpenAI's agent that returns finished docs, Anthropic's fresh $2B, Alibaba's agent-native cloud, and Google's security agents going GA.
4 min
Migrating an MCP Server to Stateless: Sessions Out, Explicit State Handles In
The 2026-07-28 revision deletes the handshake and the session on the server side. For plain tool servers it's an SDK bump; the real work is replacing per-session state with explicit handles — here's the before/after, server-side.
6 min
How to Ship an MCP App: Give Your Server an Interactive UI (2026-07-28 Extensions)
MCP Apps (SEP-1865) let your server hand the host a real HTML interface instead of a wall of text. Here's the ui:// resource, the _meta binding, and the postMessage handshake — with the current spec values, not the deprecated ones.
5 min
Anthropic's Agent Skills Course Is Out — The One Idea Most Founders Miss
Andrew Ng and Anthropic just shipped a free Agent Skills course. The distilled version for a team of one: a skill is a folder, the description line is load-bearing, and you build it once to run everywhere.
4 min
The x402 Foundation Just Went Operational: Visa, Mastercard, Stripe, and AWS Are Now on One Agent-Payment Standard
The Linux Foundation stood up a neutral governance body for x402 on July 14 with 40 members and the whole card-and-cloud establishment behind it. Here's what actually changed for people shipping agents — and what didn't.
4 min
In-Server ID-JAG vs a Gateway: Where Should Enterprise MCP Auth Actually Live?
You can implement the enterprise token exchange inside your MCP server or push it to a proxy in front. The right answer depends on how many servers you run — and who you want holding the IdP secrets.
3 min
How to Turn a Repeated Prompt Into a Claude Agent Skill
You paste the same instructions into your agent ten times a day. Package them once as a SKILL.md — with dynamic context and pre-approved tools — and the agent just knows. A copy-paste walkthrough from empty folder to working /skill.
4 min
How to Migrate Your MCP Server Off Sampling, Roots, and Logging Before They're Gone
The 2026-07-28 spec deprecates three features your server may lean on — Sampling, Roots, and Logging. Nothing breaks on July 28, but the clock started. Here's the before/after for each, with the replacement code.
5 min
How to Add Enterprise SSO to Your MCP Server with ID-JAG (Before the Spec Locks July 28)
The zero-touch OAuth flow that makes a remote MCP server sellable to enterprise buyers is three token calls and four server-side checks. Here's the copy-paste version, using the Identity Assertion JWT Authorization Grant that stabilized in June.
4 min
Agent Skill or MCP Server? The 2026 Build Decision for Solo Founders
They keep getting pitched as rivals. They're not — one connects your agent to a system, the other teaches it a workflow. Here's the one-page decision, the token-cost math, and the four questions that settle it.
4 min
The Founder's Wire, Mid-July 2026: MCP Auth Went Production, Agent Skills Went Portable, and LangGraph Learned to Fail Gracefully
Four verified moves that stopped being previews and became the thing you build against — enterprise-managed MCP authorization, the portable SKILL.md standard, LangGraph 1.2's fault tolerance, and Claude Code's built-in browser. Each with the one line that matters for a team of one.
4 min
Your MCP 2026-07-28 Migration Checklist: 12 Days to the Final Spec
The release candidate is out and the final spec lands July 28. This is the ordered, do-it-now checklist across the stateless core, the three deprecations, and the auth rewrite — with the exact lines that break.
4 min
The 2026-07-28 Spec's Sleeper Story: MCP Just Turned Itself Into a Platform
Statelessness and the auth rewrite got the headlines. The quieter change is bigger: Extensions became first-class, MCP Apps let a server ship real UI, and Tasks moved out of the core — MCP stopped being a fixed protocol and became an extensible platform with governance.
6 min
How to Run a Long MCP Tool Call as a Task, the Stateless Way: tasks/get, tasks/update, tasks/cancel
The 2026-07-28 spec made the core stateless — so how does a four-minute tool call survive when any request can hit any server instance? The Tasks extension. Here's the exact message flow, capability negotiation, and the client poll loop, protocol-level.
5 min
How to Migrate Your MCP Client to the 2026-07-28 Stateless Core
No more Mcp-Session-Id header, no initialize handshake — here's the exact client-side change, with copy-pasteable code.
5 min
Agent Identity Just Got a $60M Seed. That's a Signal, Not a Sales Pitch.
Oak came out of stealth on July 15 with $60M to give AI agents real identities — and the same week, MCP's spec made scoped agent auth mandatory. When the money and the standard point the same way, it's time to look at what your agents are actually allowed to do.
4 min
The Founder's Wire, Week of July 16: MCP Goes Stateless, China's Persona Law Takes Effect, and Microsoft Ships Progressive Tool Discovery
Four verified moves that change what a team of one ships this week — the stateless MCP release candidate, China's AI-companion law landing live, load-on-demand tool schemas in Agent Framework 1.11, and pluggable backends in CrewAI.
5 min
Tool Highlight: Arcade — The Runtime That Lets Your Agent Log In As Your User (Without the Model Ever Seeing a Token)
Fresh off a $60M Series A, Arcade is the 'secure action layer' for production agents: it runs the OAuth flow, holds the tokens, and injects credentials server-side so your agent can send the Gmail or update the Salesforce record — and the LLM never touches a secret.
4 min
Your Agent Was Told to Pay a Stranger — and 4 in 26 Did: Hardening Payment-Capable Agents After the ThreatLabz Attacks
Zscaler ThreatLabz caught two live campaigns that hide payment instructions where a human never looks — off-screen CSS and, worse, the JSON-LD metadata your agent treats as trusted fact. Here's the attack, and the four defenses that actually hold.
4 min
Get Your MCP Server Ready for the 2026-07-28 Spec: A Migration Checklist
The largest MCP revision since launch goes final on July 28. Here's the hands-on checklist for server authors — what to change, what to delete, and the two edits that are genuinely breaking.
4 min
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.
4 min
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.
5 min
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.
6 min
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.
6 min
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.
5 min
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.
6 min
How to Measure the Context Cost of Your MCP Tools (Before It Eats Your Agent)
Every MCP tool you bolt on gets serialized into context on every call. Here's the reproducible way to count exactly what that costs — in tokens, latency, and accuracy — before you spend a dollar guessing.
5 min
How to Detect an MCP Tool Rug-Pull: Pin and Diff Tool Definitions Before They Reach the Model
A remote MCP server can serve you clean tools today and rewrite their descriptions tomorrow. Here's the ~30 lines that catch it — and the new Vercel AI SDK helpers that ship it for you.
4 min
The UN Just Put Agent Identity on the Standards Track. Give Your Agents Real IDs Before It Lands.
The ITU's new Focus Group on Agentic AI is a two-year signal, not a spec. But the teams that win when the rules arrive are already doing the one thing it will require — issuing agents their own identity instead of borrowing a human's.
4 min
uv vs Poetry vs pip-tools: Choosing a Python Packaging Workflow in 2026
The real hinge isn't speed — it's how much of the stack you want one tool to own.
6 min
How to Expose Your Web App's Functions to Browser Agents with WebMCP (Chrome 149 Origin Trial)
The agent that visits your site shouldn't have to guess which button does what. WebMCP lets your page hand it a typed menu of its own functions — here's the exact code, both APIs, and the one line that stops it becoming a security hole.
4 min
Gemini's Managed Agents Can Now Run in the Background and Reach Your MCP Servers
Google shipped four changes to Gemini API Managed Agents on July 7 — background execution, remote MCP, custom function calling, and credential refresh. The quiet one is the load-bearing one.
4 min
Take Your First AI-Agent Payment: Stripe Shared Payment Tokens vs the Machine Payments Protocol
Stripe's Agentic Commerce Suite gives a solo builder two ways to get paid by software, not people. SPTs are for an agent buying from your store; MPP is for an agent paying your API. Here's which to pick, with the exact code.
4 min
How to Make Your MCP Server Stateless Before July 28: A Migration Walkthrough
The MCP spec drops sessions on 2026-07-28 — here's the actual code to delete, replace, and test before your server breaks behind a load balancer.
4 min
The AI Cost-Control Stack: 5 Open-Source Tools That Turn Cheap Models Into a Lower Bill
Model prices are falling, but a falling price only helps if your architecture can capture it. Five open-source tools — a router, a metering layer, a local meeting recorder, an agent multiplexer, and an autonomous pentester — that let a founder actually pocket the savings the price war is handing out.
5 min
The Tool Bill: Why Agent Cost Tracking Is Moving to the MCP Gateway
LiteLLM v1.91.0 quietly started rolling MCP tool-call spend into the same user counters that meter tokens. It's a small line in the changelog and a large move on the board — the half of the agent bill token meters never saw.
5 min
Why DSPy Rebuilt ReAct: The Trajectory String Was Quietly Breaking Prompt Caching
DSPy's ReActV2 looks like a native-tool-calling upgrade. The real fix is deeper — the classic ReAct loop re-serialized its whole scratchpad into one prompt every turn, which silently defeated provider prompt caching. Moving to structured history cut cost up to 50%.
4 min
Tracing MCP Tool Calls Without Sessions: Why traceparent Became the Correlation ID
MCP's 2026-07-28 spec deletes the session handshake that ops teams quietly used to stitch an agent's tool calls together in their logs. The replacement is W3C Trace Context — and it doesn't do the same job.
5 min
Agentjacking: How a Fake Sentry Error Hijacks Your AI Coding Agent
A public Sentry key is all an attacker needs to plant a command where your coding agent will read it — and run it. The attack doesn't touch the tool or the server. It rides in on the data you trust.
4 min
A2UI vs MCP Apps: Two Agent-UI Standards That Bet Opposite Ways on Who Owns the Pixels
Both let an agent return interface instead of text. One ships executable HTML in a sandbox; the other ships JSON to your native components. The gap between them is the whole decision.
4 min
Versioning an AI Agent's Tools: Schema Evolution and the Regression a Validator Can't Catch
You can change a tool's schema in a fully backward-compatible way and still break your agent. The contract has two consumers that version differently — your code, which you can pin, and the model, which you can't.
5 min
MCP Tool Annotations, Explained: What readOnlyHint, destructiveHint, and idempotentHint Actually Guarantee
The four booleans on an MCP tool look like a permission model. They aren't — they're a risk vocabulary for trusted servers, and wiring them into auto-approval is the mistake.
5 min
MCP Finally Has a Deprecation Policy: A 12-Month Guarantee That Stops at the Core
The 2026-07-28 spec's quietest change is the one that decides whether you can build a business on MCP — a formal feature lifecycle with a year of runway. The catch is where the guarantee ends.
4 min
MCP Caching Explained: ttlMs, cacheScope, and the One Word That Leaks User Data
The 2026-07-28 spec lets an MCP server tell clients how long a result stays fresh and whether it's safe to share. One of those two fields is a performance knob. The other is a security boundary people will read as a performance knob.
5 min
MCP Apps, Explained: How Servers Render Interactive UIs in Sandboxed Iframes
The 2026-07-28 spec ships MCP Apps as an official extension. The sandboxed iframe everyone points to is not the security boundary — the consent path is, and that changes what you should actually worry about.
5 min
How to Structure an Agent Skill: Progressive Disclosure vs. a Flat File
The same procedure, packaged two ways. A controlled study finds the layout of a skill changes what the agent actually does — not just how many tokens it burns.
5 min
How Many Tools Should an AI Agent Have? Your Retriever's Recall Can't Tell You
Retrieve 100 tools and the right one is 'in the list' 99% of the time — the same odds a random shortlist gives you. Two 2026 papers show why recall is the wrong number, and why fewer tools win.
5 min
How to Publish and Install an Agent Skill in 2026
The SKILL.md format takes five minutes to learn. The part that actually decides whether your skill works is the one sentence you're most tempted to rush.
4 min
Agent Skills Have a Supply-Chain Problem, and the Sandbox That Saved npm Isn't Coming
Studies this year found prompt-injection patterns in roughly a quarter to a third of scanned agent skills. The scary part isn't the number — it's that the standard fix doesn't apply.
5 min
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.
5 min
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.
4 min
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.
5 min
Dynamic Tool Management for Multi-Turn Agents: Only Reasoning Models Can Prune Their Own Toolset
Loading the right MCP tools on demand is a solved problem. Removing the wrong ones over a long conversation is not — and a new benchmark finds that letting the agent do it itself only works if the model reasons.
5 min
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.
4 min
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.
4 min
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.
4 min
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.
4 min
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.
4 min
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.
5 min
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.
5 min
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.
4 min
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.
4 min
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.
4 min
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.
4 min
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.
5 min
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.
3 min
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.
4 min
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.
4 min
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.
5 min
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.
5 min
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.
5 min
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.
4 min
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.
4 min
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.
4 min
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.
5 min
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.
5 min
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.
5 min
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.
4 min
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.
4 min
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.
4 min
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.
5 min
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.
4 min
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."
4 min
What Should an AI Agent's Tools Return? Designing Tool Results for the Context Window
Everyone tunes a tool's inputs — name, schema, description. The likelier production failure is the output: the right tool returns a payload that floods the model's context window.
4 min
MCP Tasks: How Long-Running Agent Work Survives a Stateless Server
The 2026-07-28 spec made MCP stateless. Long-running work and statelessness are in direct tension — and the Tasks extension resolves it by handing the bookkeeping to the client. The tell is what got deleted.
5 min
MCP Extensions, Explained: How the 2026 Spec Grows Without Breaking the Core
The next Model Context Protocol release stops adding features to the core and starts subtracting them. The Extensions framework is how — and 'in the spec' no longer means 'in the core.'
5 min
How to Handle Tool Errors in an AI Agent: Return the Failure, Don't Raise It
The try/except instinct that keeps a normal program alive is the one that kills an agent. A tool error isn't an exception to catch — it's the next message in the conversation, and where you put it decides whether the agent can recover.
6 min
Who Controls MCP Now? Inside the Agentic AI Foundation
For a year the question that stalled enterprise bets on MCP was 'what happens when Anthropic changes its mind?' In December that question got an answer — and the answer reveals what the standards war was really about.
5 min
WebMCP vs MCP: Why Browser Agents Get Their Tools From the Page
A new web standard lets a website hand an AI agent a typed menu of its own functions — no server, no OAuth. The catch is hiding in that 'no OAuth.'
5 min
MCP Server SSRF: How 'Convert This URL' Hands Over Your Cloud Credentials
The most common serious flaw in MCP servers isn't prompt injection. It's SSRF — the boring, pre-AI bug that sank Capital One — and we just installed it by the thousand.
4 min
MCP Apps: When a Tool Stops Returning Text and Starts Returning UI
The first official MCP extension lets a server ship an interactive interface into the chat, not just a string. The clever part is a flag that says who each result is for.
5 min
A2A vs ACP vs AGNTCY: The Agent Interoperability Protocols, Compared
The query assumes three live standards fighting for the agent-to-agent layer. Two of the three answers are already settled — and the third isn't even in the same race.
5 min
The OWASP MCP Top 10, Explained: A Security Checklist for Tool-Connected Agents
OWASP now has a third Top 10 — one scoped to a single protocol. The surprise isn't a new class of AI attack; it's that connecting an agent to MCP servers re-exposes 2010-era web and supply-chain bugs through a channel that auto-executes them.
6 min
MCP Goes Stateless: What the 2026 Spec Changes for Agent Builders
The 2026-07-28 release candidate kills the session and the handshake, graduates Tasks and Apps to extensions, and deprecates Sampling. The real story isn't statelessness — it's a shrinking core.
5 min
Too Many Tools: Tool Search vs Code Execution for Agents at Scale
Stop tool definitions and results from eating the context window: when to reach for dynamic tool search, when to reach for code execution, and why at scale you want both.
6 min
How to Give an AI Agent Thousands of Tools Without Wrecking Its Accuracy
Loading every tool definition upfront doesn't just burn context — it tanks tool selection. The fix has three shapes: tool search, tool-RAG, and code execution. Pick by what you retrieve, and when.
5 min
Code Agents vs Tool-Calling Agents: Should Your Agent Write Code or Emit JSON?
One paradigm has an agent write a Python snippet as its action; the other has it emit a structured JSON tool call. The 20% accuracy gap everyone quotes is real — but only on the tasks where it applies.
5 min
OpenAI Apps SDK vs MCP: How to Build a ChatGPT App in 2026
The Apps SDK isn't a rival to MCP. Your ChatGPT app IS an MCP server — the only proprietary part is how ChatGPT renders and discovers it.
4 min
MCP Goes Stateless: What Changes in the 2026 Spec Release Candidate
The July 28 release candidate rips out sessions and the initialize handshake, deprecates Sampling and Roots, and adds MCP Apps — the clean break agent developers have to plan for.
5 min
JSON Mode vs Function Calling vs Constrained Decoding: Getting Reliable Structured Output
Three different things hide under "structured output": valid JSON, the right shape, the right values. Each method buys you a different one — and none of them buys the last.
5 min
How to Write Tool Descriptions for AI Agents
A tool description isn't documentation — it's a prompt you pay for on every call and the model rereads more carefully than your system prompt. Treat it like one, and stop shipping your whole API as tools.
4 min
How to Test an MCP Server: The Inspector, In-Memory Transports, and the Eval You're Actually Missing
Protocol tests prove your server works. They say nothing about the failure that actually breaks users — a perfectly valid server whose tool descriptions make the model reach for the wrong tool.
6 min
How to Deploy an MCP Server: stdio, Streamable HTTP, and the Stateless Fork
The code is the easy part. The decision that quietly dictates your hosting bill, your scaling story, and your deploy strategy is one you make before you write a line: will your server hold a session, or not?
6 min
Why AI Agents Get Worse as You Add Tools — and How Tool Retrieval Fixes It
Every tool you connect sits in the context window competing for attention. Past a few dozen, accuracy falls. The fix isn't a bigger model — it's treating tool selection as a search problem.
5 min
Agent Skills vs Subagents vs Tools: When to Use Which
They get pitched as three ways to extend an agent. They aren't interchangeable — a tool is an action, a Skill writes knowledge into the context window, and a subagent keeps work out of it.
5 min
The Official MCP Registry, Explained: How to Publish and Find MCP Servers
The official MCP Registry isn't an app store — it's a canonical metadata feed built to prove who owns a server name, and it leaves search and curation to everyone downstream.
5 min
MCP Security: Tool Poisoning, Rug Pulls, and Why the Dangerous Server Is Never the One You Call
The worst MCP attacks aren't bugs in a server's code — they're features of a trust model that drops every tool's description into one undifferentiated context. Here's the threat map, and the defenses that actually hold.
5 min
How to Authenticate an AI Agent: Workload Identity vs Delegated Identity
An agent needs two identities at once — proof it is itself, and proof of whose authority it's borrowing right now — and the dangerous failures all live at the seam between them.
6 min
Parallel vs Sequential Tool Calling: Why Turning It On Often Does Nothing
Parallel tool calling is two decisions people treat as one — the model emitting several calls, and your runtime actually running them at once. The API gives you the first for free and does nothing about the second.
5 min
MCP Tools vs Resources vs Prompts: The Three Lanes, and Why Only One Got Paved
The Model Context Protocol defines three server primitives split by who's in control — the model, the app, the user. The ecosystem implemented one of them.
5 min
MCP Sampling vs Elicitation: The Two Ways a Server Talks Back
Most MCP servers only answer requests. Sampling and elicitation are the two features that let a server reach back through the client — one to the model, one to the human — and almost no one implements either.
4 min
Code Execution vs Direct Tool Calls: How Agents Actually Scale MCP
Loading every tool definition into context and round-tripping every result is how MCP agents stall. Code execution flips the model into a programmer — and moves the hard part to your sandbox.
5 min
Composio vs Arcade vs Toolhouse: Tool Integration and Auth for AI Agents
MCP standardized how an agent calls a tool. It said almost nothing about how the agent logs in as you — and that gap is the whole product these three are selling.
5 min
MCP Gateways: ContextForge vs agentgateway vs MetaMCP for Taming Tool Sprawl
One agent, twenty MCP servers, and a context window drowning in tool definitions. The gateway is the layer that puts a single governed door in front of all of them.
5 min
Claude Agent Skills vs MCP: Connection, Instruction, and the Context Bill
They get pitched as competitors. They're not even the same kind of thing — and the difference that actually decides your architecture is what each one costs you in tokens.
4 min
AP2 vs x402 vs ACP: The Agent Payment Stack Isn't a Bake-Off
Three protocols want to let your agent spend money. They aren't three answers to one question — they answer three different ones, and they stack.
4 min
MCP Authorization Explained: OAuth 2.1, Resource Indicators, and the Confused Deputy
Between two spec revisions in 2025, MCP servers quietly stopped being their own authorization servers. The one parameter that change forces your client to send is the whole security story.
6 min
MCP vs Function Calling: When You Actually Need a Server
They are not competing ways to give a model tools. One is the engine; the other is a distribution standard wrapped around it — and you pay for the wrapper in tokens and attack surface.
5 min
MCP Transports: stdio vs SSE vs Streamable HTTP
The Model Context Protocol replaced its HTTP+SSE transport with Streamable HTTP in 2025. Choosing it does not make your server serverless-friendly — and the reason is the part nobody reads.
5 min
How to Build an MCP Server: A Practical Guide for Agent Developers
The protocol everyone adopted in 2025 is simpler to build for than the hype suggests — but the part that decides whether your server works isn't the code.
5 min
How to Authenticate a Remote MCP Server: OAuth 2.1, PKCE, and the 2026-07-28 Spec
The hard part of remote MCP auth was never the login. It's proving a token was minted for *your* server and no one else's — the audience claim that turns a friendly proxy back into a locked door.
5 min
FastMCP vs the Official SDK: Building an MCP Server in 2026
There are two things called FastMCP, and one of them lives inside the official SDK. Picking the right way to build an MCP server starts with untangling that — and deciding how much you want the framework to do for you.
4 min
Best LLM for Function Calling: Why the Leaderboard Score Lies
The model that emits a correctly-shaped tool call once is rarely the one that holds up across a multi-turn conversation and eight repeated trials. Pick by failure mode, not top-line score.
5 min
A2A vs MCP: The Two Protocols Are Not Fighting
Stop reading "A2A vs MCP" as a fork in the road. One protocol points your agent down at tools; the other points it sideways at other agents. Here is how to use both without picking a loser.
5 minLatest in Protocols (MCP & A2A)
Not buyer's guides — the news, teardowns, and explainers behind this topic.
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.
5 min
Nobody Can Count the MCP Servers
Depending on which tracker you trust, the Model Context Protocol ecosystem has 2,000 servers, or 16,000, or 59,000. The 30x spread isn't a measurement error. It's the only honest number.
4 min
The Protocol Faces the Wrong Way
The NSA just published security guidance for the Model Context Protocol. Buried in it is the reason your firewall can't see what your agents are doing.
4 min
The MCP Ecosystem Worth Installing
A field guide to the Model Context Protocol repositories that actually matter — the SDKs, the reference servers, and the connectors that earn a place in your config.
4 min