Auth is the Universal Bright Spot

Every single site scores above 60% on auth. Developer tools have solved authentication — OAuth, API keys, well-documented token flows. This is mature infrastructure. If only the rest of the agent-readiness stack were this far along.

Errors and Cost are the Universal Weak Spots

Error handling scores are dismal — most sites return HTML error pages instead of structured JSON error envelopes. When an agent hits a 404 or a 429, it gets a pretty error page designed for humans, not a machine-parseable response it can act on.

Cost transparency is even worse. Only api.github.com and httpbin.org score above 50%. Most developer tools offer no programmatic way for an agent to understand what an API call costs, what the rate limits are, or how to optimize usage. Agents flying blind on cost is a real problem as autonomous agents start making purchasing decisions.

The API Paradox

Several sites with excellent APIs score poorly on the API check. Why? Because agent-bench tests the public-facing homepage, not the API subdomain. Stripe's API at api.stripe.com is world-class, but stripe.com is a marketing site that happens to link to docs. For agents discovering services, the entry point matters as much as the API itself.

This is exactly what llms.txt and A2A Agent Cards solve — they put machine-readable descriptions at the front door, not buried in the docs.

The Docs Gap

Documentation scores split into two camps. Shopify, Linear, Stripe, Vercel, and Notion all score 60%+ — they have llms.txt files, comprehensive docs, and structured API references. Stack Overflow and api.github.com score 0% — not because their docs are bad, but because they don't exist at the URLs agents check.

This reinforces what we found in the llms.txt adoption report: developer tools are adopting llms.txt faster than any other category (50% adoption), but there's still a long tail of holdouts.

What Would It Take to Hit 80%?

For most of these sites, going from 50% to 80% would require:

• Add llms.txt — a 10-minute task that immediately boosts the docs score
• Structured error responses — return JSON error envelopes with error codes, not HTML pages
• Rate limit headers — X-RateLimit-Remaining, X-RateLimit-Reset, Retry-After
• Cost metadata — endpoint pricing in a machine-readable format
• A2A Agent Card — /.well-known/agent.json describing capabilities

None of this is hard engineering. It's mostly metadata and headers. The tools themselves are often excellent — they just don't describe themselves in ways agents can consume.

The Takeaway

Developer tools are better than average on agent-readiness, but not by as much as you'd expect. The auth layer is mature. Everything else — discovery, error handling, cost transparency, machine-readable docs — is still early. The good news: for most of these platforms, getting to 80% is a weekend project, not a rewrite.

Run agent-bench on your own tools to see where you stand. And if you want the quick fix, drop in agent-layer middleware — it handles errors, rate limits, llms.txt, and discovery in a single app.use().

← The Accessibility–Agent Overlap | Agent-Readiness in E-Commerce →