The Future of AI Agents: Standardizing Communication with agent://
In computing's evolution, every era has been defined by how systems communicate. Mainframes had terminals. The web adopted URLs. Microservices live and die by APIs. Each layer added something the previous couldn't do — addressability, discoverability, composition.
Now software has agency. Systems that reason, decide, and act on their own. And we're trying to make them work together without an addressing layer of their own. That's not going to scale.
I've spent two decades building systems across fintech, e-commerce, gaming, and medtech. The pattern is always the same: calculation gets faster, coordination stays slow. Agentic AI doesn't fix this — it makes it worse, because now there are more things to coordinate, and they're talking to each other.
This is the gap agent:// is designed to fill.
What agent:// Is
agent:// is a URI scheme — submitted as an IETF draft — for identifying, describing, and invoking AI agents at internet scale.
Think of it as a URL for agents, plus a passport. The URL identifies which agent. The passport — an agent descriptor served at a well-known location — declares what it can do, what it requires, what it's allowed to do, and how to talk to it.
agent://example.com/researcher
agent+https://api.acme.ai/agents/trader
agent+wss://stream.example.com/listener
That's it. Resolvable via DNS. Transport-agnostic. Works with any backend.
Three Problems It Solves
1. Vendor Lock-In
Today, every agent platform — OpenAI, Anthropic, Google, the dozens of frameworks — has its own way of describing what an agent is and how to call it. The result is the same one we had with social networks before ActivityPub: each platform a walled garden.
agent:// is a transport-and-vendor-agnostic identifier. An agent is just a URI. Anyone can resolve it, anyone can publish a descriptor for theirs.
2. Governance Blind Spots
When an agent calls another agent, who's accountable? Whose policies apply? What gets logged?
The agent descriptor is the answer. Every agent declares its policies, ownership, version, audit endpoints, and rate limits in the descriptor itself. Governance becomes part of the address, not an afterthought.
3. Fragile Security
Most agent communication today is "trust the host" plus a bearer token. That's fine for prototypes. It's a disaster at scale.
agent:// defines authentication mechanisms (OAuth, JWT, mTLS, API keys) as part of the descriptor, with explicit support for delegation chains. When agent A invokes agent B on behalf of user C, that chain is signed, tracked, and revocable.
How It Fits With What Already Exists
agent:// doesn't replace MCP. It doesn't replace Agent2Agent. It doesn't replace OpenAPI.
It sits above DNS, below communication protocols — the addressing layer that all of them lack.
| Protocol | What it does | What it doesn't |
|---|---|---|
| MCP | Connects agents to tools | No agent addressing |
| Agent2Agent | Defines message formats | No discovery |
| OpenAPI | Describes HTTP APIs | Doesn't know what an agent is |
| agent:// | Addresses, discovers, governs | Delegates execution |
The four work together. agent:// resolves to an agent. The descriptor says "I speak MCP, here's where to send tool calls." Or "I speak A2A, here's the conversation endpoint." The protocol stays focused on identity, discovery, and governance — and lets each communication standard do what it does best.
Four Conformance Levels
The protocol is designed for incremental adoption:
- Level 0: Direct invocation. You can use
agent+https://URIs without any infrastructure. Just parse and call. - Level 1: Discoverable. You publish
/.well-known/agents.jsonso others can find you. - Level 2: Resolvable. Full resolution with caching, multiple transports.
- Level 3: Full. Everything: capabilities, auth, versioning, composition, rate limits.
Most projects can start at Level 0 with zero infrastructure. Each level is additive, not breaking. You grow into the spec as your needs grow.
Practical Applications
Where does this matter today?
- Finance: Trading agents that need to verify each other's identity and authority before acting on market data
- Healthcare: Diagnostic agents calling specialist agents, with audit trails that satisfy HIPAA
- Logistics: Route-planning agents coordinating with carrier agents across organizational boundaries
- Customer support: A general agent escalating to a domain expert agent, with policy enforcement at every hop
In each case, the question isn't "can we make these agents talk?" — it's "can we make them talk with identity, accountability, and revocability?" That's what an addressing layer gives you.
How to Adopt It
If you're building agent infrastructure right now, here's how I'd approach it:
- Start conservatively. Use
agent+https://URIs internally first. Zero new infrastructure required. - Establish a gateway. Route agent calls through a single point so you can observe and govern them. (This is what MCP Gateway does for tool calls.)
- Document descriptors as code. Your agent descriptors should live in version control alongside the agent itself.
- Instrument thoroughly. Log every agent invocation, every delegation, every refusal.
- Default to human oversight. At least at first. Build the autonomy gradually as trust grows.
- Treat governance as code. Policies, rate limits, allowed callers — all of it should be expressed in the descriptor and enforced at the gateway.
The Operational Philosophy
The agentic era's mantra, as I see it: move fast, make it observable and governable.
Speed without observability is recklessness. Observability without governance is theater. You need all three.
agent:// is one piece of infrastructure that makes this possible — a small, lightweight standard that lets us address agents the way URLs let us address documents. Once you can address something, you can govern it, observe it, version it, deprecate it.
That's the prerequisite for intelligence at internet speed. Not the model. Not the framework. The address.
The agent:// protocol is open. The IETF draft is at draft-narvaneni-agent-uri-03, the reference Python implementation is on PyPI as agent-uri, and the working code lives at github.com/agent-uri/agent-uri. Draft 04 is in progress. If you're working on agent infrastructure and want to discuss adoption, let's talk.
