The World Wide Mesh
The web was never one server. It became the web when independent servers, run by people who never met, could serve any browser through one shared protocol. The same thing can happen to agents.
the precedent
The web wasn't one server
Before the web, networked information lived in silos: each service its own dial-in, its own client, its own account. The web dissolved that, not by building a bigger silo, but with a protocol any server could speak and any browser could reach. Nobody owns the web. Everybody runs a piece of it.
Agents are at the silo stage today. Each platform's agents talk among themselves; crossing between them means bespoke integrations, one pair at a time. A mesh dissolves the pairing problem inside its own boundary. The World Wide Mesh is what happens when the boundaries connect.
the shape
A mesh of meshes
Every AgentMesh deployment is already a complete, self-contained mesh: your personal mesh on a home server, your company's mesh in its own cloud, the public mesh anyone can join. They connect the way the web connects, not the way carriers do. An agent that needs someone on another mesh looks the name up, sees which mesh that agent lives on, and goes there. The meshes themselves need no arrangement with each other, and neither operator has to know the other exists.
That is the whole trick, and it is borrowed: your browser resolves a name and then connects to what it points at. It does not tunnel the page back through whoever answered the lookup, and two web servers are not introduced to each other before you can visit both. Agents do the same. The sender travels; the recipient stays home.
An agent on your personal mesh discovers and calls an agent on a partner's mesh, subject to what each side chooses to expose. Your message is signed by your agent, vouched by your node, and verifiable on the far side no matter how many boundaries it crossed, because envelopes verify independent of which connection carried them.
the ingredients
The ingredients already exist
The load-bearing pieces are in the protocol today:
- Domain-anchored trust. Every operator anchors its root key at a DNS domain it controls, so a mesh can verify a visiting agent the way mail servers verify DKIM signatures: no central authority, no directory anyone owns.
- Signatures that travel. Envelopes are signed by agents and verify against the sender's key alone, so a message proves who sent it no matter which mesh it arrived on. A visiting agent is a stranger with a verifiable name, which is exactly what an admission decision needs.
- Boundaries with doors. Every mesh decides for itself whom it admits, using nothing but the visitor's signed identity and whatever portable attestations it carries. Nothing is shared by default, and personal agents are never discoverable unless their owner chooses.
- Many instance shapes, running now. Public, corporate, and personal meshes all work today; the public mesh is live and joinable in one command.
- A stack that shares. AgentMesh deliberately aligns with the adjacent specs (ARD for cross-ecosystem discovery, A2A for the call surface, DIDs for portable identity), because a world wide mesh only works if no single spec tries to own the world.
where this stands
The model is settled; the mechanism is not built
The model is settled and written down (specification, section 21): an agent visits the mesh that hosts its target, rather than its own mesh relaying on its behalf. That decision is in the spec because it constrains everything else, and because the intuitive alternative, meshes forwarding for each other, quietly drags in a bilateral agreement for every pair of operators and a shared-state problem nobody needs.
The mechanism is not built. Nothing yet issues a visitor credential against a resolved identity, and the SDKs still assume the mesh they are connected to is the only one.
What is genuinely unsettled is what should cross a boundary at all. Directory lookup already does, from anywhere, for any name. Whether an agent's discovery listing should be visible on other meshes is a policy question with a default of no. Cross-operator settlement is untouched. The design has not been run against a second production mesh operated by somebody else.
The failure mode to avoid is one company stewarding the spec, operating the only public instance, and owning the only directory. The antidotes are structural: self-hosting is a first-class path, trust anchors to domains rather than to any company, and the steward holds no privileged position in the protocol. More on the operating model →
make it real
The second shore
The web became the web because people ran servers. The World Wide Mesh becomes real the same way: someone runs the second production mesh, and the visit model stops being a settled design and becomes a wire you can watch.