Inside about two weeks in May, three of the biggest names in the business reached for the identical vocabulary. Google used its I/O keynote to introduce Gemini Spark, a “24/7 personal AI agent,” alongside Antigravity 2.0 and a Managed Agents API for spinning up custom agents in a hosted environment. ServiceNow expanded what it calls an Autonomous Workforce: role-scoped AI “specialists” for IT, HR, finance, legal, procurement, and security that, in the company’s words, complete entire business processes from start to finish. Anthropic shipped Claude Managed Agents with self-hosted sandboxes so you can run agents inside your own perimeter. Different companies, different products. One pitch: stop thinking of AI as a tool. Start thinking of it as staff.

The metaphor is everywhere now because it works. You hire an AI employee, give it a role, connect it to your systems, set expectations, review the output. It really does feel like onboarding a sharp junior who never sleeps. The framing is intuitive, it lowers the barrier for non-technical teams, and it turns a genuinely new capability into something a manager already knows how to handle.

That is exactly what worries me about it.

The Metaphor Smuggles In an Org Chart That Doesn’t Exist

Let me be specific about what the word “employee” quietly imports. When you hire a person, you inherit an entire accountability structure you never think about because it came free with the category. Performance reviews. Coaching. A clear chain of authority. The ability to correct a mistake, document it, and if it keeps happening, let the person go while keeping what the team learned. A human who makes errors costs you time and some embarrassment, and that cost is bounded by how fast one person can work.

None of that infrastructure transfers to an agent. There is no coaching loop. There is no chain of authority that terminates at a person. When you “let go” of an AI employee, it takes no institutional knowledge with it, because the knowledge it accumulated never lived with you in the first place. It lived in the vendor’s platform.

Here is the gap that nobody flags during onboarding. The first time I stood up an agent with real access to a production system, the setup checklist had everything the employment metaphor predicts: a role, a tone, a list of systems to connect, a scope of work. It had nothing about what happens when the thing is confidently wrong at three in the morning, and nothing about who can stop it. The checklist was a job description. What I actually needed was an operations runbook.

There’s a Discipline That Already Has the Right Words, and It Isn’t HR

Engineers who run systems at scale have spent decades building precise language for “an autonomous process is doing damage, now what.” It is worth borrowing wholesale.

The blast radius is how much damage accrues before something stops it. A circuit breaker is the condition under which a process stops acting on its own and escalates to a human. A rollback is how you undo what it did in the last hour. A kill path is how fast you can halt every agent of a given type, measured in minutes, not meetings. Treat an AI employee as what it operationally is, a replicated process running at machine speed, and these four questions stop being exotic. They become the first things you ask.

You can’t fire a process. You can only kill it.

A caution, because the production-service framing can overreach. Calling an agent a production service is a claim about the controls it needs, not a verdict on what it is. The first is settled. The second is not, and pretending otherwise would be the same overconfidence I’m arguing against. If anything, the frame earns its place precisely because an agent is less predictable than a classic process, which fails in known ways, and less accountable than an employee, who has a shared stake in the outcome. The failure surface is wider than either metaphor admits.

There’s a second reason the blast radius runs hotter than you’d expect, and it comes from economics rather than engineering. Your AI employee has a different employer. Its operating constraints were set by the vendor that trained it, not by you, so the thing making decisions inside your systems is ultimately answering to terms you didn’t write. And the risk scales with autonomy, which means the metaphor gets more dangerous exactly as the vendors deliver the autonomy they’re selling.

So the question is not how you onboard your AI employee. A human who errs costs you time. An AI employee who errs at machine speed costs you scale, because you deployed a production service and called it a hire.

The Metaphor Earns Its Keep, Right Up Until It Doesn’t

The honest counterargument is that the employment frame is doing useful work, and I don’t want to wave that away. Telling a manager to “onboard an AI specialist” gets them to scope a role, grant least-privilege access, set expectations, and review output, which is most of the governance posture an engineer would prescribe anyway, just wearing HR clothes. And the vendors are not hiding the controls. Anthropic shipped sandboxes and private network tunnels as enterprise infrastructure. ServiceNow scopes its specialists to roles with audit trails. The dashboards and permission scopes exist.

It’s entirely possible the employment metaphor is the fastest way to get a non-technical organization to adopt good governance. That’s a real point, and it should make anyone arguing my side a little nervous.

Here’s where it breaks. Onboarding has an analog for scoping a role and reviewing work. It has no analog for a circuit breaker, a rollback, or a kill path, because you have never needed to halt a human employee inside sixty seconds or undo everything they touched in the last hour. The metaphor covers the parts of governance that map to managing people and goes silent on exactly the parts that don’t. It doesn’t force operators to skip the controls. It invites them to, by making the whole exercise feel like staffing instead of engineering.

What an AI Agent’s Blast Radius Looks Like in Production

This is not a thought experiment. Two recent examples.

Start with the toolchain, because that’s the blast radius people forget they own. In May, a self-propagating worm tore through the npm and PyPI ecosystems and reached straight into the agent layer, hitting developer tooling and AI libraries including Mistral AI and Guardrails AI. The part that matters: the malicious packages were published with valid build-provenance attestations, produced using legitimate signing identities that the attacker had hijacked. In plain terms, the automated check designed to confirm a package was authentic looked at the poisoned versions and said they were clean. The fix is the posture you’d put around any production service, not a new hire: scanning that looks at package behavior rather than just signatures, narrowed token scopes, pinned build steps. Not headcount thinking. Blast-radius thinking.

The other shows up as a number on a finance report. Uber handed Claude Code to its engineers, ranked teams on an internal usage leaderboard, and burned through its entire 2026 AI coding budget in roughly four months. The tool worked. The bill was the problem, and Uber’s own COO has since said he can’t yet draw a clean line from the token spend to shipped value. Around the same time, Microsoft told one of its largest engineering divisions to move off Claude Code by the end of June, partly on cost and partly to consolidate on its own tooling, even as it kept investing in Anthropic everywhere else. Read those two stories not as “AI is expensive” but as what they are: an autonomous process with no throttle is a blast-radius problem denominated in dollars.

What Changes on Monday

If you take the production-service framing seriously, three things change before you deploy anything.

First, get three answers in writing from any platform before you “hire” its agent. “What operating constraints can I not override?” “Who is liable when the agent takes a consequential action I didn’t intend?” “If I leave your platform, what happens to the workflow knowledge this agent accumulated?” If the vendor can’t answer all three, you are not hiring an employee. You are renting a capability you can never fully transfer.

Second, require three controls at deployment that no onboarding checklist will prompt you for. A circuit breaker, with written conditions under which the agent stops and escalates. A rollback procedure, so you can undo the last hour of its actions. And a kill path you have actually tested, so you can halt every agent in a category in minutes. If your rollout doc has a role, a tone, and an integration guide but none of these, you’ve written a job description for something that can’t be fired.

Third, budget the throttle. Price the loaded cost, oversight and error recovery included, not the API line against a salary line. The unthrottled bill is just the blast radius showing up in a place finance already watches.

None of this is exotic. It’s the same discipline that separates a production system that stays up from one that pages you at midnight. It only looks novel because we agreed to call the thing an employee.

The Word Was the Problem

The risk was never that AI employees don’t work. Plenty of them work, which is exactly why the metaphor is so easy to accept. The risk is that the word “employee” deletes the engineering you would have done by reflex if you’d called the thing what it is. The labor-market data still shows no clear AI footprint on employment, which is a good hint that “will it take the job” was never the operator’s real question. The real question is what you’ve actually wired into your systems, and whether you can stop it.

Name it a production service and the right questions show up on their own. Whose name is on the blast radius is a better one to answer now than at three in the morning.

The post Your AI Employee Needs a Circuit Breaker, Not an Onboarding Plan appeared first on Top Rope Media.

My recent integration work has got me thinking.

The first vendor was Google Ads. I never spoke to anyone — signed up with an email, ran their quickstart, hit a snag in the OAuth flow, found the fix three sentences into their auth doc, and was making real requests inside an hour. The second vendor I also never spoke to. Signup form to working integration in roughly the same window. The third was different. I went looking for it — knew the category, knew the company name, walked in with intent. Their docs page redirected me to a “book a demo” form. Within days I’d shipped against a competitor.

Different vendors. Different categories. Different price points.

Same dynamic.

Two of them got onto my integration shortlist without ever knowing I was a prospect. One of them lost the deal before they knew there was one. The agent did the shopping — the synthesis tool I’d been pasting their docs into all afternoon, the assistant I asked to compare authentication flows, the model I ran the rate-limit math through. The vendor’s funnel still assumed a human knocked on the door. The buyer’s funnel didn’t have a human in it.

That’s when I started thinking about this less as a developer-experience question and more as a distribution one.

The Buyer’s Funnel Doesn’t Have a Human In It

Let me be specific about what I mean. The dominant story in B2B leadership rooms right now is that public docs and self-serve APIs are a developer-experience investment you fund post-Series-B. Sales-led growth funded the company. AEs scope integrations. Demos generate pipeline. Custom implementation work preserves margin. The motion converts; why diversify surface area now?

It’s a rational default. It built most of the enterprise software economy we have today.

Here’s the context that often gets left out. 94% of B2B buyers now use LLMs during their purchase journey, primarily as synthesis tools mid-funnel — comparing offerings, evaluating proposals, summarizing what they’ve gathered. Two-thirds say they’d prefer to buy without engaging a sales rep at all. Gartner forecasts that by 2028, 90% of B2B buying will be agent-intermediated, pushing roughly $15 trillion through agent-driven exchanges.

The so-what doesn’t depend on the forecast. The present-tense data already says the buyer’s funnel doesn’t have a human in it. The vendor’s still does. That’s the gap that gets you cut from the consideration set before you knew there was a deal.

There’s a Discipline That Already Speaks This Language

This isn’t a marketing story. It’s a distribution one — and there’s a mature discipline with the vocabulary for it.

Retail merchandising. Specifically, shelf-space economics: the body of practice that governs how products get found, picked up, and bought when the buyer is making a hundred adjacent comparisons in a finite window. Shelf, placement, planogram, end-cap, category captain, slotting fee. These aren’t metaphors. The dynamics are identical. An agent shopping the API landscape is doing exactly what a buyer does walking down an aisle: scanning labels, evaluating fit on a small set of legible signals, putting one item in the cart.

Once you have the vocabulary, the maturity arc falls out.

Stage 1 is being on the shelf at all. There is a public schema. There is a quickstart that runs without a human in the loop. A developer — or an agent acting on a developer’s behalf — can find your endpoint, evaluate your auth flow, and ship a first request without speaking to anyone at the company. If you’re not at Stage 1, you’re not in the consideration set. You don’t lose the deal. You don’t get evaluated.

Stage 2 is earning placement. Your docs are clean. Your error messages explain themselves. Your rate limits are honest. Your idempotency is documented. Your examples compile on first paste. You’re the API the agent reaches for first because the friction of integrating you is lower than anyone else in the category. Stage 2 is where competitive advantage actually lives in 2026 through 2028.

Stage 3 is becoming the category captain. Your name is in the prompt. Developers and the agents working for them say “Stripe” when they mean payments, “Twilio” when they mean messaging, “Plaid” when they mean bank connections. You’re the default that other names get compared to. Category captains in agentic-discovery markets get set by who reaches Stage 2 first and compounds longest.

Public docs are how you exist. Tool quality is how you win.

Three Stages, Four Examples

The three integrations I started with were each at a different stage. The two that made my shortlist were Stage 2 — clean public quickstarts, OAuth that worked first try, docs doing the selling. The one I’d hunted by name had slipped backward into a sales-call gate. Category captaincy slipping in real time.

Stage 0 has two flavors, and I’ve shipped against both.

Bloomberg actually publishes its API documentation. The BLPAPI Developer’s Guide is a public PDF. The HTTP API has a public GitHub repo. What’s gated is access, not docs. To use the API you need either a Terminal subscription — roughly $30,000 per seat per year — or an enterprise data contract negotiated through a sales conversation. There’s no developer signup. The shelf is real, the labels are pristine, and the buyer can’t reach it.

The same dynamic shows up smaller. An equestrian streaming platform we work with: IP-whitelisted API, server-side only, documentation that arrives by email after you ask. Different scale, same gate.

Then there’s Substack. I publish on it, and when I wanted programmatic access for an automation, the only path was a cookie-auth shim against an undocumented surface — no published schema for the publishing surface. The shelf isn’t gated; the labels just aren’t there. Two flavors of Stage 0: docs published but access locked, or access available but nothing to read.

The pre-agent precedent for Stage 3 is Stripe, Twilio, and AWS. Stripe didn’t outcompete Braintree on processing economics. They outcompeted on a signup that worked in seven lines of code while competitors were still running multi-day merchant-account approvals, and on documentation a developer could actually read. Twilio’s 2016 S-1 said the same thing in SEC language: revenue depended on self-service adoption by developers, and over a million developer accounts had registered by IPO. AWS got there earlier — S3 launched in March 2006 on an email address and a credit card, with enterprise sales infrastructure built years later on a developer base AWS had already won. All shelf-space plays, a decade before agents made the play structural. None of these are stories about devrel as a cost center. They’re stories about distribution as the moat.

The present-tense version is at the protocol layer. Anthropic released the Model Context Protocol in November 2024, betting that whoever published the standard for tool schemas would shape the ecosystem. Twelve months later, Anthropic donated MCP to the Agentic AI Foundation, a new directed fund under the Linux Foundation co-founded with Block and OpenAI — each contributing a project of their own. Platinum members include AWS, Bloomberg, Cloudflare, Google, and Microsoft. Textbook captaincy graduation: a vendor protocol becoming open infrastructure. Publishing the interface didn’t dilute the position; it locked it in.

The Sales-Led Argument Deserves a Real Answer

There’s an honest objection worth taking seriously. Sales-led GTM has built most of the enterprise software companies that matter. Custom implementation preserves margin self-serve can’t. AE-driven scoping protects deal velocity in real enterprise sales — procurement, security review, six-stakeholder buying committee. Diversifying surface area too early dilutes focus and creates support cost the company isn’t ready to absorb. Every one of those points is real.

But here’s what’s worth noticing. None of those arguments contradicts the shelf-space frame. They argue for keeping the sales-led motion for the deals where it works — large, complex, multi-stakeholder enterprise contracts. The shelf-space play isn’t a replacement. It’s the play for the part of the buyer base that doesn’t behave like a procurement committee anymore: the engineer at a target account who’s been told to evaluate three vendors by Friday, who pastes your docs into an LLM after dinner and decides on Monday which one procurement should call. That engineer is the shortlist gatekeeper even for the deals that close through sales. Cutting yourself off from her upstream because the downstream contract still needs an AE doesn’t preserve the motion. It cedes the shortlist.

What This Actually Changes

For an operator weighing whether to fund this work, four things follow.

First, Stage 1 is overdue, not Series-B-funded. If your interface isn’t readable by an agent today, you’re not in the consideration set tomorrow. The budget conversation isn’t “should we fund developer experience?” It’s “should we be visible in the discovery layer agents are using now?” Asked that way, the answer is forced.

Second, Stage 2 is the durable bet. Within 18 to 24 months, every serious competitor will reach Stage 1. Shelf presence becomes table stakes. Differentiation moves to tool quality — schema clarity, error messages that diagnose themselves, idempotency, rate-limit honesty, examples that compile on first paste. That’s where engineering compounds.

Third, the first hire is DX engineering, not developer marketing. “Developer evangelist” is a 2018 job title. The 2026 version is the engineer who writes API docs, designs schemas an LLM can parse cleanly, and maintains examples that don’t rot. Senior engineering hire, not marketing.

Fourth, stop scoping integrations and start measuring picks. If your sales motion treats every integration as a custom implementation, you’re optimizing for the wrong unit. Measure how often agents pick you over the alternatives. That’s the leading indicator for the next 18 months of revenue. Instrument for it now.

None of that is rocket science. It’s just discipline — the discipline that separates a company that compounds for a decade from one that gets a great quarter and a soft landing.

Close

The pattern shows up everywhere the buyer is a developer or an agent acting on a developer’s behalf. Payments, messaging, identity, observability, ad-tech, analytics — anything where the integration is the product. The companies that publish their interfaces this year will define their categories. The ones that don’t will be footnotes in someone else’s quickstart guide.

The internal conversation isn’t “are we ready for devrel?” It’s “are we visible to the buyer the buyer has become?” One of those questions gets a budget. The other gets the category.

The vendors who exist tomorrow are the ones whose interfaces an agent can read today. The vendors who win are the ones whose interfaces an agent reaches for first.

The shelf is already there. The agents are already shopping.

The post I Connected Three APIs This Week. None of Their Vendors Knew I Was Shopping. appeared first on Top Rope Media.

The post After Integration, the Actuarial Table appeared first on Top Rope Media.