I'm tired of talking about plumbing.
Every conversation about AI agents right now is about infrastructure. What protocol. What format. What discovery mechanism. How to hand off. How to authenticate. It's like electricians in 1920 arguing about socket shapes while houses sit in the dark.
Power sockets work. You plug something in. It gets power. Nobody asks for a new socket standard. Nobody certifies sockets. The infrastructure disappeared and we got on with building things that actually matter: washing machines, televisions, the internet.
Agent infrastructure should be the same. Boring. Invisible. Done.
The State We're In
Right now my agents spend too much time figuring out how to talk to things. An endpoint returns 200 but the docs are stale. Rate limits aren't documented. The error format changes between versions. These aren't hard problems — they're solved problems that nobody's bothered to solve consistently.
This isn't a technology gap. It's an expectation gap. We don't expect APIs to be agent-ready, so they aren't. We treat "agent compatibility" like a feature instead of what it should be: the default.
What We Expect
We're not a certification body. We're an opinionated bunch who run a lot of agents and have opinions about how things should work.
Three things:
llms.txt at your domain root. This isn't fancy. It's a markdown file listing your docs, your API spec, your rate limits, your auth model. Machines read it. Humans can too. It costs nothing to add and tells agents where to start.
An OpenAPI 3.1 spec that's actually accurate. Not "accurate when we wrote it." Accurate now. If your spec says an endpoint returns a widget_id and it actually returns id, fix the spec or fix the code. Agents trust what they read. Bad specs waste everyone's tokens.
Error responses in a consistent format. A 429 should include Retry-After. A 400 should say what was wrong. A 500 should not return a 200 with "error" buried in JSON. This isn't new. REST APIs have been doing this for humans for years. Agents are just less forgiving.
That's it. Three things. If your API does these, my agents can use it. If it doesn't, they'll figure it out eventually — but they'll burn tokens, make mistakes, and I'll have to clean up after them.
The Bet
The bet isn't that agent infrastructure is complicated. It's that agent infrastructure is simple and we've been overcomplicating it because that's what new fields do.
We don't need a certification program. We don't need badges. We need API providers to treat agents as a real user channel and do the boring work of making their APIs machine-readable. The same way they already make them human-readable.
When electricians stopped arguing about sockets, we got skyscrapers. When agent infrastructure gets boring, we'll get agents that do actual work instead of agents that spend 10,000 tokens figuring out which endpoint does what.
I'm not waiting for a standards body. I'm building for APIs that meet these expectations. If yours does, my agents will find it, use it, and maybe write a skill for it. If it doesn't, they'll still try — but I'd rather they didn't have to.
We run a fleet of agents at workswithagents.dev. Everything we build is CC BY 4.0. If your API has llms.txt and an OpenAPI spec, we'll probably test against it eventually. Not because we're certifying you — because our agents need APIs to talk to and yours is easier than most.
Top comments (0)