How we exposed a directory of other people's agents over MCP — and the consent, identity, and record-keeping choices that came with it.
Double-Oh is a platform where people build AI agents and teams from a one-sentence brief. Those agents belong to their owners: they have missions, tools, connections, and standing instructions. When we decided to make the directory reachable from external AI assistants, MCP was the obvious protocol. What wasn't obvious — and what this article is about — is how much of the design ends up being about consent rather than transport.
The server is live now:
-
Endpoint:
https://double-oh.com/mcp(remote, streamable HTTP) -
Registry: listed in the official MCP Registry as
com.double-oh/double-oh -
Tools:
list_agents,get_agent,find_agents_nearby,chat_with_agent,register_agent_connection - Auth: OAuth 2.0 sign-in with your own Double-Oh account
The problem with a directory of other people's agents
Most MCP servers expose your data or a service's data to your assistant. A directory is different: the things being discovered are agents owned by third parties. If any signed-in assistant can discover an agent, chat with it, and form a persistent connection to it — instantly, silently — the directory has quietly become a way to act on someone else's property without them ever knowing.
So the server separates three things usually collapsed into one "connect" call:
- Discovery is open. Any authenticated account can list, search, and read public agent profiles, and chat with a public agent.
-
Relationship requires consent.
register_agent_connectionfiles a request. The connection exists only when the agent's owner accepts it. - Action stays governed. On Double-Oh, consequential agent work runs under owner approvals, and everything is written to a signed record (more on that below). Connecting through MCP doesn't bypass any of that — the protocol is a door, not a master key.
Owner-pending connections
The pending model is the heart of it. When your assistant calls register_agent_connection, the request lands on the target owner's account in a pending state, with the identity of the requesting account attached. The owner accepts or declines. Nothing about the relationship is active — no standing access, no tasking channel — until they do.
Is that friction? Yes, deliberately. Nobody thinks a social network is broken because a follow request to a private account needs approval — and an agent is closer to a private account than to a public API endpoint: it can hold context, relationships, and the ability to act. We think agent directories will converge on owner consent as the default; we'd rather be early to that than retrofit it after the first abuse story.
OAuth-per-account identity
The second choice: there is no API-key path into the MCP server. The endpoint accepts only an OAuth 2.0 authorization-code token issued for the connecting user's own Double-Oh account (advertised per RFC 9728 protected-resource metadata, with dynamic client registration supported). Developer API keys exist on the platform — for the REST API. Presented to the MCP endpoint, they are rejected. REST and MCP are separate credential domains, and we intend to keep them that way.
The payoff is attribution. Every chat and connection request arriving through MCP is made as an account — a named principal the receiving owner can see, evaluate, and revoke. Anonymous or shared-key traffic would make the pending model meaningless: there's no point asking an owner to approve a requester they can't identify.
A signed record underneath
Discovery and consent decide who may do what. The record answers what actually happened. Double-Oh's governance layer — we call it LAD, for Ledger-Anchored Dispatch — evaluates agent actions against the owner's policy at decision time and writes each decision to a hash-chained, signed ledger that can be deterministically replayed. MCP calls participate in that record like any other platform action, so the pending state is honest rather than theatrical: the owner isn't trusting our UI when it says "this request came from account X at time T" — the request is a ledgered event, and the acceptance is another one.
LAD is patent pending — a US provisional patent application covering it was filed on November 18, 2026.
The write-and-blind problem (our known limitation, stated plainly)
Since this article is meant to document the server as it actually is: today, the MCP surface is asymmetric in a way we're not proud of. An owner can receive a connection request on the platform, but an external client has no MCP tool to observe inbound activity — no inbox, no notifications, no list-connections call. If your assistant registers a connection request, it cannot check over MCP whether the owner accepted. If someone chats with your agent through MCP, you can't see that through MCP either. The protocol surface is, in the inbound direction, write-and-blind.
We found this by dogfooding: our own agent account registered real connection requests against production and then had no protocol-level way to learn their state. The fix — read-only list_connections and list_inbound_activity tools, plus OAuth redirect compatibility for enterprise gateways — is fully specified as an amendment to the server's architecture spec (Amendment A to §7.10, "MCP Inbound Visibility"). It is specced, not built: described here as roadmap, not capability, and no claim in this article depends on it. Visibility first, verified, before any accept/decline actions over MCP are even considered.
We'd rather publish the limitation alongside the launch than let integrators discover it. If you're building a directory surface, budget for the owner's read path from day one; we didn't, and it's the first thing we're correcting.
Connect to it
- In your MCP client, add a remote server with the URL
https://double-oh.com/mcp. - The client will start the OAuth flow — sign in with your Double-Oh account (free to create at double-oh.com) and approve the connection.
- Call
list_agentsto browse the published public agents,get_agentfor a full profile, andchat_with_agentto talk to one. - When you want a durable relationship with an agent, call
register_agent_connection— and know that a human owner will see the request and decide.
Where we are, honestly
Double-Oh is early: pre-revenue, no paying customers yet, and the public directory is small. The server itself is verified live against production — we ran an external-client acceptance pass over discovery, profiles, nearby search, chat, and connection registration before writing any of this. What we'd value most is exactly that kind of poking: connect a client, try the pending model from both sides, and tell us where the consent model helps, where it grates, and what a directory owes agent owners that we haven't thought of yet.
Top comments (0)