Agent Mesh: the zero-trust mesh for AI agents, and the decision it forces on your platform team
# Agent Mesh: a zero-trust mesh for AI agents, and the decision it forces on your platform team
Eighty days that changed the answer
On 18 August 2026 a project appeared in Google's GitHub organisation with no keynote, no launch video and a name people kept confusing with a segmentation model: SAM, Sovereign Agent Mesh. Michal Sutter wrote it up the same day in MarkTechPost. The substance was a networking layer, licensed Apache-2.0, that lets agents share tools without publishing anything to the internet. The architecture had three moving parts: a control plane for identity and policy, routers for transport and discovery, and one node per agent.
The problem was not theoretical. Agents already ran across cloud accounts, on-premises datacenters, laptops and edge devices, and the usual way for two of them to cooperate was to expose internal scripts, LLM endpoints or private APIs to the internet. The proposal was a peer-to-peer overlay, zero-config and zero-trust: less like an API gateway, more like a private VPN, scoped to tool invocation over MCP rather than to packet forwarding.
That was eighty days ago, and three things have happened since that matter more than the launch itself.
First, the name changed. The repository moved from google/sam to google/agentmesh, and the README on the main branch states that the name was updated to align the project with its role in the ecosystem. A review published by Wavect on 12 October 2026 already used the new names and flagged a trap: the v0.1.0-rc.9 build, published 7 October, still shipped binaries called sam-*. If you write runbooks, pin the version and the binary name together.
Second, v0.2.0 shipped on 2 November 2026. It lets a router expose a2a, mcp and inference services to HTTP clients outside the mesh under the same identity and policy checks used inside it, adds a Go SDK that embeds a mesh member in a process, and moves the control plane database to schema version 21.
Third, the scope question moved. In August the interesting question was whether a mesh could work at all. Today the interesting question is narrower and more expensive: do we want our agents to trust each other through a peer-to-peer overlay with offline authorization, instead of through a central gateway that we can watch? That is a decision about blast radius, residency and who gets to say no.
What zero-trust means when there is no gateway
Start with the trust model, because it is the part that survives contact with production.
A node enrols with a control plane. The control plane verifies an OIDC JWT, translates the claims into Datalog facts (the subject becomes a user fact, each group becomes a group fact, the node's peer ID binds in as the client peer fact) and seals those facts into a Biscuit token signed with the control plane's Ed25519 key. The node stores the credential, the control plane's public key, the control plane URL and its router addresses. From that moment it is a member of that mesh only.
The operational consequence is the interesting part. The node that receives a call authorizes it locally. There is no hot permission lookup. A request passes through two stages: one that gates the connection against ban and revocation caches, and one that runs two Biscuit authorizer passes, the first over the hosting node's own credential and the second over the caller's, plus a baseline check that requires the connection's peer ID to match the peer ID inside the token. That baseline check is what stops a stolen credential from being replayed from a different host.
Enforcement is deny by default with no built-in exceptions. A call requires an explicit capability fact. Even the built-in discovery catalogue has to be granted on purpose. Service names are typed, in the form type://name, so mcp://calculator, inference://vllm-eu or a2a://triage, and wildcards are permitted, for example mcp://build-runner.*.
Two consequences follow for anyone who has cleaned up a leaked API key. The blast radius of a compromised credential shrinks from everything that key could reach to exactly what the policy inside that credential permits. And the credential itself has a short life: 24 hours by default, renewed in the background, so a stolen credential is useful for at most its remaining lifetime, and a banned node cannot renew at all.
Sovereignty: what you control, and what quietly stays in scope
Run your own control plane and you own five decisions. Membership, because enrolment goes through your identity provider or through bootstrap tokens you mint, and an identity with no binding cannot enrol a node. The signing key, because the control plane generates and rotates Ed25519 signing keys by default, or you supply them in a PEM file that the control plane re-reads every 30 seconds, meaning a rotation needs no restart and you keep the previous key until every credential it signed has expired. The policy, held in your database and editable only with your admin token or through the console. Revocation, published as a signed mesh event that every connected node and router enforces at once, with nodes pulling every 15 minutes and routers every 5 minutes. And where the software runs: a laptop, a private cluster, or an air-gapped network, because Agent Mesh is Apache-2.0, sends no telemetry and depends on no hosted service.
Here is the part that decides your residency answer. The control plane is not on the data path: it sees enrolments, refreshes, router leases and token exchanges, and never sees a request. Tool calls travel between nodes over an encrypted libp2p stream, relayed through a router when a direct connection is impossible, and the relay forwards ciphertext and learns only that two peers are talking. But routers are on the path, so their placement decides where your data physically goes. Nodes in a region attached to a router in that region keep relayed traffic inside that region. Residency is not a property of the design. It is a property of your router placement.
Shared nodes do not share permissions
For anyone running several agents inside one cluster, this is the property that decides whether the mesh is usable. When multiple workloads, users or sandboxed agents sit behind a single node, they do not inherit that node's permissions.
On the MCP endpoint and on the inference endpoints, the caller presents its own platform credential: an OIDC ID token, a Kubernetes projected service account token, or a SPIFFE JWT-SVID, or a Biscuit already attenuated for a specific task. The node exchanges that platform credential through POST /token/exchange into a delegated session Biscuit carrying the caller's own user, email, group and role facts, bound to the node through the client peer fact and an actor node fact. The destination node then authorizes the request against the caller's delegated Biscuit and its attenuation chain, never against the origin node's own roles. A workload cannot borrow the platform's authority just because it shares a network.
Attenuation is the other half of the model, and it is the part that makes delegation safe. A holder can append a task authorization rule block to its own token, narrowing which services, MCP tools, HTTP methods, paths, cloud permissions and resources that token may use. Every appended block must match, the limit is eight, and the effective authority is the intersection of the standing policy with every appended block, so attenuation can only ever narrow. A sub-agent hop that receives a narrowed token cannot widen it again. That is a meaningful difference from a gateway that hands out a bearer token and hopes the downstream service interprets it narrowly.
Labels as a residency primitive
Labels are where policy meets geography. A node declares labels as key and value pairs, the control plane attests only the labels its role permits, and the labels become signed facts inside the credential. Three mechanisms then hold a boundary. A provider can require a label, for example a check on the jurisdiction label, which rejects any caller whose credential lacks that fact regardless of what the mesh granted. A caller can require labels of the provider, and the node verifies the provider's credential before it forwards any request data, refusing the request if the provider cannot show every label named. And an operator can set a floor for an entire node, applied to every outbound request, which callers cannot lower.
The wire: keys, transport and discovery
Each node generates its own Ed25519 key pair and keeps it in its data directory. The peer ID, the string that shows up in logs, discovery results and proxy URLs, is derived from the public key, and the key never leaves the machine. The credential is bound to that key, so a copied credential is worthless without it, and every peer-to-peer connection proves possession of the key as part of the libp2p handshake. If a node is decommissioned, a full reset deletes the key and issues a new peer ID.
On the transport side, nodes are libp2p peers. By default a node listens on QUIC over UDP port 5001 and TCP over port 5002, and it advertises its private addresses as well unless you pass the flag to stop it. When neither side can accept an inbound connection, which is the normal case across corporate networks, the pair uses a relay circuit through a router, and hole punching is enabled so a relayed connection upgrades to a direct one when the NATs allow it. Every hop is protected by a libp2p secure channel bound to the peer's identity: TLS 1.3 for Go peers and for the Node and Python SDKs, or Noise for browsers. One capacity detail matters for fan-out workloads, because a QUIC connection admits 256 streams while TCP with yamux has no equivalent limit.
The local surface an agent sees is deliberately small. The node listens on TCP at 127.0.0.1:8080 by default, where every request must carry the node's API token in a dedicated authentication header, and on a Unix domain socket created with mode 0600, which needs no token because only the owning user can open it. Passing an empty bind address removes the TCP listener entirely. The agent-facing routes are the MCP endpoint over Streamable HTTP, an OpenAI-compatible inference endpoint, a discovery route and a reverse proxy path of the form /mesh/<peer-id>/<type>/<name>/<path>.
Discovery is the part that deserves scepticism, because it is where most mesh designs leak authority. Here the directory lives on the routers and is served to members over a versioned route. Routers place each record on the routers closest to its key using the Kademlia table they maintain among themselves, and nodes keep no distributed hash table of their own; they ask the routers they hold. A record that a provider stopped announcing without withdrawing it disappears after three re-provision intervals. Before advertising an MCP or A2A service the node probes the backend, with a two second default timeout, so the catalogue does not advertise tools that would fail when called. And the first message on any stream is an authentication frame carrying the caller's credential and the requested service, to which the receiver replies with its own credential. Discovery results are hints about who claims to serve something. Nothing is authorized on that basis.
A configuration you can run today
Enrol a workload with no browser, using the projected Kubernetes service account token:
```bash go install github.com/google/agentmesh/cmd/agentmesh-node@latest agentmesh-node run --jwt-path /var/run/secrets/tokens/sa-token ```
The mesh policy is the document that decides who may call what, and it is worth designing rather than inheriting:
```json { "roles": [ { "name": "developer", "allowed_services": ["mcp://code-reviewer", "mcp://build-runner.*", "inference://*"], "allowed_publish": ["mcp://build-runner.*"], "allowed_targets": ["group:dev-nodes"], "allowed_labels": ["region=*"], "http": [ { "service": "mcp://code-reviewer", "methods": ["POST"], "paths": ["/mcp"] } ] } ], "bindings": [ { "role": "developer", "members": ["group:eng"] } ] } ```
Note what that policy separates. Calling a service and serving one are granted independently, so a role allowed to call the code reviewer does not thereby get to publish it. Targets are facts about the destination node, expressed as a peer, a user, an email, a group or an identity provider role. The HTTP block narrows a grant to one method and one path. And the control plane refuses a policy that names an undefined role, uses an unknown member prefix, or grants a single identity more than the Biscuit authorizer can evaluate. Posting it needs your admin token:
```bash AUTH_HEADER=$(printf 'Bearer %s' "$(cat ./admin-token)") curl -sS -X POST "$CONTROL_PLANE/policies" \ -H "Authorization: $AUTH_HEADER" \ -H 'Content-Type: application/json' \ --data @policy.json ```
Exposing the mesh to ordinary HTTP clients is a separate, deliberate step:
```bash agentmesh-router --ingress-addr :8443 --ingress-url https://mesh.example.com ```
The decision for this quarter
A gateway and a peer-to-peer mesh compete only on the same ground. The gateway wins when services live in one trust domain and you want a single place to watch and meter. The mesh wins when agents cross boundaries between cloud, datacentre, laptop and edge, because there the identity travels with the node and policy names services instead of addresses. Two caveats: the project is pre-1.0 with no support commitment, and the independent security audits of Biscuit verification and key rotation sit in the 1.0.0 stage and have not happened. So the question for this planning cycle is how much of your tangle of tunnels, reverse proxies and static credentials would disappear if the mesh handled transport and authorization. Pilot it: your own control plane, two agents on opposite sides of a boundary, and a policy small enough to audit completely.