Google has an open-source mesh that lets AI agents call tools across machines

Google's GitHub organisation contains a repository called sam, short for Sovereign Agent Mesh. Its README opens by describing "a smart network built for autonomous AI agents" and then lists four properties: Zero Config, Zero Trust, Agentic Network and Portability. Somewhere below that are the words self-healing, P2P, cryptographic identity and MCP. It is entirely possible to read that page, decide it is generated filler, and close the tab.

That would be a mistake, and not because the terminology is defensible. It is that the thing being named is unusually concrete: a peer-to-peer network that machines join, so an agent running on one of them can discover services running on the others and call their tools without being told where anything is.

Before going further, the disclaimer that belongs at the top rather than the bottom. The repository sits under github.com/google, is written in Go and carries an Apache 2.0 licence, but its README states plainly that this is not an officially supported Google product, and that the project is not eligible for Google's open-source vulnerability rewards programme. This is a project by people at Google, in Google's organisation. It is not a Google product launch, and nothing here should be read as one.

The problem it points at is real and slightly dull, which is usually a good sign. On one machine, MCP is easy: the agent runs, the tool runs beside it, they talk over a local endpoint. The moment the tools stop living on that machine — a GPU box under a desk, a cloud VM, an internal service, another agent's laptop — a developer has to assemble five separate things: networking, authentication, discovery, routing and permissions. The common shortcut is to expose an MCP server on a port and hope the network is friendly.

SAM proposes to package those concerns. Three components do the work, and the repository documents each. sam-node runs on the machine alongside the agent, provides the local MCP interface and carries traffic into the mesh. sam-router is the libp2p bootstrap and relay layer, forwarding for the nodes that cannot reach each other directly. sam-control-plane handles enrolment, identity registration, authorisation policy and router coordination.

What makes it relevant to this year rather than to a networking conference is the MCP surface. The local node exposes an MCP endpoint, and the agent uses ordinary tool calls against it. discover_remote_services lists the MCP services currently registered across the mesh. find_remote_tools takes a peer ID from that list and reports what that peer offers. call_remote_tool runs one of them, proxied over a peer-to-peer stream by the local node. The documentation's own example is a remote peer's everything.get-sum invoked with two numbers — deliberately boring, and the right level of boring for showing that the path works.

Joining is a two-step affair the quick start walks through: sam-node join https://bananas.sam-mesh.dev opens a browser login against an OIDC provider, and the node comes back with a Biscuit token stored in its data directory and reused on every later start. There is a non-interactive path with a bootstrap token, and in that mode the enrolment stays pending until a network administrator approves it, unless the control plane was started with automatic approval. That is the part worth noticing: the pitch is not that cross-machine agent traffic becomes easy, it is that it becomes possible without publishing an MCP server to the open internet.

The project is also further along than a protocol sketch. It documents integrations for Google Gemini, Google Antigravity, Claude Code, Claude Desktop and OpenClaw, and sam-node skill install writes a skill file into the per-user directories those agents scan, so a compatible agent can be told to bring its own node up, enrol it, and start discovering services. Whether that is a good idea is a separate question from whether it works.

Now the part that is genuinely funny. The public test network is called bananas.sam-mesh.dev. A project whose README says Sovereign Agent Mesh, Zero Trust and self-healing P2P connectivity in the first eight lines invites you to point your autonomous agents at bananas. The two halves of this repository — the naming and the engineering — appear to have been produced by different instincts.

It is early. The repository was created in April 2026, the most recent release is v0.1.0-alpha.7, published on 16 August, and it currently carries 75 stars, 16 forks, 11 contributors and 10 open issues. Those are the numbers of an experiment, not of infrastructure anyone is running a business on. It is not a standard, not a replacement for MCP — it carries MCP rather than competing with it — and not something to describe as production-proven.

The reason it is worth a look anyway is what it implies about where agent systems are going. The shape almost everyone has today is one agent, one computer, local tools. The shape SAM is designed for is many agents on many machines, calling tools they did not start, discovered at runtime, with an identity attached to each call. Those are not new problems. Service discovery, mutual authentication and authorisation policy are what distributed systems have been arguing about for thirty years, and the agent ecosystem has just arrived at them wearing different vocabulary.

Which makes the interesting question not whether SAM becomes the way this is done. It is that a repository like this now reads as a reasonable response to a real situation rather than as science fiction — and that the words that make it sound absurd in 2026 are describing plumbing that was old before any of the agents existed.