TL;DR: Google, Microsoft, GitHub, Hugging Face, Nvidia and Salesforce backed a draft spec called Agentic Resource Discovery (ARD). It lets AI agents find and connect to tools and other agents at runtime instead of someone hard-wiring every integration. Most businesses don't need to adopt it tomorrow. They do need their systems in a state where an agent could actually use them. That groundwork is the unglamorous part, and it's the part worth doing now.
What actually shipped
A group of large vendors published an open spec for how AI agents locate, verify, and connect to tools, APIs, MCP servers, and other agents while they run. The idea is simple. An organization publishes a machine-readable catalog of what it can do on its own domain. Registries index those catalogs. An agent that needs a capability looks it up, checks the publisher is who they claim to be, and connects. No preconfigured integration for every pair.
It's plumbing. If you build internal tools for a living, plumbing is the stuff that quietly decides whether the fancy thing on top works at all.
Why a non-AI business should care
Picture where this goes. Today a person clicks through your app. Tomorrow their agent does the clicking, or skips the UI entirely and asks your system for the thing directly. Booking, reordering, checking a status, pulling an invoice. The businesses that win that shift aren't the ones with the biggest model. They're the ones whose systems can answer when an agent knocks.
Here's the catch nobody likes saying out loud. Most operational systems can't answer cleanly today. Half the process lives in someone's head. The "API" is a spreadsheet a person emails around. There's no clean way to expose a capability without also exposing the whole database.
That's the real work, and it has nothing to do with chasing a spec.
The shape of "agent-ready"
You don't need ARD to get ready for it. Three things matter, in order.
1. A capability is a defined thing, not a vibe. Before an agent can call "create a delivery booking," a human has to be able to describe exactly what that means: inputs, outputs, what can go wrong. If your team can't write it down, an agent can't run it.
{
"capability": "create_delivery_booking",
"inputs": {
"pickup_pincode": "string",
"drop_pincode": "string",
"weight_kg": "number"
},
"returns": { "booking_id": "string", "eta_hours": "number" },
"errors": ["serviceable_area_only", "weight_over_limit"]
}
That little block is worth more than it looks. It forces the messy process into something testable.
2. Expose the capability, not the system. An agent should reach a narrow, authenticated surface that does one job, not a connection to your core database. Wrap the capability behind a tool definition, gate it with real auth, and scope it tight.
# illustrative, MCP-style tool surface
def create_delivery_booking(pickup_pincode, drop_pincode, weight_kg):
assert_within_service_area(pickup_pincode, drop_pincode)
assert weight_kg <= MAX_WEIGHT_KG
return bookings.create(pickup_pincode, drop_pincode, weight_kg)
If an agent misbehaves, the blast radius is one function with guardrails, not your whole stack.
3. Log everything an agent does. When a non-human starts taking actions in your business, "who did this and why" stops being optional. An append-only audit trail of every agent call is the difference between a useful tool and an incident review.
What I'd skip for now
Publishing a public ARD discovery manifest and registering it. For a 40-person manufacturer or a regional clinic, that's premature. The spec is a draft, the registries are early, and your competitive edge isn't being the first to be discoverable. It's having clean, callable processes when it matters. Do steps 1 to 3. Watch the standard. Adopt it when there's a reason.
The unglamorous part is the moat
Agents are coming for the busywork. That part is genuinely close. The preparation is boring: define your processes, expose them safely, log them. Boring is fine. Boring is defensible. The companies that did the boring work will plug into whatever standard wins. The ones still running on tribal knowledge and spreadsheets will be standing outside the door when the agent knocks.
We build this kind of agent-ready plumbing inside traditional businesses for a living, mostly in logistics, fintech, and healthcare. If you're staring at a process that lives in someone's head and wondering how it ever talks to an agent, that's a solvable problem. More on how we think about it at athreix.com.
Top comments (0)