mrkeyoor.com_
Tue 01 Sept 17:40 UTC
AI Toolsevaluationupdated 26 Aug 2026

sam review

SAM, or Sovereign Agent Mesh, is a peer-to-peer network for AI agents to discover and call remote MCP tools through local nodes. It combines node identity, authorization policy, relays, and an MCP sidecar so an agent can reach approved services without holding credentials for every remote system.

+112stars / 7d
Verdict

Our SAM build passed in 78 seconds, but its only reported integration test failed after 385 seconds because the unprivileged container could not use unshare. That makes SAM a credible evaluation target for teams building a secured multi-network agent platform, not a default MCP setup for ordinary developers. Try the public testnet first; self-host only if OIDC, routing, DNS, policy, and alpha security changes are work your platform team wants to own.

We ran it

Lab card: what happened when we ran samScreenshot of sam (sam-mesh.dev)
Install✓ · 61s324 packages
Build✓ · 78s
Tests✗ · 385s0 passed · 1 failed of 1 (go test)
Repo399 files~51,103 lines of source · 27.4 MB · 10 CI workflows · tests dir

Answers from our run

Does sam build from source?

Dependencies installed in 61 seconds (324 packages), and the build succeeded in 78 seconds. We cloned commit cdaf83e into a clean Debian container with 3 CPUs and no project-specific setup.

Do sam's tests pass?

Not all of them: 0 of 1 passed and 1 failed when we ran the project's own test command (go test). Some failures need services or credentials a bare container does not have.

Who should not use sam?

Teams seeking an officially supported Google service: the README explicitly says SAM is unsupported and outside Google's open-source vulnerability reward program.

What are the alternatives to sam?

Tailscale, go-libp2p, MCP Context Forge. Our SAM build passed in 78 seconds, but its only reported integration test failed after 385 seconds because the unprivileged container could not use unshare.

Setup2/5Public node is guided; self-hosted mesh has many infrastructure parts
Docs4/5Quick start, integrations, testing, and Kubernetes are detailed
Community3/5702 stars with active August 2026 issues and pull requests
Maturity2/5Alpha release with recent authorization and enrollment fixes

Who it’s for

Platform teams connecting agents and MCP services across local, cloud, and edge networks.
Kubernetes operators prepared to run OIDC, a control plane, routers, DNS synchronization, and policy.
Claude Code users who want an installable skill plus one local MCP endpoint for mesh discovery and remote calls.
Security engineers willing to evaluate Biscuit capabilities, libp2p identity, revocation, and sandbox boundaries in alpha software.

Who it’s NOT for

Teams seeking an officially supported Google service: the README explicitly says SAM is unsupported and outside Google's open-source vulnerability reward program.
Buyers who require stable production releases: the latest release is v0.1.0-alpha.7, and recent work fixed an expired-capability acceptance path.
Operators who cannot grant Linux namespace capabilities to isolation tests or workloads: our integration test failed when unshare returned Operation not permitted.
Agents that need natural-language remote-tool search today: open issue 313 says the advertised intent parameter is ignored and only structural filters work.
Small teams expecting a simple self-hosted server: the production guide includes Dex, PostgreSQL, a control plane, stateful routers, DNS updates, policies, and workload identity.

Setup reality

Our sandbox installed 324 Go packages in 61 seconds. The build succeeded in 78 seconds. Tests failed after 385 seconds: the reported Go test result was 0 passed and 1 failed of 1, with TestSamBoxNanoInitIntegration failing because unshare was not permitted in the unprivileged container.

The public testnet path needs a one-time OIDC or bootstrap enrollment, a persistent node identity, local API token, and open libp2p ports. Self-hosting adds an OIDC issuer, PostgreSQL, control plane, stateful routers, DNS synchronization, policy, and Kubernetes identities.

SAM is at v0.1.0-alpha.7 and is not an officially supported Google product. The node exposes MCP over local HTTP; remote clients need its bearer token. The bundled agent skill can configure Claude Code, but enrollment still hands the one-time login to a person.

A local node gives agents one doorway to remote MCP tools

Each SAM node exposes a local MCP server. An attached agent can inspect the mesh, discover services, list tools on a peer, and invoke a remote tool through a protected peer-to-peer stream. The node handles network identity and authorization, so the agent harness does not need a credential for every tool provider. A control plane registers identities and policies, while routers help nodes discover and reach one another over libp2p.

The quick start joins Google's public bananas.sam-mesh.dev testnet through OIDC or a bootstrap token. After enrollment, a node stores its Biscuit capability and identity for later starts. Local HTTP is protected by an API token, and Docker examples expose UDP 5001, TCP 5002, and the local API on 8080. This is more networking than a normal single-process MCP server, even on the hosted testnet path.

What happened when we ran it

Our sandbox installed 324 Go packages in 61 seconds and built commit cdaf83e in 78 seconds. The checkout contained 399 files, about 51,103 lines of source, and 27.4 MB. Our scan found 10 CI workflow files and a tests directory, with no Dockerfile. Those results show a manageable source build for a network system with control-plane, router, node, console, and integration code.

The test step failed after 385 seconds. The reported Go result was 0 passed and 1 failed of 1. TestSamBoxNanoInitIntegration tried to re-execute under unshare, which returned Operation not permitted inside our unprivileged container. The test log also showed DHT activity, Biscuit signing-key rotation, and a deliberately malformed OIDC token, but the named test failure was the rejected namespace operation.

That failure does not prove the namespace code is broken, and the log does not establish that granting privileges would make the whole test pass. It does prove this isolation check cannot run under the restrictions of our fresh Debian sandbox. Teams using the sandbox feature should reproduce it with the exact Linux capabilities and kernel configuration intended for deployment rather than removing the test to get a green result.

Claude Code gets a skill, while enrollment stays human

sam-node skill install writes a SAM skill for Claude Code, Claude Desktop, or Google's supported skill locations. The document teaches an agent how to start the node, register its MCP endpoint, find mesh services, and call remote tools. An agent can run the daemon and read its local API token, but the one-time OIDC enrollment login is intentionally returned to a person.

The separation is sensible because enrollment creates durable network identity. Remote MCP configuration must protect that token, and the node should normally bind its management surface to 127.0.0.1. Resetting all node data destroys the key and creates a new peer identity, so backups and recovery procedures need to distinguish configuration from identity.

Self-hosting means OIDC, routers, DNS, and policy

The production guide describes Dex as an identity bridge, a stateless control plane backed by PostgreSQL, stateful routers with persistent identity keys, and nodes authenticated through Kubernetes projected service-account tokens. A DNS synchronization job publishes changing router addresses for DHT bootstrapping. The control plane starts closed until an administrator posts a policy, which is the correct default for remote tool execution.

This stack fits a platform team already operating Kubernetes and identity federation. It is excessive for two agents on one LAN. The sample router deployment uses 3 replicas and persistent volumes, while the control plane example also uses 3 replicas. Operators must manage OAuth clients, issuer and audience values, database availability, DNS records, router ports, signing-key rotation, enrollment approval, and revocation.

Alpha security fixes deserve release-by-release review

Issue 296 reported that the node data-plane authorizer at the exact commit we tested did not inject the time fact needed to reject expired Biscuit capabilities. Pull request 316 fixed missing expiration checks and merged on August 26, 2026, after that commit.

Another current issue, 317, says rotation and revocation events are handled by nodes but are not propagated by the shipped control-plane binary because it retains a no-operation mesh adapter. That is an open report, not a confirmed release note. For a system whose pitch centers on authorization, these are adoption-blocking checks: prove expiry, revocation, key rotation, and policy denial across real nodes before routing sensitive tools.

Remote discovery works by names, and intent search is unfinished

Agents can discover registered MCP services, fetch a peer's catalog, and call a tool through the local node. Open issue 313 points out that the find_remote_tools schema accepts a natural-language intent field but currently ignores it. Exact peer, service, and tool filters work; an agent that does not know the tool name must retrieve a broader list and inspect descriptions itself.

Issue 318 also notes that the node currently exposes 16 MCP tools, including 5 operator diagnostics proposed for removal from the agent-visible list. The proposal had not merged when researched. A growing catalog increases prompt size and the chance of choosing the wrong operation, so deployments should inventory the actual tool list exposed to each agent rather than assuming SAM's local endpoint contains only remote invocation functions.

Same-day activity does not make alpha infrastructure settled

GitHub recorded 702 stars and 15 combined open issues and pull requests when fetched. The last push was August 26, 2026, and v0.1.0-alpha.7 was published August 16. Recent activity covered enrollment, namespace isolation, authorization expiry, Kubernetes packaging, service advertisement, identity evidence, and tool-surface reduction. The pace is high because core behavior is still being corrected.

SAM is interesting when agent networking itself is the product problem. Our 78-second successful build makes source evaluation accessible, while the 385-second failed integration test shows that meaningful validation reaches into Linux isolation behavior. Use the testnet to learn the model, then demand a security and operations proof before trusting a private mesh.

Alternatives

ProjectWhat it isPick it when
Tailscale gh↗An identity-aware private network for connecting machines and services.pick this instead when secure reachability is the main problem and agents can use ordinary service discovery.
go-libp2pThe Go networking stack beneath many peer-to-peer applications, including SAM's transport layer.pick this instead when you need to design your own peer protocols rather than adopt SAM's identity, MCP, and policy model.
MCP Context ForgeA gateway and registry for managing access to MCP servers through a central service.pick this instead when a centralized MCP gateway fits better than a peer-to-peer agent mesh.

What people are saying

  1. [github-trending] google/sam
  2. [techcrunch-ai] Sam Altman and AI’s decel debate
  3. [techcrunch-ai] Sam Altman is still making the case for parenting via ChatGPT
  4. [techcrunch-ai] Sam Altman isn’t the only one who wants to pump the brakes on AI

Sources

  1. SAM README
  2. SAM repository facts
  3. SAM v0.1.0-alpha.7
  4. Expired Biscuit issue
  5. Remote tool intent issue
  6. Control plane mesh connector issue

More ai tools reviews

claudian · SkillSpector · robin · mjlab · MoGe · awesome-design-md · the whole board →