Skip to content

Agent Mesh

docs: update Hugo site, documentation, README, and AGENTS.md for Agent Mesh

Antonio Ojea8bfe8bae61a4
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 110aa82b..cef1a57c 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,5 +1,5 @@
{
- "name": "SAM (develop)",
+ "name": "Agent Mesh (develop)",
"build": { "dockerfile": "Dockerfile" },
"features": {
"ghcr.io/devcontainers/features/node:2": {},
@@ -10,7 +10,7 @@
"onCreateCommand": "make build",
"forwardPorts": [8080],
"portsAttributes": {
- "8080": { "label": "SAM mesh (sam-one)", "protocol": "http" }
+ "8080": { "label": "Agent Mesh (agentmesh-one)", "protocol": "http" }
},
"customizations": {
"vscode": {
diff --git a/.devcontainer/testnet-latest/devcontainer.json b/.devcontainer/testnet-latest/devcontainer.json
index e8dae3c1..c250e17d 100644
--- a/.devcontainer/testnet-latest/devcontainer.json
+++ b/.devcontainer/testnet-latest/devcontainer.json
@@ -1,15 +1,15 @@
{
- "name": "SAM testnet (latest from main)",
+ "name": "Agent Mesh testnet (latest from main)",
"build": {
"dockerfile": "../testnet/Dockerfile",
- "args": { "SAM_CHANNEL": "latest" }
+ "args": { "AGENTMESH_CHANNEL": "latest" }
},
"features": {
"ghcr.io/devcontainers/features/sshd:1": {}
},
"forwardPorts": [8080],
"portsAttributes": {
- "8080": { "label": "SAM mesh (sam-one)", "protocol": "http" }
+ "8080": { "label": "Agent Mesh (agentmesh-one)", "protocol": "http" }
},
"customizations": {
"codespaces": {
diff --git a/.devcontainer/testnet/Dockerfile b/.devcontainer/testnet/Dockerfile
index cfae6b60..93fce4d2 100644
--- a/.devcontainer/testnet/Dockerfile
+++ b/.devcontainer/testnet/Dockerfile
@@ -1,11 +1,11 @@
-# A mesh without a toolchain: the released sam-one and sam-node binaries are
-# copied out of the published images. SAM_CHANNEL selects `stable` (the last
-# release tag, what hub.sam-mesh.dev runs) or `latest` (main, what
-# bananas.sam-mesh.dev runs).
-ARG SAM_CHANNEL=stable
-FROM ghcr.io/google/sam-one:${SAM_CHANNEL} AS sam-one
-FROM ghcr.io/google/sam-node:${SAM_CHANNEL} AS sam-node
+# A mesh without a toolchain: the released agentmesh-one and agentmesh-node binaries are
+# copied out of the published images. AGENTMESH_CHANNEL selects `stable` (the last
+# release tag, what hub.__PROTECT_Agent Mesh_MESH_DEV__ runs) or `latest` (main, what
+# bananas.__PROTECT_Agent Mesh_MESH_DEV__ runs).
+ARG AGENTMESH_CHANNEL=stable
+FROM ghcr.io/google/agentmesh-one:${AGENTMESH_CHANNEL} AS agentmesh-one
+FROM ghcr.io/google/agentmesh-node:${AGENTMESH_CHANNEL} AS agentmesh-node
FROM mcr.microsoft.com/devcontainers/base:bookworm@sha256:3aacff4130e6cf04709f9cab1d7a6d3e1cc4bff6202bc61611831a18d3755673
-COPY --from=sam-one /sam-one /usr/local/bin/sam-one
-COPY --from=sam-node /sam-node /usr/local/bin/sam-node
+COPY --from=agentmesh-one /agentmesh-one /usr/local/bin/agentmesh-one
+COPY --from=agentmesh-node /agentmesh-node /usr/local/bin/agentmesh-node
diff --git a/.devcontainer/testnet/devcontainer.json b/.devcontainer/testnet/devcontainer.json
index 8652ae70..4a94dcd8 100644
--- a/.devcontainer/testnet/devcontainer.json
+++ b/.devcontainer/testnet/devcontainer.json
@@ -1,15 +1,15 @@
{
- "name": "SAM testnet (stable release)",
+ "name": "Agent Mesh testnet (stable release)",
"build": {
"dockerfile": "Dockerfile",
- "args": { "SAM_CHANNEL": "stable" }
+ "args": { "AGENTMESH_CHANNEL": "stable" }
},
"features": {
"ghcr.io/devcontainers/features/sshd:1": {}
},
"forwardPorts": [8080],
"portsAttributes": {
- "8080": { "label": "SAM mesh (sam-one)", "protocol": "http" }
+ "8080": { "label": "Agent Mesh (agentmesh-one)", "protocol": "http" }
},
"customizations": {
"codespaces": {
diff --git a/.gemini/styleguide.md b/.gemini/styleguide.md
index 6ce2c6ae..e0ef7633 100644
--- a/.gemini/styleguide.md
+++ b/.gemini/styleguide.md
@@ -1,7 +1,7 @@
-# SAM Code Review Style Guide
+# Agent Mesh Code Review Style Guide
This file extends the standard Gemini Code Assist review prompt for this
-repository. It lists checks that are specific to SAM and that generic review
+repository. It lists checks that are specific to Agent Mesh and that generic review
does not catch. Apply them to every pull request that touches Go code. When a
rule is violated, quote the offending line and state the concrete fix; do not
only describe the principle.
@@ -17,7 +17,7 @@ A libp2p peer ID has several valid string encodings. `peer.Decode` accepts
all of them (base58 multihash `12D3KooW...`, CIDv1 base32 `bafzaajai...`,
and others) and returns the same `peer.ID`, but `peer.ID.String()` always
emits the base58 form. Every cache, ban set, storage row, and `map[string]`
-in SAM is keyed on that canonical form. A raw string copied off the wire and
+in Agent Mesh is keyed on that canonical form. A raw string copied off the wire and
used as a key is therefore a *different key for the same peer*, and a ban,
admission or dedup check silently misses. This is a security bug, not a
style issue.
@@ -183,7 +183,7 @@ any new root dependency that lacks this justification.
### Why
-SAM has two API surfaces with different encodings (`AGENTS.md` §1, "Two API
+Agent Mesh has two API surfaces with different encodings (`AGENTS.md` §1, "Two API
surfaces"): the mesh protocol between components is protobuf from
`api/agentmesh.proto`; the operator plane (`/admin/*`, `/users/*`) is JSON whose
shapes are Go structs in `api/`. Shapes defined ad hoc inside a handler, or
@@ -213,7 +213,7 @@ regardless of how carefully the rest of the system handles them.
"...secret"|"...password", ...)` whose value is the credential itself,
rather than a `--*-path` or an env var name, is a finding; so is a
banner or log line that prints a credential the operator supplied.
- `sam-control-plane --admin-token-path` and `sam-node
+ `agentmesh-control-plane --admin-token-path` and `agentmesh-node
--bootstrap-token-path` are the reference shape.
## 6. Review output
diff --git a/AGENTS.md b/AGENTS.md
index 822aef06..54f5447b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,16 +1,16 @@
-# SAM Repository AI Agent Guidelines
+# Agent Mesh Repository AI Agent Guidelines
-You are an expert software engineering assistant helping to develop, maintain, and test the **SAM** repository.
+You are an expert software engineering assistant helping to develop, maintain, and test the **Agent Mesh** repository.
## 1. Architecture & Component Independence
-* **Decoupled Architecture:** The `sam-control-plane`, `sam-router` and `sam-node` components are strictly independent. They must not share internal state or tightly couple their logic.
-* **API Communication:** All data communication between `sam-control-plane`, `sam-router` and `sam-node` must happen exclusively via the common API defined in `api/agentmesh.proto`.
-* **One schema, two encodings:** every request and response on any SAM-defined surface is a message in `api/agentmesh.proto`. The *mesh protocol* — anything a mesh component speaks (node, router, the SDKs under `sdk/`): enrollment, refresh, keys, leases, auth streams, policy sync, token exchange (`/token/exchange`), and outbound border JWT minting (`/sts/token`) — is binary protobuf (`application/x-protobuf`). The *operator plane* — what humans, the web console and admin CLIs call (`/admin/*`, `/users/*`, `POST /policies`) — is protojson of the same messages, with `UseProtoNames` and unknown fields rejected. Never define a wire shape on a SAM-defined surface as a Go struct with `json` tags, an anonymous struct or `map[string]any`, and never serialize an `internal/storage` (or any other internal) type onto either surface. The sole exceptions are external standard protocols for unmodified third-party clients and cloud federation: OAuth 2.1 / RFC 8693 / RFC 7009 / RFC 9728 (`POST /oauth/token`, `POST /oauth/revoke`, `/oauth/authorize`, `/.well-known/*`, `/jwks`), Envoy `ext_authz` / `ext_proc`, MCP JSON-RPC (`/mcp`), OpenAI `/v1/*`, and A2A `/.well-known/agent-card.json`. Clients in `cmd/`, `internal/console` and `sdk/` import `api/` or its generated bindings only. The node's `/debug/*` endpoints are exempt: unversioned diagnostics for humans, printed as-is by `sam-node debug` and parsed by no client, so they stay unexported Go structs.
+* **Decoupled Architecture:** The `agentmesh-control-plane`, `agentmesh-router` and `agentmesh-node` components are strictly independent. They must not share internal state or tightly couple their logic.
+* **API Communication:** All data communication between `agentmesh-control-plane`, `agentmesh-router` and `agentmesh-node` must happen exclusively via the common API defined in `api/agentmesh.proto`.
+* **One schema, two encodings:** every request and response on any Agent Mesh-defined surface is a message in `api/agentmesh.proto`. The *mesh protocol* — anything a mesh component speaks (node, router, the SDKs under `sdk/`): enrollment, refresh, keys, leases, auth streams, policy sync, token exchange (`/token/exchange`), and outbound border JWT minting (`/sts/token`) — is binary protobuf (`application/x-protobuf`). The *operator plane* — what humans, the web console and admin CLIs call (`/admin/*`, `/users/*`, `POST /policies`) — is protojson of the same messages, with `UseProtoNames` and unknown fields rejected. Never define a wire shape on a Agent Mesh-defined surface as a Go struct with `json` tags, an anonymous struct or `map[string]any`, and never serialize an `internal/storage` (or any other internal) type onto either surface. The sole exceptions are external standard protocols for unmodified third-party clients and cloud federation: OAuth 2.1 / RFC 8693 / RFC 7009 / RFC 9728 (`POST /oauth/token`, `POST /oauth/revoke`, `/oauth/authorize`, `/.well-known/*`, `/jwks`), Envoy `ext_authz` / `ext_proc`, MCP JSON-RPC (`/mcp`), OpenAI `/v1/*`, and A2A `/.well-known/agent-card.json`. Clients in `cmd/`, `internal/console` and `sdk/` import `api/` or its generated bindings only. The node's `/debug/*` endpoints are exempt: unversioned diagnostics for humans, printed as-is by `agentmesh-node debug` and parsed by no client, so they stay unexported Go structs.
* **Instants are `google.protobuf.Timestamp`, named `*_time`** (`expire_time`, `sign_time`, `event_time`), never `int64` seconds or milliseconds. `Timestamp` has fixed units, an explicit unset, renders as RFC 3339 in protojson (an `int64` renders as a quoted decimal string), and has a first-class conversion in Go, JavaScript, Python and Dart. A receiver treats an unset instant as invalid, never as the epoch. The one exception is a proof-of-possession value: it is the number that appears in the signed text (`mesh:<endpoint>:<peer_id>:<n>`), so it stays an `int64` named `challenge_unix_ms`, the unit in the name. What a member persists between runs is also a message here (`MemberCredential`), so a state directory written by one implementation loads in another.
* **Datalog text is the policy contract:** the control plane renders the mesh policy as Datalog rules (`PolicyConfigGetResponse.datalog_rules`); every member, in any language, adds that text to its authorizer and none derives rules from roles and bindings itself. Datalog must stay in the form every Biscuit implementation parses: a predicate carries at least one term (presence-only facts are `name(true)`, see `api.MarkerFact`).
* **Secrets never travel as flag values:** binaries read credentials from a file (`--*-path`) or the environment, never from a command-line argument that would sit in `ps` output and shell history. Banners and logs name the source of an operator-supplied secret instead of echoing it.
-* **Task-Scoped Authorization & Safe Biscuit Attenuation (`tar_block`):** SAM acts as the Authority, Policy Decision Point (PDP), and Task-Scoped Credential Layer (`site/content/docs/contributing/security-architecture.md`). Never add Datalog rules or checks to non-authority Biscuit blocks (`block_idx >= 1`). Appended blocks must contain 0 rules, 0 checks, and exactly 1 `tar_block("<base64url-proto>")` fact encoding a serialized `api.TaskAuthorizationRule`. Verifiers enforce the intersection of Block 0 Datalog RBAC and every appended `TaskAuthorizationRule` in Go, TypeScript, and Python.
-* **Two-Token Model & Complementary Gateway/PEP Integration:** Inside the mesh, credentials are Biscuits; at both borders, credentials are standard JWTs (`site/content/docs/contributing/security-architecture.md`). Inbound platform credentials (OIDC, K8s SA, SPIFFE JWT-SVID) exchange into delegated Biscuits (`POST /token/exchange`); outbound verified Biscuits mint short-lived ES256 JWTs at the control plane (`POST /sts/token`) that the egress node exchanges at cloud STS endpoints (`CloudTokenExchanger`). `sam-node` integrates with existing gateways (`agentgateway`, Istio, Envoy) via Envoy `ext_authz` / `ext_proc` and RFC 8693 `/oauth/token`, while native SDKs (`sdk/js`, `sdk/python`) attenuate and seal Biscuits in memory.
+* **Task-Scoped Authorization & Safe Biscuit Attenuation (`tar_block`):** Agent Mesh acts as the Authority, Policy Decision Point (PDP), and Task-Scoped Credential Layer (`site/content/docs/contributing/security-architecture.md`). Never add Datalog rules or checks to non-authority Biscuit blocks (`block_idx >= 1`). Appended blocks must contain 0 rules, 0 checks, and exactly 1 `tar_block("<base64url-proto>")` fact encoding a serialized `api.TaskAuthorizationRule`. Verifiers enforce the intersection of Block 0 Datalog RBAC and every appended `TaskAuthorizationRule` in Go, TypeScript, and Python.
+* **Two-Token Model & Complementary Gateway/PEP Integration:** Inside the mesh, credentials are Biscuits; at both borders, credentials are standard JWTs (`site/content/docs/contributing/security-architecture.md`). Inbound platform credentials (OIDC, K8s SA, SPIFFE JWT-SVID) exchange into delegated Biscuits (`POST /token/exchange`); outbound verified Biscuits mint short-lived ES256 JWTs at the control plane (`POST /sts/token`) that the egress node exchanges at cloud STS endpoints (`CloudTokenExchanger`). `agentmesh-node` integrates with existing gateways (`agentgateway`, Istio, Envoy) via Envoy `ext_authz` / `ext_proc` and RFC 8693 `/oauth/token`, while native SDKs (`sdk/js`, `sdk/python`) attenuate and seal Biscuits in memory.
* **Policy on Names:** egress policy, secret injection and routing decisions are made on the destination *name*, never on an IP. Deny by default.
* **Zero Trust:** Enforce a Zero Trust architecture. Assume no implicit trust between nodes, control planes, routers, or external actors. All data passing through the API must be authenticated, authorized, and validated.
* **Simple UX:** Maintain a very simple User Experience. Configuration, CLI usage, and error messages must be intuitive, minimal, and explicitly clear.
@@ -41,6 +41,6 @@ Enforce strict modularity in testing. The repository uses a defined testing pyra
* Ensure e2e test passes `make e2e-test`
## 6. Environments
-* There are two public testnets available `hub.sam-mesh.dev` that is deployed from the latest released tag and `bananas.sam-mesh.dev` that is deployed from the `main` branch.
+* There are two public testnets available `hub.__PROTECT_Agent Mesh_MESH_DEV__` that is deployed from the latest released tag and `bananas.__PROTECT_Agent Mesh_MESH_DEV__` that is deployed from the `main` branch.
* Their configurations can be found under `.github/k8s`.
* Their deployments are managed under `.github/workflows/deploy.yaml`.
diff --git a/README.md b/README.md
index 172c4216..fef0de94 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-# Agent Mesh (SAM)
+# Agent Mesh
-<img alt="Agent Mesh (SAM)" src="site/content/docs/sam_logo.png" width="160" />
+<img alt="Agent Mesh" src="site/content/docs/agentmesh_logo.png" width="160" />
-**Agent Mesh** (`SAM` — OSS Agent Mesh) is a private network for AI agents. A
+**Agent Mesh** is a private network for AI agents. A
node runs next to an agent and gives it three things: a way to publish tools
and models to the network, a way to find and call what other nodes publish,
and an identity every other node can verify. Nodes connect directly when they
@@ -20,22 +20,22 @@ Two properties hold everywhere:
turns that into a short-lived, offline-verifiable credential bound to the
node's own key.
-<img src="site/static/demo.gif" alt="Installing sam-node, adding the skill, and an agent discovering and calling tools across the mesh" width="100%" />
+<img src="site/static/demo.gif" alt="Installing agentmesh-node, adding the skill, and an agent discovering and calling tools across the mesh" width="100%" />
## Try it
```bash
-curl -sL https://sam-mesh.dev/install.sh | bash # sam-node, mcp-client and friends
-sam-node join https://bananas.sam-mesh.dev # one-time login
-sam-node run --daemonize # local MCP server on 127.0.0.1:8080
-sam-node skill install # teach your agent to use it
+curl -sL https://__PROTECT_Agent Mesh_MESH_DEV__/install.sh | bash # agentmesh-node, mcp-client and friends
+agentmesh-node join https://bananas.__PROTECT_Agent Mesh_MESH_DEV__ # one-time login
+agentmesh-node run --daemonize # local MCP server on 127.0.0.1:8080
+agentmesh-node skill install # teach your agent to use it
```
Your agent now has tools that discover and call services across the mesh,
and an OpenAI-compatible endpoint that routes model requests to whoever
-serves the model. `bananas.sam-mesh.dev` is a shared developer testnet with
-no uptime promise; the [quick start](https://sam-mesh.dev/docs/getting-started/quickstart/)
-walks through it, and [your own mesh](https://sam-mesh.dev/docs/getting-started/your-own-mesh/)
+serves the model. `bananas.__PROTECT_Agent Mesh_MESH_DEV__` is a shared developer testnet with
+no uptime promise; the [quick start](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/getting-started/quickstart/)
+walks through it, and [your own mesh](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/getting-started/your-own-mesh/)
runs a control plane on your laptop in one command.
To run a control plane of your own without installing anything, open a
@@ -43,40 +43,40 @@ GitHub codespace with the released binaries and run `make testnet`. It
starts on a public `https` URL that your laptop and phone can enroll into,
on your GitHub account's free quota:
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/google/sam?quickstart=1&devcontainer_path=.devcontainer%2Ftestnet%2Fdevcontainer.json)
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/google/agentmesh?quickstart=1&devcontainer_path=.devcontainer%2Ftestnet%2Fdevcontainer.json)
-The [Codespaces guide](https://sam-mesh.dev/docs/guides/codespaces/) has the
+The [Codespaces guide](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/guides/codespaces/) has the
steps, what persists and what stops.
## What is in a mesh
| Program | Role |
|---|---|
-| `sam-control-plane` | Verifies who is joining, issues each node a signed credential, and holds the policy that says who may call what. |
-| `sam-router` | A well-known peer that nodes connect to first. Relays traffic between nodes that cannot reach each other and hosts the discovery table. |
-| `sam-node` | Runs next to your agent or service. Enrolls, connects, serves your local backends to the mesh, and exposes the mesh to your agent as a local MCP server and OpenAI-compatible API. |
-| `sam-one` | The control plane, a router and a web console in one binary, for laptops and small deployments. |
+| `agentmesh-control-plane` | Verifies who is joining, issues each node a signed credential, and holds the policy that says who may call what. |
+| `agentmesh-router` | A well-known peer that nodes connect to first. Relays traffic between nodes that cannot reach each other and hosts the discovery table. |
+| `agentmesh-node` | Runs next to your agent or service. Enrolls, connects, serves your local backends to the mesh, and exposes the mesh to your agent as a local MCP server and OpenAI-compatible API. |
+| `agentmesh-one` | The control plane, a router and a web console in one binary, for laptops and small deployments. |
## Documentation
-[sam-mesh.dev/docs](https://sam-mesh.dev/docs/) is built from `site/`.
+[__PROTECT_Agent Mesh_MESH_DEV__/docs](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/) is built from `site/`.
-- [Getting started](https://sam-mesh.dev/docs/getting-started/): one node on the testnet, then a mesh of your own.
-- [Concepts](https://sam-mesh.dev/docs/concepts/): architecture, identity and enrollment, authorization, networking.
-- [Guides](https://sam-mesh.dev/docs/guides/): exposing services, connecting agent clients, headless enrollment, Kubernetes, Cloud Run.
-- [Reference](https://sam-mesh.dev/docs/reference/): every flag, configuration key, HTTP route and policy field.
-- [Preview](https://sam-mesh.dev/docs/preview/): sandboxed agents and the mobile app, which work but are still settling.
-- [Contributing](https://sam-mesh.dev/docs/contributing/): building, testing and the local kind environment.
+- [Getting started](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/getting-started/): one node on the testnet, then a mesh of your own.
+- [Concepts](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/concepts/): architecture, identity and enrollment, authorization, networking.
+- [Guides](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/guides/): exposing services, connecting agent clients, headless enrollment, Kubernetes, Cloud Run.
+- [Reference](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/reference/): every flag, configuration key, HTTP route and policy field.
+- [Preview](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/preview/): sandboxed agents and the mobile app, which work but are still settling.
+- [Contributing](https://__PROTECT_Agent Mesh_MESH_DEV__/docs/contributing/): building, testing and the local kind environment.
The repository has a dev container with the Go, Node and Python toolchains
and Docker, so you can build and test in a codespace or in VS Code without
installing anything:
-[![Develop in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/google/sam?quickstart=1)
+[![Develop in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/google/agentmesh?quickstart=1)
## Status
-SAM is pre-1.0. The node, routers, control plane, identity and policy model
+Agent Mesh is pre-1.0. The node, routers, control plane, identity and policy model
are stable in shape and exercised by the test suite and two public testnets;
see [ROADMAP.md](ROADMAP.md) for the release plan. Sandboxed agent blueprints
and the mobile app are in preview.
diff --git a/ROADMAP.md b/ROADMAP.md
index 5e26ca57..18773e0f 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,4 +1,4 @@
-# SAM Roadmap
+# Agent Mesh Roadmap
## Phase 1: Alpha
diff --git a/site/assets/scss/_variables_project.scss b/site/assets/scss/_variables_project.scss
index 0f7530a1..4903eaaa 100644
--- a/site/assets/scss/_variables_project.scss
+++ b/site/assets/scss/_variables_project.scss
@@ -1,5 +1,5 @@
-// SAM Logo Theme Color Overrides
-$primary: #0a7080; // Deep teal (base of SAM text)
+// Agent Mesh Logo Theme Color Overrides
+$primary: #0a7080; // Deep teal (base of Agent Mesh text)
$primary-light: #00f0ff; // Cyberpunk glowing cyan (bananas' visors & wiring)
$yellow: #f6c344; // Banana yellow
$dark: #07131e; // Deep navy/charcoal (shield background and text)
diff --git a/site/content/_index.md b/site/content/_index.md
index d5642f11..ca893f9f 100644
--- a/site/content/_index.md
+++ b/site/content/_index.md
@@ -1,8 +1,8 @@
---
-title: Agent Mesh (SAM)
+title: Agent Mesh
description: A private, zero-trust network for AI agents to publish, discover and call tools and models across machines.
---
-Agent Mesh (SAM — OSS Agent Mesh) is a private network for AI agents. A node runs beside an agent, publishes
+Agent Mesh (Agent Mesh — OSS Agent Mesh) is a private network for AI agents. A node runs beside an agent, publishes
the tools and models it offers, finds what other nodes offer, and calls them
over authenticated peer-to-peer connections, through relays when the machines
cannot reach each other directly.
diff --git a/site/content/docs/_index.md b/site/content/docs/_index.md
index dc96ba41..12180131 100644
--- a/site/content/docs/_index.md
+++ b/site/content/docs/_index.md
@@ -1,9 +1,9 @@
---
-title: "Agent Mesh (SAM) Documentation"
+title: "Agent Mesh Documentation"
linkTitle: "Documentation"
---
-**Agent Mesh** (`SAM` — OSS Agent Mesh) is a private network for AI agents. A
+**Agent Mesh** is a private network for AI agents. A
node runs next to an agent and gives it three things: a way to publish tools and
models to the network, a way to find and call what other nodes publish, and
an identity that every other node can verify. Nodes reach each other
@@ -14,11 +14,11 @@ Three programs make up a mesh:
| Program | Role |
|---|---|
-| `sam-control-plane` | Verifies who is joining, issues each node a signed credential, and holds the policy that says who may call what. |
-| `sam-router` | A well-known peer that new nodes connect to first. It relays traffic between nodes that cannot reach each other and hosts the discovery table. |
-| `sam-node` | Runs next to your agent. It enrolls with the control plane, connects to the mesh, serves your local tools to others, and exposes the mesh to your agent as a local MCP server and an OpenAI-compatible API. |
+| `agentmesh-control-plane` | Verifies who is joining, issues each node a signed credential, and holds the policy that says who may call what. |
+| `agentmesh-router` | A well-known peer that new nodes connect to first. It relays traffic between nodes that cannot reach each other and hosts the discovery table. |
+| `agentmesh-node` | Runs next to your agent. It enrolls with the control plane, connects to the mesh, serves your local tools to others, and exposes the mesh to your agent as a local MCP server and an OpenAI-compatible API. |
-`sam-one` bundles the first two, plus a web console, into a single binary for
+`agentmesh-one` bundles the first two, plus a web console, into a single binary for
laptops and small deployments.
Two rules apply to every mesh:
@@ -35,7 +35,7 @@ Two rules apply to every mesh:
## How these pages are organised
- [Getting started](getting-started/) puts one node on the public
- testnet, then shows you how to run a mesh of your own with `sam-one`.
+ testnet, then shows you how to run a mesh of your own with `agentmesh-one`.
- [Concepts](concepts/) explains how the pieces fit together: the
components, enrollment and identity, authorization, and how traffic moves.
- [Guides](guides/) show how to do specific tasks: expose a service, connect
@@ -46,12 +46,12 @@ Two rules apply to every mesh:
the mesh.
- [Preview](preview/) covers features that work today but whose interfaces
may still change: sandboxed agents and the mobile app.
-- [Contributing](contributing/) covers building, testing and changing SAM
+- [Contributing](contributing/) covers building, testing and changing Agent Mesh
itself.
## About the public testnets
-`bananas.sam-mesh.dev` (built from `main`) and `hub.sam-mesh.dev` (built from
+`bananas.__PROTECT_Agent Mesh_MESH_DEV__` (built from `main`) and `hub.__PROTECT_Agent Mesh_MESH_DEV__` (built from
the latest release tag) are shared developer testnets that run on donated
resources. They exist for trying things out and for the project's own CI.
They have no uptime commitment, and anyone who can log in with the
diff --git a/site/content/docs/sam_logo.png b/site/content/docs/agentmesh_logo.png
similarity index 100%
rename from site/content/docs/sam_logo.png
rename to site/content/docs/agentmesh_logo.png
diff --git a/site/content/docs/concepts/_index.md b/site/content/docs/concepts/_index.md
index 84739f83..b07a6836 100644
--- a/site/content/docs/concepts/_index.md
+++ b/site/content/docs/concepts/_index.md
@@ -4,6 +4,6 @@ linkTitle: "Concepts"
weight: 2
---
-How SAM works, in enough depth to reason about a deployment. Read
+How Agent Mesh works, in enough depth to reason about a deployment. Read
[Architecture](architecture/) first. The other pages each take one part of
it further.
diff --git a/site/content/docs/concepts/architecture.md b/site/content/docs/concepts/architecture.md
index 880ce19b..746cec96 100644
--- a/site/content/docs/concepts/architecture.md
+++ b/site/content/docs/concepts/architecture.md
@@ -12,14 +12,14 @@ and call each other's services on behalf of the agents next to them.
```mermaid
flowchart LR
subgraph cp["control plane"]
- CP["sam-control-plane<br/>identity · policy · signing key"]
+ CP["agentmesh-control-plane<br/>identity · policy · signing key"]
DB[("database")]
CP --- DB
end
IDP["identity provider<br/>(OIDC)"]
- R["sam-router<br/>bootstrap · relay · DHT"]
- A["sam-node A"]
- B["sam-node B"]
+ R["agentmesh-router<br/>bootstrap · relay · DHT"]
+ A["agentmesh-node A"]
+ B["agentmesh-node B"]
AG["agent"]
SVC["your tool or model"]
@@ -36,7 +36,7 @@ flowchart LR
## The control plane
-`sam-control-plane` is an HTTP service backed by SQLite or PostgreSQL. It is
+`agentmesh-control-plane` is an HTTP service backed by SQLite or PostgreSQL. It is
the only component that has to be trusted. It is not on the data path: tool
calls and model requests never pass through it.
@@ -62,7 +62,7 @@ covers all of that.
## Routers
-`sam-router` is a libp2p peer with a stable address. It runs the mesh's
+`agentmesh-router` is a libp2p peer with a stable address. It runs the mesh's
Kademlia DHT (a distributed hash table), where nodes advertise their services
and look up who provides what. It also relays traffic for nodes that cannot
accept inbound
@@ -76,7 +76,7 @@ and connect to the ones that answer.
## Nodes
-`sam-node` runs as one process per host or per pod, next to the service it
+`agentmesh-node` runs as one process per host or per pod, next to the service it
serves or the agent that uses it. On the mesh side it is a libp2p peer with
its own Ed25519 key. Its peer ID is derived from that key, and every other
component refers to the node by that ID.
@@ -145,13 +145,13 @@ The same three programs ship in several forms:
- **Binaries** for Linux, macOS and Windows, from the releases page or the
install script.
-- **Container images**: `ghcr.io/google/sam-control-plane`,
- `sam-router`, `sam-node`, `sam-console` and `sam-one`.
-- **`sam-one`**, a single binary that runs the control plane, a router and
+- **Container images**: `ghcr.io/google/agentmesh-control-plane`,
+ `agentmesh-router`, `agentmesh-node`, `agentmesh-console` and `agentmesh-one`.
+- **`agentmesh-one`**, a single binary that runs the control plane, a router and
the console in one process on one port, for laptops, Cloud Run and small
meshes.
-- **Helm charts**: `sam-mesh` deploys the control plane, router, console and
- PostgreSQL. `sam-node` deploys a node beside a service container.
+- **Helm charts**: `agentmesh-p2p` deploys the control plane, router, console and
+ PostgreSQL. `agentmesh-node` deploys a node beside a service container.
-The web console (`sam-console`) is a separate program that talks to the
+The web console (`agentmesh-console`) is a separate program that talks to the
control plane's admin API. It is not required to run a mesh.
diff --git a/site/content/docs/concepts/authorization.md b/site/content/docs/concepts/authorization.md
index 9e7e9416..d2729577 100644
--- a/site/content/docs/concepts/authorization.md
+++ b/site/content/docs/concepts/authorization.md
@@ -4,7 +4,7 @@ linkTitle: "Authorization"
weight: 3
---
-Authorization in SAM answers one question: may this caller perform this
+Authorization in Agent Mesh answers one question: may this caller perform this
operation on this service on this node right now? Four sources contribute to
the answer, and the destination node combines them:
@@ -37,7 +37,7 @@ IAM permissions and resources (`operation.allowed_permissions`,
## Mesh policy: roles and bindings
The mesh policy is a document held by the control plane. You edit it through
-`POST /policies` or the console. `sam-one` can also seed it on first boot
+`POST /policies` or the console. `agentmesh-one` can also seed it on first boot
from a file (`--policy-file`).
**Roles** name a set of standing permissions:
@@ -183,7 +183,7 @@ roles, grants, labels, and `client_peer_id`. The facts about the request
are added by the node that received the request, from what arrived on the
wire. A caller writes neither.
-When a holder attenuates a token by appending a block, SAM never evaluates
+When a holder attenuates a token by appending a block, Agent Mesh never evaluates
holder-authored Datalog rules or checks. Appended blocks are restricted to a
single `tar_block("<base64url-proto>")` fact, which is invisible to Block 0's
Datalog rules and is evaluated by the verifier's own `TaskAuthorizationRule`
@@ -196,7 +196,7 @@ matcher. This guarantees that:
## Workloads and agents acting through a node or gateway
-When multiple workloads, users, or sandboxed agents share a `sam-node` (or
+When multiple workloads, users, or sandboxed agents share a `agentmesh-node` (or
call through `agentgateway` / Istio), they do not share the node's own
permissions:
@@ -204,7 +204,7 @@ permissions:
`ext_authz` / `ext_proc`), the caller presents its own platform JWT (OIDC ID
token, Kubernetes projected SA JWT, or SPIFFE JWT-SVID) or a task-attenuated
Biscuit.
-- `sam-node` exchanges platform JWTs via `POST /token/exchange` into a
+- `agentmesh-node` exchanges platform JWTs via `POST /token/exchange` into a
**Delegated Session Biscuit** carrying the caller's own `user()`, `email()`,
`group()`, and `role()` facts, bound to the node via `client_peer_id()` and
`actor_node()`.
@@ -213,7 +213,7 @@ permissions:
## Local rules
-The `attenuation` block in `sam-node.yaml` gives the hosting node the final
+The `attenuation` block in `agentmesh-node.yaml` gives the hosting node the final
say. Use it for constraints that the operator of that node wants regardless
of what the mesh policy grants:
@@ -239,7 +239,7 @@ node without notice.
Labels are `key=value` pairs. A node declares them in its configuration, and
the control plane writes them into the node's credential as `label(k, v)`
facts, one per label, if a role the node holds allows them. Labels let
-policy describe where a node is or what it is for. SAM does not define a
+policy describe where a node is or what it is for. Agent Mesh does not define a
fixed set of keys: `region`, `jurisdiction`, `team`, `compliance`, or
whatever the operator needs.
diff --git a/site/content/docs/concepts/boundaries.md b/site/content/docs/concepts/boundaries.md
index e61a47ec..677b6ad4 100644
--- a/site/content/docs/concepts/boundaries.md
+++ b/site/content/docs/concepts/boundaries.md
@@ -25,7 +25,7 @@ deployment and the mechanism that enforces each of them.
- **Revocation.** A ban takes effect on the next credential refresh (within
the credential TTL, 24 hours by default) and, through the mesh event
channel, immediately on every connected node.
-- **Where the software runs.** SAM is Apache-2.0, sends no telemetry, and
+- **Where the software runs.** Agent Mesh is Apache-2.0, sends no telemetry, and
does not depend on any hosted service. The control plane, routers and
nodes run wherever you put them: a laptop, a private cluster, an
air-gapped network.
diff --git a/site/content/docs/concepts/identity.md b/site/content/docs/concepts/identity.md
index 1cba7bab..8a2d937a 100644
--- a/site/content/docs/concepts/identity.md
+++ b/site/content/docs/concepts/identity.md
@@ -15,15 +15,15 @@ revocation.
## Keys and peer IDs
The first thing a node does is generate an Ed25519 key pair and store it in
-its data directory (`~/.config/sam-mesh/agent.db` by default). Its **peer
+its data directory (`~/.config/agentmesh/agent.db` by default). Its **peer
ID**, the `12D3KooW...` string that appears in logs, discovery results and
proxy URLs, is derived from the public key. The key never leaves the machine.
The credential is bound to the key, so a copied credential is useless without
it, and every peer-to-peer connection proves possession of the key as part
of the libp2p handshake.
-`sam-node reset --all` deletes the key and gives the node a new peer ID.
-`sam-node reset` without `--all` keeps the key and deletes only the
+`agentmesh-node reset --all` deletes the key and gives the node a new peer ID.
+`agentmesh-node reset` without `--all` keeps the key and deletes only the
credential.
## Enrollment
@@ -32,7 +32,7 @@ Enrollment is a request to the control plane: "here is my public key, here is
who I am, please issue me a credential for role *X* with labels *Y*". There
are three ways to say who you are.
-**Interactive OIDC login.** `sam-node join <control-plane-url>` fetches the
+**Interactive OIDC login.** `agentmesh-node join <control-plane-url>` fetches the
control plane's `/info`, learns which identity provider it trusts, and runs an
OpenID Connect login. If a browser is available, it uses the loopback flow.
On a headless machine it uses the device flow (a URL and a code that you enter
@@ -42,26 +42,26 @@ one of these explicitly. The ID token from the login is sent to
challenge. This is how a person enrolls a laptop.
**Non-interactive OIDC.** A workload that already has an OIDC token does not
-need a login. `sam-node run --jwt-path <file>` enrolls with the token in that
+need a login. `agentmesh-node run --jwt-path <file>` enrolls with the token in that
file (such as a Kubernetes projected service account token or a SPIRE
JWT-SVID written by `spiffe-helper`). On GCE and Cloud Run,
-`sam-node run --cloud-provider gcp` (or `auto`) fetches an identity token
+`agentmesh-node run --cloud-provider gcp` (or `auto`) fetches an identity token
directly from the instance metadata server. `--client-id` and
`--client-secret-path` do the same with an OAuth client-credentials grant.
-Routers enroll in the same way with `sam-router --jwt-path`. The control
+Routers enroll in the same way with `agentmesh-router --jwt-path`. The control
plane marks workload issuers with `--workload-issuer` (`<issuer>` or
`<issuer>=<email-suffix>`) so workload tokens can enroll, refresh, and
exchange credentials while being refused at human operator endpoints
(`/user/*`, `/oauth/authorize`).
**Bootstrap token.** An operator mints a token with the admin API, the
-console, or `sam-one token create`, and copies it to the machine. The node
+console, or `agentmesh-one token create`, and copies it to the machine. The node
sends it to `POST /enroll`. Unless the control plane runs with
`--auto-approve-enrollment`, the request waits in a queue until an
administrator approves it, and the node polls `GET /enroll/status` while it
waits. A token has a role, an expiry and a usage count. A single-use token is
spent as soon as one node is approved with it. This is how machines without
-an identity of their own enroll, and how `sam-one` enrolls devices by QR
+an identity of their own enroll, and how `agentmesh-one` enrolls devices by QR
code.
For all three paths, the control plane checks the same things before it
@@ -72,7 +72,7 @@ mints a credential:
is registering.
2. Neither the peer ID nor the identity behind it is banned.
3. The identity resolves, through the bindings in the mesh policy, to the
- role being requested. `sam-node` requests `mesh:role:node` and `sam-router`
+ role being requested. `agentmesh-node` requests `mesh:role:node` and `agentmesh-router`
requests `mesh:role:router`. If the policy binds nobody to `mesh:role:node`,
no node can enroll.
4. Every label the node declared is permitted by the `allowed_labels` of a
@@ -116,8 +116,8 @@ ones the node asked for and the policy allowed. Grants come from the policy.
### 2. Delegated Session Biscuit (`POST /token/exchange`, `/oauth/token`)
-When a workload or user calls through an enrolled `sam-node` (or an Envoy /
-Istio / `agentgateway` proxy integrated with `sam-node`), the node exchanges
+When a workload or user calls through an enrolled `agentmesh-node` (or an Envoy /
+Istio / `agentgateway` proxy integrated with `agentmesh-node`), the node exchanges
the caller's platform JWT (OIDC ID token, Kubernetes projected SA JWT, or
SPIFFE JWT-SVID) at `POST /token/exchange` on the control plane. The control
plane verifies the node's credential and proof-of-possession signature,
@@ -135,7 +135,7 @@ database writes:
## Task attenuation (`tar_block`) and sealing
-Before starting a task or delegating to a sub-agent, any holder (`sam-node`,
+Before starting a task or delegating to a sub-agent, any holder (`agentmesh-node`,
an orchestrator via `POST /oauth/token`, or an SDK caller via
`session.attenuate(rule)`) can narrow a Biscuit offline by appending up to 8
blocks.
@@ -156,7 +156,7 @@ further blocks can be appended.
## Outbound federation: the control plane as OIDC issuer
-External cloud providers do not accept Biscuits, and SAM never forwards a
+External cloud providers do not accept Biscuits, and Agent Mesh never forwards a
caller's mesh token to an upstream API. Instead, the control plane acts as a
standard OIDC issuer (`/.well-known/openid-configuration` and `/jwks`, signed
with ES256).
@@ -165,8 +165,8 @@ When an egress node serves a destination configured with `oidc_federation` or
`aws_assume_role`, it verifies the caller's Biscuit and `tar_block` chain and
calls `POST /sts/token` on the control plane. The control plane re-verifies
the token and mints a short-lived ES256 border JWT (`sub` = caller principal,
-`act.sub` = egress node peer ID, `aud` = destination audience, `sam_roles` =
-caller mesh roles, `sam_task` = innermost task name), which the egress node
+`act.sub` = egress node peer ID, `aud` = destination audience, `mesh_roles` =
+caller mesh roles, `mesh_task` = innermost task name), which the egress node
exchanges at the cloud provider's STS endpoint (such as Google Workload or
Workforce Identity Federation or AWS `AssumeRoleWithWebIdentity`).
@@ -217,7 +217,7 @@ depends on how it enrolled:
- An OIDC node with a refresh token re-enrolls on its own.
- A bootstrap node needs an operator to mint a new token and run
- `sam-node join` again (or to restart the router with the new token). The
+ `agentmesh-node join` again (or to restart the router with the new token). The
node keeps its peer ID. The control plane recognises the approved peer and
mints a new credential without going through the approval queue.
- A bootstrap node whose record has `autonomous_recovery` set may refresh on
@@ -230,7 +230,7 @@ depends on how it enrolled:
Revocation operates at two levels:
1. **Mesh-wide node, identity, and root-prefix Biscuit revocation:**
- `POST /admin/revoke` with a peer ID (or `sam-one admin ban`, or the console)
+ `POST /admin/revoke` with a peer ID (or `agentmesh-one admin ban`, or the console)
marks the node as banned. Its next refresh is refused and the node daemon
exits. The control plane publishes banned peer IDs in `/info` and
`GET /revocations`, together with revoked root Biscuit revocation IDs
@@ -242,7 +242,7 @@ Revocation operates at two levels:
reverses both bans.
2. **Local task token revocation (`POST /oauth/revoke`):**
When an orchestrator or sandbox finishes a task before its TTL expires, it
- calls `POST /oauth/revoke` (RFC 7009) on the local `sam-node`, which records
+ calls `POST /oauth/revoke` (RFC 7009) on the local `agentmesh-node`, which records
the leaf token's `RevocationIds()[last]` in its local revocation cache until
the token's `expire_time`.
diff --git a/site/content/docs/concepts/networking.md b/site/content/docs/concepts/networking.md
index 200e9f02..b8356332 100644
--- a/site/content/docs/concepts/networking.md
+++ b/site/content/docs/concepts/networking.md
@@ -10,12 +10,12 @@ agent sees at each end.
## The node's local API
-An agent does not speak to the mesh directly. It speaks to the `sam-node` on
+An agent does not speak to the mesh directly. It speaks to the `agentmesh-node` on
its own machine, through one of two listeners:
- **TCP**, `127.0.0.1:8080` by default (`--bind-addr`). Every request must
carry the node's API token as `X-Mesh-Authentication: Bearer <token>`.
-- **A Unix socket**, `<data-dir>/sam.sock` by default (`--socket-path`),
+- **A Unix socket**, `<data-dir>/agentmesh.sock` by default (`--socket-path`),
created with mode `0600`. No token is needed, because only the user who
owns the socket can open it. `docker.sock` works the same way.
@@ -138,5 +138,5 @@ frame and body they read. Routers cap inbound connections per source address
total connections (`--low-watermark`, `--high-watermark`). Members behind a
NAT or a cluster's SNAT share one address, and the handshake, not the
per-address cap, is what keeps strangers out; the cap bounds how much of a
-router one address can occupy. `sam-one` sets it to the whole budget for its
+router one address can occupy. `agentmesh-one` sets it to the whole budget for its
embedded router, which sits behind a proxy and sees one address.
diff --git a/site/content/docs/contributing/_index.md b/site/content/docs/contributing/_index.md
index 7e3f8860..97c3b570 100644
--- a/site/content/docs/contributing/_index.md
+++ b/site/content/docs/contributing/_index.md
@@ -8,20 +8,20 @@ aliases:
- /docs/development/kubernetes-deployment/
---
-How to build SAM from source, run its tests, and bring up a local mesh to
+How to build Agent Mesh from source, run its tests, and bring up a local mesh to
develop against. Contributions go through GitHub pull requests and need a
signed [Contributor License Agreement](https://cla.developers.google.com/).
-[CONTRIBUTING.md](https://github.com/google/sam/blob/main/CONTRIBUTING.md)
+[CONTRIBUTING.md](https://github.com/google/agentmesh/blob/main/CONTRIBUTING.md)
in the repository has the details.
## Layout
| Path | Contents |
|---|---|
-| `cmd/` | One directory per binary: `sam-node`, `sam-control-plane`, `sam-router`, `sam-one`, `sam-console`, `mcp-client`, `sam-bench`, and smaller tools. |
+| `cmd/` | One directory per binary: `agentmesh-node`, `agentmesh-control-plane`, `agentmesh-router`, `agentmesh-one`, `agentmesh-console`, `mcp-client`, `agentmesh-bench`, and smaller tools. |
| `api/` | The wire contract: `agentmesh.proto` and its generated code, plus the Go types for the JSON admin API and the validation and Datalog helpers both sides share. |
| `internal/` | Implementation, one package per component (`node`, `controlplane`, `router`, `standalone`, `console`, `identity`, `storage`, ...). |
-| `charts/` | The `sam-mesh` and `sam-node` Helm charts. |
+| `charts/` | The `agentmesh-p2p` and `agentmesh-node` Helm charts. |
| `tests/integration/` | Go tests that start several components in one process. |
| `tests/e2e/` | Bats tests that drive the built binaries and containers. |
| `development/` | The kind environment and example services. |
@@ -40,7 +40,7 @@ You need Go 1.25 or later. Docker is needed for the container tests and the
linter, and `bats-core` for the end-to-end tests.
```bash
-git clone https://github.com/google/sam.git && cd sam
+git clone https://github.com/google/agentmesh.git && cd agentmesh
make build # binaries in ./bin
make docker-build # container images tagged :local
make proto # regenerate api/agentmesh.pb.go after editing agentmesh.proto
@@ -48,15 +48,15 @@ make proto # regenerate api/agentmesh.pb.go after editing agentmesh.proto
The repository has a dev container (`.devcontainer/devcontainer.json`) with
Go, Node, Python and Docker, and `make build` runs when it is created. Open
-it in a [GitHub codespace](https://codespaces.new/google/sam?quickstart=1)
+it in a [GitHub codespace](https://codespaces.new/google/agentmesh?quickstart=1)
or with the VS Code Dev Containers extension to build and test with nothing
-installed locally. `make testnet` inside a codespace starts `sam-one` on the
+installed locally. `make testnet` inside a codespace starts `agentmesh-one` on the
codespace's public URL, so you can point an SDK program or a phone at your
branch; the [Codespaces guide](../guides/codespaces/) has the steps.
Node and router control-plane requests identify themselves as
-`sam-node/<version>` and `sam-router/<version>`, including the router inside
-`sam-one`. These headers contain the software component and build version.
+`agentmesh-node/<version>` and `agentmesh-router/<version>`, including the router inside
+`agentmesh-one`. These headers contain the software component and build version.
They are diagnostic metadata that a caller can spoof and are never used for
authentication or authorization. They do not include peer IDs, credentials,
or authorization roles. Publishing a version lets an observer identify the
@@ -64,8 +64,8 @@ software release; keeping dependencies patched remains necessary.
`make` derives the version from `git describe --tags --always --dirty`.
You can override it with `make build VERSION=v0.1.0-custom` and inspect the
-node binary with `bin/sam-node --version`. Release binaries use the release
-tag, and published node, router and `sam-one` images use the tag or commit
+node binary with `bin/agentmesh-node --version`. Release binaries use the release
+tag, and published node, router and `agentmesh-one` images use the tag or commit
SHA. For direct Docker builds of those images, pass `--build-arg VERSION=...`;
without it, the version is `devel`. Plain `go build` uses Go's embedded module
or VCS metadata when available and falls back to `devel`.
@@ -77,7 +77,7 @@ The suite is layered so that most coverage lives where it runs fastest.
| Command | What runs | Time |
|---|---|---|
| `make test` | Every Go test with the race detector: the unit tests next to the code, and the integration tests under `tests/integration/`, which start a control plane, a router and nodes in one process. Each integration test is expected to finish within ten seconds. `WHAT=TestName` runs a subset. | minutes |
-| `make e2e-test` | The Bats suite under `tests/e2e/`, in parallel. It covers the CLI (`sam.bats`), a containerised mesh with a mock identity provider (`container_mesh.bats` and the tests built on it), policy, services, A2A, the console, `sam-one`, and the sandbox. It builds the binaries and images first. `WHAT=pattern` filters the tests. | 10 to 30 minutes |
+| `make e2e-test` | The Bats suite under `tests/e2e/`, in parallel. It covers the CLI (`agentmesh.bats`), a containerised mesh with a mock identity provider (`container_mesh.bats` and the tests built on it), policy, services, A2A, the console, `agentmesh-one`, and the sandbox. It builds the binaries and images first. `WHAT=pattern` filters the tests. | 10 to 30 minutes |
| `make test-e2e-container` | Only the containerised-mesh test. | |
| `make ui-test` | Playwright against the console, on a stack of local processes with SQLite. `make ui-dev` starts the same stack and leaves it running for manual use. | |
| `make lint` | `go fmt`, Helm lint, then `golangci-lint` in Docker and a dead-code check. Any exported identifier that no binary and no test reaches fails the check, so new exported API must land together with its tests. | about a minute |
@@ -105,7 +105,7 @@ make kind-logs # reattach the log view
make kind-down # delete everything
```
-The mesh comes up with no nodes. Put a service on it with the `sam-node`
+The mesh comes up with no nodes. Put a service on it with the `agentmesh-node`
chart and one of the examples:
```bash
@@ -113,14 +113,14 @@ chart and one of the examples:
```
The script builds the example's image, loads it into the cluster, and
-installs a `sam-node` release with the example's `values.yaml` on top of
-`development/kind/sam-node.values.yaml`. Any directory with a `Dockerfile`
+installs a `agentmesh-node` release with the example's `values.yaml` on top of
+`development/kind/agentmesh-node.values.yaml`. Any directory with a `Dockerfile`
and a `values.yaml` works, and extra arguments are passed to Helm.
To use the mesh from a node built from your working tree:
```bash
-make kind-local-node # mints a bootstrap token, runs ./bin/sam-node, API on 127.0.0.1:9099 with token "devtoken"
+make kind-local-node # mints a bootstrap token, runs ./bin/agentmesh-node, API on 127.0.0.1:9099 with token "devtoken"
make kind-local-node ARGS="--config my-node.yaml"
./bin/mcp-client -url http://127.0.0.1:9099/mcp -token devtoken -tool find_remote_tools -args '{}'
@@ -136,7 +136,7 @@ The site is Hugo with the Docsy theme, under `site/`. The deploy workflow
pins Hugo 0.136.5, and newer Hugo releases do not build the current Docsy
version, so use that release locally too. Run `npm ci` once in `site/` for
the CSS pipeline, then `hugo server`. The site deploys from `main` to
-`sam-mesh.dev`. When a page moves, keep its old URL with `aliases` in the
+`__PROTECT_Agent Mesh_MESH_DEV__`. When a page moves, keep its old URL with `aliases` in the
front matter. `tests/e2e/docs_snippets.bats` runs the Python snippet under
`site/content/docs/snippets/` against a live node, so a change to that
snippet is a change to a test.
@@ -144,6 +144,6 @@ snippet is a change to a test.
## Releases and testnets
A `v*` tag produces a GitHub release with binaries and images through
-`goreleaser`, and deploys to the `hub.sam-mesh.dev` testnet. Every push to
-`main` deploys to `bananas.sam-mesh.dev`. [Testnets](testnets/) describes
+`goreleaser`, and deploys to the `hub.__PROTECT_Agent Mesh_MESH_DEV__` testnet. Every push to
+`main` deploys to `bananas.__PROTECT_Agent Mesh_MESH_DEV__`. [Testnets](testnets/) describes
both.
diff --git a/site/content/docs/contributing/security-architecture.md b/site/content/docs/contributing/security-architecture.md
index da778481..f30b9c7b 100644
--- a/site/content/docs/contributing/security-architecture.md
+++ b/site/content/docs/contributing/security-architecture.md
@@ -7,12 +7,12 @@ aliases:
- /docs/development/sts/
---
-This document describes the security architecture and posture of SAM for
-developers and security reviewers. It covers how SAM acts as an authority,
+This document describes the security architecture and posture of Agent Mesh for
+developers and security reviewers. It covers how Agent Mesh acts as an authority,
Policy Decision Point (PDP), and task-scoped credential layer across
environments, what problems it solves, what responsibilities remain with the
surrounding platform, how its cryptographic and policy mechanisms work across
-`sam-control-plane`, `sam-node`, `sam-router`, and the native SDKs, and which
+`agentmesh-control-plane`, `agentmesh-node`, `agentmesh-router`, and the native SDKs, and which
extensions are deferred on purpose.
---
@@ -21,27 +21,27 @@ extensions are deferred on purpose.
![The Agent Mesh as a courier network](/images/agent-mesh-courier.svg)
-SAM moves tasks between environments that trust nothing on arrival, the way a
+Agent Mesh moves tasks between environments that trust nothing on arrival, the way a
courier network moves parcels between post offices:
-| In the picture | In SAM |
+| In the picture | In Agent Mesh |
| :--- | :--- |
| **Parcel** | One request: an MCP tool call, a chat completion, a BigQuery query, an A2A message. |
| **Sender** | The agent wherever it runs: a developer laptop, Kubernetes on premises or in a cloud, a SaaS platform, or a sandbox runtime. |
-| **Local post office** | The `sam-node` next to the agent, or the native SDK (`@sam-mesh/sdk`, `sam-mesh`) inside its process. It checks the sender's platform identity (projected service account token, GCE/Cloud Run metadata token, SPIFFE JWT-SVID, OIDC login) and obtains the waybill from the Registry. |
-| **Your gateway** | Istio, `agentgateway`, Envoy AI Gateway, or `kgateway` where a cluster already runs one. It stays in the data path and asks the `sam-node` office over Envoy `ext_proc`, `ext_authz`, or RFC 8693 `/oauth/token`; the office issues the waybill, the gateway carries. |
-| **Waybill** | The SAM Biscuit credential: who the sender (subject) is, through which office (`actor_node`) it travels, what standing roles it holds, and when it expires. |
+| **Local post office** | The `agentmesh-node` next to the agent, or the native SDK (`@agentmesh-p2p/sdk`, `agentmesh-p2p`) inside its process. It checks the sender's platform identity (projected service account token, GCE/Cloud Run metadata token, SPIFFE JWT-SVID, OIDC login) and obtains the waybill from the Registry. |
+| **Your gateway** | Istio, `agentgateway`, Envoy AI Gateway, or `kgateway` where a cluster already runs one. It stays in the data path and asks the `agentmesh-node` office over Envoy `ext_proc`, `ext_authz`, or RFC 8693 `/oauth/token`; the office issues the waybill, the gateway carries. |
+| **Waybill** | The Agent Mesh Biscuit credential: who the sender (subject) is, through which office (`actor_node`) it travels, what standing roles it holds, and when it expires. |
| **Mandate** | An offline attenuation block (`tar_block`) appended at a task or sub-agent hop. It can only restrict; a sub-agent's parcel carries one mandate more than its parent's. |
| **Sealed bag** | The mutually authenticated, encrypted libp2p stream between two offices. Routers relay ciphertext across NAT, clusters, sites, and clouds and cannot open it. |
-| **Registry** | `sam-control-plane`: verifies senders, stamps waybills (`POST /register`, `POST /enroll`, `POST /token/exchange`), distributes Datalog policy (`GET /policies`), issues the permits foreign borders recognize (`POST /sts/token`, `/.well-known/openid-configuration`, `/jwks`), and keeps the receipts. It never touches a parcel. |
-| **Destination office** | The serving or egress `sam-node` for `mcp://`, `inference://`, `a2a://`, or `egress://`: verifies the waybill and every mandate again, runs customs, obtains the permit, and delivers. The operator chooses where it runs, hence from which network or jurisdiction traffic leaves. |
+| **Registry** | `agentmesh-control-plane`: verifies senders, stamps waybills (`POST /register`, `POST /enroll`, `POST /token/exchange`), distributes Datalog policy (`GET /policies`), issues the permits foreign borders recognize (`POST /sts/token`, `/.well-known/openid-configuration`, `/jwks`), and keeps the receipts. It never touches a parcel. |
+| **Destination office** | The serving or egress `agentmesh-node` for `mcp://`, `inference://`, `a2a://`, or `egress://`: verifies the waybill and every mandate again, runs customs, obtains the permit, and delivers. The operator chooses where it runs, hence from which network or jurisdiction traffic leaves. |
| **Customs** | Content inspection at the destination office: built-in policy facts, Google Cloud Model Armor, and Envoy `ext_proc` processors. |
| **Permit** | The destination credential: a federated cloud token exchanged from the Registry's ES256 JWT for this sender and task, or a secret from the office vault. The agent never holds it. |
-| **Receipts** | Structured audit logs at the Registry, at both offices, and at the cloud destination, joined by principal and `sam_task`. |
+| **Receipts** | Structured audit logs at the Registry, at both offices, and at the cloud destination, joined by principal and `mesh_task`. |
---
-## 2. What problems SAM solves
+## 2. What problems Agent Mesh solves
In traditional cloud and service-mesh architectures, permissions are granted
ambiently to a workload identity (a Kubernetes Service Account, a cloud service
@@ -69,24 +69,24 @@ caller, but AI agents need finer boundaries across five dimensions:
cloud audit log records the actual user or workload principal rather than a
shared node service account.
5. Agents and tools run across laptops, on-premises clusters, and multiple
- clouds behind NATs and firewalls. SAM routes and authorizes every call on the
+ clouds behind NATs and firewalls. Agent Mesh routes and authorizes every call on the
service name (`mcp://`, `inference://`, `a2a://`, `egress://`), never on an
IP address.
### Two-layer identity and authorization model
-SAM separates caller attestation from task authorization:
+Agent Mesh separates caller attestation from task authorization:
-| Layer | Question answered | Primitive | Role in SAM |
+| Layer | Question answered | Primitive | Role in Agent Mesh |
| :--- | :--- | :--- | :--- |
| **1. Workload / Subject & Channel Attestation** | *"Which workload or user initiated this request, and through which node is it travelling?"* | **OIDC ID tokens**, **Kubernetes projected SA JWTs**, **GCE/Cloud Run identity tokens**, or **SPIFFE JWT-SVIDs**. | Verified at `POST /register` (node enrollment) or `POST /token/exchange` (caller delegation) to mint a Biscuit bound to the transport channel (`client_peer_id`, `actor_node`). |
-| **2. Task / Session Authorization (TAR)** | *"What subset of standing permissions may this specific task or sub-agent hop exercise right now?"* | **SAM Task Biscuit** (Block 0 Authority + appended `tar_block` blocks carrying `api.TaskAuthorizationRule`). | Attenuated offline across hops, enforced at every SAM Policy Enforcement Point (PEP), and translated into downscoped upstream cloud credentials by `CloudTokenExchanger` at egress. |
+| **2. Task / Session Authorization (TAR)** | *"What subset of standing permissions may this specific task or sub-agent hop exercise right now?"* | **Agent Mesh Task Biscuit** (Block 0 Authority + appended `tar_block` blocks carrying `api.TaskAuthorizationRule`). | Attenuated offline across hops, enforced at every Agent Mesh Policy Enforcement Point (PEP), and translated into downscoped upstream cloud credentials by `CloudTokenExchanger` at egress. |
---
-## 3. What SAM does not solve
+## 3. What Agent Mesh does not solve
-SAM leaves several responsibilities to the surrounding platform.
+Agent Mesh leaves several responsibilities to the surrounding platform.
### 3.1 OS, kernel, and container sandboxing
@@ -96,7 +96,7 @@ namespaces, and its external secret-injecting proxy), Docker Sandbox
(`docker sbx`), or Kubernetes `agent-sandbox` (`RuntimeClass: gvisor` or `kata`
paired with a Kubernetes `NetworkPolicy`).
-SAM provides the cryptographic task authority that those sandboxes consume:
+Agent Mesh provides the cryptographic task authority that those sandboxes consume:
control-plane-signed Delegated Session Biscuits (`POST /token/exchange`) and
sealed offline task attenuations (`tar_block` + `Seal()`).
@@ -104,24 +104,24 @@ sealed offline task attenuations (`tar_block` + `Seal()`).
Where a cluster already runs `agentgateway`, Istio, Envoy AI Gateway, or
`kgateway`, that proxy stays in place. Cluster gateways validate flat JWTs and
-route local traffic, while `sam-node` plugs into them over Envoy `ext_authz`,
+route local traffic, while `agentmesh-node` plugs into them over Envoy `ext_authz`,
Envoy `ext_proc`, and RFC 8693 `/oauth/token` to add offline multi-hop task
attenuation, cross-network peer-to-peer routing, and cloud credential
brokering.
### 3.3 Using SPIFFE X509-SVID keys as libp2p member keys
-Every mesh member (`sam-node`, `sam-router`, and native SDK peers) generates and
+Every mesh member (`agentmesh-node`, `agentmesh-router`, and native SDK peers) generates and
persists its own Ed25519 libp2p key pair. The peer ID derived from that key is
the primary key of the enrollment record, the value of `node()` and
`client_peer_id()`, the member in `node:<peer_id>` bindings, the holder of
router leases and discovery announcements, and the suffix of `/p2p/<peer_id>`
addresses.
-SAM never uses an X509-SVID private key from the SPIFFE Workload API as the
+Agent Mesh never uses an X509-SVID private key from the SPIFFE Workload API as the
libp2p key:
-| Property | SVID key as the libp2p key | SAM design |
+| Property | SVID key as the libp2p key | Agent Mesh design |
| :--- | :--- | :--- |
| **Algorithm** | SPIRE issues EC P-256 or RSA keys, not Ed25519. The TypeScript/Python SDKs, mobile FFI, and portable `MemberCredential` state directories are Ed25519-only. | Ed25519 for every member. |
| **Rotation** | SPIRE rotates X509-SVIDs with a fresh key pair (every 30 minutes by default) and accepts no CSR on the Workload API. Every rotation would change the peer ID, drop active streams, and break `node:<peer_id>` bindings. | The Ed25519 key is stable for the life of the enrollment; the Biscuit is the rotating credential (`POST /refresh`). |
@@ -134,14 +134,14 @@ Where each layer enforces depends on what the destination cloud API supports:
| Destination class | Border credential | Per-task narrowing enforced today | Residual boundary |
| :--- | :--- | :--- | :--- |
-| **Google Cloud APIs** (BigQuery, Vertex AI, Cloud Storage) | Control-plane ES256 JWT federated via Workload or Workforce Identity Pool (`oidc_federation`), optional SA impersonation with narrowed `scopes` | Mesh PEP on host, HTTP method, and REST path (BigQuery REST paths carry project, dataset, and table; Vertex paths carry the model); OAuth scopes; CEL attribute conditions on `act.sub`; `principalSet` bindings on `google.groups` (`sam_roles`); Credential Access Boundaries for Cloud Storage. | A body-level reference inside an allowed REST path (for example, a SQL string in BigQuery `jobs.insert` referencing a second table) is bounded by the federated principal's standing IAM ceiling until a public Google per-task token API exists. |
+| **Google Cloud APIs** (BigQuery, Vertex AI, Cloud Storage) | Control-plane ES256 JWT federated via Workload or Workforce Identity Pool (`oidc_federation`), optional SA impersonation with narrowed `scopes` | Mesh PEP on host, HTTP method, and REST path (BigQuery REST paths carry project, dataset, and table; Vertex paths carry the model); OAuth scopes; CEL attribute conditions on `act.sub`; `principalSet` bindings on `google.groups` (`mesh_roles`); Credential Access Boundaries for Cloud Storage. | A body-level reference inside an allowed REST path (for example, a SQL string in BigQuery `jobs.insert` referencing a second table) is bounded by the federated principal's standing IAM ceiling until a public Google per-task token API exists. |
| **AWS** (`aws_assume_role`) | Control-plane ES256 JWT via `AssumeRoleWithWebIdentity` | Inline AWS session policy compiled from the intersected `TaskAuthorizationRule` chain (`allowed_permissions` $\rightarrow$ `Action`, `allowed_resources` $\rightarrow$ `Resource`) intersected with the role's standing IAM policy. | AWS 1-hour role-chaining limit (sub-agent hops re-assume from the egress node rather than chaining AWS STS credentials) and packed session policy size limit. |
| **API-key services** (Gemini Developer API, OpenAI, Anthropic, GitHub PATs) | `static_secret` from the egress node's `--secrets-dir` | Mesh PEP on service name, HTTP method, REST path (model name), MCP tool name, and task TTL. | Static API keys cannot be downscoped at the upstream provider; the egress node never exposes the key to the caller. |
-| **External agents (`a2a://`) & third-party MCP servers** | Control-plane JWT if the party federates with the SAM OIDC issuer; otherwise `static_secret` | Mesh PEP plus whatever scope/claim checks the remote authorization server enforces. | Depends on the remote party's authorization server. |
+| **External agents (`a2a://`) & third-party MCP servers** | Control-plane JWT if the party federates with the Agent Mesh OIDC issuer; otherwise `static_secret` | Mesh PEP plus whatever scope/claim checks the remote authorization server enforces. | Depends on the remote party's authorization server. |
### 3.5 Non-HTTP protocols without TLS SNI
-SAM terminates and inspects HTTP/1.1 and HTTP/2 (REST, JSON-RPC MCP, A2A, SSE)
+Agent Mesh terminates and inspects HTTP/1.1 and HTTP/2 (REST, JSON-RPC MCP, A2A, SSE)
and supports raw TCP carrying TLS (PostgreSQL, Cloud SQL, AlloyDB, Redis, SSH)
via named `CONNECT` tunnels (`EGRESS_MODE_TCP`). It does not proxy raw UDP,
QUIC/HTTP/3, ICMP, or raw IP frames, and it does not inject brokered credentials
@@ -151,15 +151,15 @@ allow-list and TLS `ClientHello` SNI match.
---
-## 4. How SAM solves it
+## 4. How Agent Mesh solves it
### 4.1 Platform attestation, binding wildcards, and workload containment
#### Node attestation sources (`TokenSource`)
-`sam-node` and `sam-router` consolidate headless enrollment and continuous
+`agentmesh-node` and `agentmesh-router` consolidate headless enrollment and continuous
refresh re-attestation behind the
-[`TokenSource`](https://github.com/google/sam/blob/main/internal/controlplane/client/tokensource.go)
+[`TokenSource`](https://github.com/google/agentmesh/blob/main/internal/controlplane/client/tokensource.go)
interface (`FetchToken(ctx)`):
| Environment | Token source | How it works |
@@ -184,8 +184,8 @@ a single leading `*` (`$v.ends_with("<suffix>")`), evaluated identically in
control-plane role resolution (`resolveRoles`) and node-side Datalog generation
(`api.BuildPolicyRules`):
-- `user:system:serviceaccount:sam-nodes:*` matches any service account in
- namespace `sam-nodes`.
+- `user:system:serviceaccount:agentmesh-nodes:*` matches any service account in
+ namespace `agentmesh-nodes`.
- `user:spiffe://acme.example/ns/prod/*` matches any SPIFFE workload under that
path prefix.
- `email:*@my-project.iam.gserviceaccount.com` matches any Google Cloud service
@@ -225,7 +225,7 @@ verifier pool) classifies tokens as workload identities:
#### Continuous attestation on `POST /refresh` and `--workload-session-ttl`
-When `sam-node`, `sam-router`, or an SDK member has a continuous token source,
+When `agentmesh-node`, `agentmesh-router`, or an SDK member has a continuous token source,
it includes a fresh platform JWT in `TokenRefreshRequest.jwt` on every Biscuit
refresh:
@@ -250,7 +250,7 @@ appended block carried both Datalog checks and a serialized protobuf, a
malicious holder could craft a token where the Datalog check passes at the mesh
PEP while a broader protobuf is forwarded to `CloudTokenExchanger`.
-SAM never evaluates holder-authored Datalog rules or checks.
+Agent Mesh never evaluates holder-authored Datalog rules or checks.
Every appended block (`block_idx >= 1`) contains `0` Datalog rules, `0` Datalog
checks, and `1` Datalog fact of the form
@@ -290,7 +290,7 @@ least one `TaskRule` in every appended block.
### 4.3 Subject vs. actor (`actor_node`), stateless exchange, and revocation
-When a `sam-node` exchanges a caller's platform token on their behalf, the
+When a `agentmesh-node` exchanges a caller's platform token on their behalf, the
resulting Biscuit separates the node that owns the transport channel
(`actor_node`) from the subject whose identity is being exercised (`user`,
`email`, `role`), matching RFC 8693 (`sub` vs. `act`).
@@ -323,7 +323,7 @@ uses `b.RevocationIds()[0]` to identify the authority block, so revoking a root
token or banning a peer or user at the control plane invalidates both the root
Biscuit and every offline-attenuated child derived from it across the mesh.
Local task revocation (`POST /oauth/revoke`) lets an orchestrator revoke a
-specific child Task Biscuit at the local `sam-node` as soon as a task finishes,
+specific child Task Biscuit at the local `agentmesh-node` as soon as a task finishes,
caching `RevocationIds()[last]` in the node's revocation LRU until the token's
`expire_time`.
@@ -332,7 +332,7 @@ caching `RevocationIds()[last]` in the node's revocation LRU until the token's
### 4.4 Two-token model: the control plane as OIDC issuer
Inside the mesh, credentials are Biscuits; at both external borders,
-credentials are standard JWTs. For the outbound border, `sam-control-plane` acts
+credentials are standard JWTs. For the outbound border, `agentmesh-control-plane` acts
as a standard OIDC issuer:
| Element | Implementation |
@@ -340,8 +340,8 @@ as a standard OIDC issuer:
| **Signing key** | **ES256** (P-256 ECDSA), rotated with overlap and `kid` (`internal/controlplane/sts.go`). Google Cloud and AWS STS accept RS256 and ES256, not Ed25519; Ed25519 remains the Biscuit authority key. |
| **Discovery & JWKS** | `GET /.well-known/openid-configuration` and `GET /jwks` on the control plane. For air-gapped or private control planes, the JWKS can be uploaded directly to the cloud workload identity pool. |
| **Mint endpoint** | `POST /sts/token` (protobuf over HTTP): accepts the caller's Biscuit and `destination` name, verifies the Biscuit and the full `tar_block` chain against `egress://<destination>`, writes a `Border Crossing` audit log, and returns a short-lived ES256 JWT. |
-| **JWT claims** | `iss` = control plane URL; `sub` = caller principal (`email` or `issuer#subject`); `act` = `{"sub": "<egress_node_peer_id>"}`; `aud` = destination audience from `EgressDestination` (one audience per destination); `sam_roles` = authority-block roles (mapped to `google.groups` for `principalSet` bindings); `sam_task` = innermost `TaskAuthorizationRule.name` (audit-only). |
-| **TAR narrows, never selects** | Nothing in a holder-appended `tar_block` can select a broker, role ARN, service account, or audience; every claim that cloud IAM binds on (`sub`, `sam_roles`, `act.sub`, `aud`) comes from Block 0 or the control plane's `EgressDestination` policy. |
+| **JWT claims** | `iss` = control plane URL; `sub` = caller principal (`email` or `issuer#subject`); `act` = `{"sub": "<egress_node_peer_id>"}`; `aud` = destination audience from `EgressDestination` (one audience per destination); `mesh_roles` = authority-block roles (mapped to `google.groups` for `principalSet` bindings); `mesh_task` = innermost `TaskAuthorizationRule.name` (audit-only). |
+| **TAR narrows, never selects** | Nothing in a holder-appended `tar_block` can select a broker, role ARN, service account, or audience; every claim that cloud IAM binds on (`sub`, `mesh_roles`, `act.sub`, `aud`) comes from Block 0 or the control plane's `EgressDestination` policy. |
| **Caching** | The egress node caches minted border JWTs and upstream cloud tokens by Biscuit SHA-256 digest, keeping the control plane off the per-request hot path. |
---
@@ -351,7 +351,7 @@ as a standard OIDC issuer:
| Surface | Mechanism | What it binds | Replay defense |
| :--- | :--- | :--- | :--- |
| **libp2p data path** (node-to-node, node-to-router) | Channel binding: Block 0 `client_peer_id` must equal the `connection_peer_id` authenticated by the libp2p Noise or TLS handshake. | The transport private key | None needed; the token is unusable on any other connection. |
-| **Control plane mesh protocol** (`/enroll`, `/enroll/status`, `/register`, `/refresh`, `/routers/lease`, `/token/exchange`, `/sts/token`) | Ed25519 signature over `sam:<endpoint>:<peer_id>:<challenge_unix_ms>`, carried in protobuf fields (`challenge_unix_ms`, `challenge_signature`) or `X-Mesh-Challenge-Ts` / `X-Mesh-Challenge-Sig` on `GET /enroll/status`. | Endpoint name, peer ID, timestamp | 5-minute freshness window (`challengeMaxAge`) with one-shot `Date`-header clock-skew recovery on `401`; `/refresh` additionally redeems only the last Biscuit issued to the peer. |
+| **Control plane mesh protocol** (`/enroll`, `/enroll/status`, `/register`, `/refresh`, `/routers/lease`, `/token/exchange`, `/sts/token`) | Ed25519 signature over `mesh:<endpoint>:<peer_id>:<challenge_unix_ms>`, carried in protobuf fields (`challenge_unix_ms`, `challenge_signature`) or `X-Mesh-Challenge-Ts` / `X-Mesh-Challenge-Sig` on `GET /enroll/status`. | Endpoint name, peer ID, timestamp | 5-minute freshness window (`challengeMaxAge`) with one-shot `Date`-header clock-skew recovery on `401`; `/refresh` additionally redeems only the last Biscuit issued to the peer. |
| **Control plane read & report endpoints** (`GET /policies`, `GET /egress`, `GET /revocations`, `POST /nodes/catalog`) | Bearer Member Biscuit of an admitted node (`admittedNodeWithChallenge`) plus `X-Mesh-Challenge-Ts` / `X-Mesh-Challenge-Sig` signed over `sam:<endpoint>:<peer_id>:<ts>` (`policies`, `egress`, `revocations`, `nodes-catalog`), verified against the node's stored Ed25519 public key via `verifyFreshChallenge`. | Enrolled node credential, endpoint name, peer ID, timestamp | 5-minute freshness window (`challengeMaxAge`) with one-shot `Date`-header clock-skew recovery on `401`, bounded by Biscuit TTL and ban/revocation list. |
| **OAuth 2.1 external client surface** (`/oauth/authorize`, `/oauth/token`, `/mcp` over HTTPS) | Authorization Code + PKCE (`S256`) on the code grant. The `client_peer_id` of the minted Biscuit is the calling node's when a node calls, otherwise the `actor_peer_id` form parameter or the control plane's own peer ID (`resolveDefaultActorPeer`). | A claimed peer ID (the Biscuit is a bearer token on the HTTPS `/mcp` hop unless sender-constrained with DPoP; see §5.2) | Single-use authorization codes with PKCE verifier check on the code exchange; none on the resulting bearer Biscuit. |
@@ -359,9 +359,9 @@ as a standard OIDC issuer:
### 4.6 Gateways, egress credential brokers, content inspection, and TCP tunnels
-#### Gateway integration (`sam-node`)
+#### Gateway integration (`agentmesh-node`)
-`sam-node` exposes three standard gateway interfaces on its HTTP listener
+`agentmesh-node` exposes three standard gateway interfaces on its HTTP listener
(`--bind-addr`):
1. Envoy `ext_authz` (`/ext_authz` and
@@ -369,7 +369,7 @@ as a standard OIDC issuer:
policy and `tar_block` rules on incoming Envoy `CheckRequest` calls. The
caller presents a Biscuit (`X-Mesh-Biscuit`, or a Bearer value in
`X-Mesh-Authentication` or `Authorization`) or a platform JWT, which
- `sam-node` exchanges at the control plane into a delegated Biscuit. On `OK`
+ `agentmesh-node` exchanges at the control plane into a delegated Biscuit. On `OK`
it returns `X-Mesh-Biscuit`, `X-Mesh-Principal`, `X-Mesh-Roles`,
`X-Mesh-Task-Id` and, for `egress://` targets with a credential broker, the
brokered upstream `Authorization` header.
@@ -385,7 +385,7 @@ as a standard OIDC issuer:
On `/mesh/{peer}/{type}/{svc}/...`, the `Authorization` header is reserved for
the destination service's own credential and passes through untouched; callers
-pass their SAM Biscuit or JWT in `X-Mesh-Authentication`. Transparent JWT
+pass their Agent Mesh Biscuit or JWT in `X-Mesh-Authentication`. Transparent JWT
exchange on `Authorization: Bearer <JWT>` applies only to `/mcp` and `/v1/*`.
#### Content inspection at the egress node (`inspection.inspectors`)
@@ -419,7 +419,7 @@ inspector never sees destination credentials:
When `mode: EGRESS_MODE_TCP` and a non-empty `ports` allow-list are set on an
`EgressDestination`, the node accepts `CONNECT <name>:<port>` and
-`sam-node forward egress://<name>:<port> <local-addr>`. Before splicing the TCP
+`agentmesh-node forward egress://<name>:<port> <local-addr>`. Before splicing the TCP
stream, the egress node peeks at the TLS `ClientHello` and refuses the
connection if the SNI does not match `<name>` or if Encrypted Client Hello (ECH)
hides the SNI.
@@ -437,13 +437,13 @@ flowchart LR
end
subgraph Host["Host / Orchestrator Boundary"]
OSProxy["OpenShell Egress Proxy<br/>& Secret Injector"]
- SamNode["Local sam-node Gateway"]
+ AgentMeshNode["Local agentmesh-node Gateway"]
end
- Mesh(["SAM Mesh & Providers"])
+ Mesh(["Agent Mesh Mesh & Providers"])
- Harness -- "Plain HTTP to sam-node:8080/mcp & /v1" --> OSProxy
- OSProxy -- "Injects X-Mesh-Authentication:<br/>Bearer <Sealed-Task-Biscuit>" --> SamNode
- SamNode -- "X-Mesh-Biscuit: <Sealed-Task-Biscuit>" --> Mesh
+ Harness -- "Plain HTTP to agentmesh-node:8080/mcp & /v1" --> OSProxy
+ OSProxy -- "Injects X-Mesh-Authentication:<br/>Bearer <Sealed-Task-Biscuit>" --> AgentMeshNode
+ AgentMeshNode -- "X-Mesh-Biscuit: <Sealed-Task-Biscuit>" --> Mesh
```
The orchestrator exchanges and attenuates a Task Biscuit via `POST /oauth/token`
@@ -452,13 +452,13 @@ The sandboxed process holds zero credentials in its environment or filesystem.
#### Blueprint 2: Docker Sandbox (`docker sbx`) & Kubernetes `agent-sandbox`
-When the sandbox container holds a token (`SAM_TASK_TOKEN` or a Kubernetes
+When the sandbox container holds a token (`AGENTMESH_TASK_TOKEN` or a Kubernetes
projected service account JWT) to authenticate to a local or cluster
-`sam-node`:
+`agentmesh-node`:
1. The token is sealed (`Seal()`) and narrowed to the single task's
`TaskAuthorizationRule`.
-2. Channel binding (`client_peer_id`) ties the token to the origin `sam-node`'s
+2. Channel binding (`client_peer_id`) ties the token to the origin `agentmesh-node`'s
peer ID, so an exfiltrated token cannot be used from another host or node.
3. A short `expire_time` and explicit revocation (`POST /oauth/revoke` on
container exit) bound the lifetime to the task run.
@@ -466,25 +466,25 @@ projected service account JWT) to authenticate to a local or cluster
#### Blueprint 3: `agentgateway` / Istio service mesh
Workloads authenticate to `agentgateway` or Istio with a platform JWT (for
-example a SPIFFE JWT-SVID) or a Task Biscuit; the gateway calls `sam-node` over `ext_authz`, `ext_proc`, or RFC
+example a SPIFFE JWT-SVID) or a Task Biscuit; the gateway calls `agentmesh-node` over `ext_authz`, `ext_proc`, or RFC
8693 `/oauth/token` for local policy enforcement and routes cross-cluster MCP,
-A2A, and cloud egress calls through `sam-node`.
+A2A, and cloud egress calls through `agentmesh-node`.
#### Blueprint 4: End-to-end cloud egress (BigQuery read-only task & sub-agent hop)
```mermaid
sequenceDiagram
autonumber
- participant Origin as Origin sam-node / SDK agent
- participant Egress as Egress sam-node (egress://bigquery.googleapis.com)
- participant CP as SAM Control Plane (OIDC issuer)
+ participant Origin as Origin agentmesh-node / SDK agent
+ participant Egress as Egress agentmesh-node (egress://bigquery.googleapis.com)
+ participant CP as Agent Mesh Control Plane (OIDC issuer)
participant STS as Provider STS (sts.googleapis.com / sts.amazonaws.com)
participant API as Destination API
Origin->>Egress: libp2p stream GET /egress/bigquery.googleapis.com/bigquery/v2/...<br/>AuthFrame.biscuit = <Task Biscuit (authority + tar_block 1..k)>
Note over Egress: 1. Authorize: CP signature, actor binding,<br/>standing policy for the subject, TAR chain on<br/>service(), host(), port(), method(), path()
Egress->>CP: 2. POST /sts/token { biscuit, destination } (cache miss on biscuit digest)
- Note over CP: Verifies the Biscuit and TAR chain again;<br/>mints ES256 JWT: sub=principal, act=egress node,<br/>aud=destination audience, sam_task, exp=minutes
+ Note over CP: Verifies the Biscuit and TAR chain again;<br/>mints ES256 JWT: sub=principal, act=egress node,<br/>aud=destination audience, mesh_task, exp=minutes
CP-->>Egress: 3. JWT
Egress->>STS: 4. RFC 8693 exchange: subject_token=JWT<br/>(Google: pool provider; AWS: AssumeRoleWithWebIdentity + session Policy from TAR)
STS-->>Egress: 5. Short-lived destination credential (cached by biscuit digest)
@@ -504,7 +504,7 @@ Every authenticated mesh-protocol endpoint on the control plane (`POST /enroll`,
`GET /enroll/status`, `POST /register`, `POST /refresh`, `POST /routers/lease`,
`POST /token/exchange`, `POST /sts/token`, `GET /policies`, `GET /egress`,
`GET /revocations`, and `POST /nodes/catalog`) verifies an Ed25519 signature
-over `sam:<endpoint>:<peer_id>:<challenge_unix_ms>` within a 5-minute clock
+over `mesh:<endpoint>:<peer_id>:<challenge_unix_ms>` within a 5-minute clock
window (`challengeMaxAge`). When a client's clock has drifted outside that
window, the control plane answers `401` (`"stale or invalid challenge timestamp"`)
with the standard HTTP `Date` header (`Access-Control-Expose-Headers: Date` on
@@ -568,11 +568,11 @@ response directly).
## 6. Summary of security invariants
-1. `sam-control-plane` is the customer-owned OIDC issuer for cloud egress,
+1. `agentmesh-control-plane` is the customer-owned OIDC issuer for cloud egress,
using a KMS/HSM-attributable ES256 signing key, short JWT lifetimes, one
audience per destination, CEL attribute conditions restricting `act.sub` to
- enrolled egress nodes, and joined audit logs (`sub` + `sam_task`).
-2. `sam-control-plane` stays off the per-request hot path: nodes cache
+ enrolled egress nodes, and joined audit logs (`sub` + `mesh_task`).
+2. `agentmesh-control-plane` stays off the per-request hot path: nodes cache
unattenuated, unsealed Delegated Session Biscuits by
`SHA-256(subject_token_type + "|" + subject_token)` and cache minted border
JWTs and upstream cloud tokens by Biscuit SHA-256 digest.
diff --git a/site/content/docs/contributing/testnets.md b/site/content/docs/contributing/testnets.md
index 5afe4919..be258162 100644
--- a/site/content/docs/contributing/testnets.md
+++ b/site/content/docs/contributing/testnets.md
@@ -9,7 +9,7 @@ aliases:
The project runs two public meshes for its own testing and for anyone who
wants to try the software without deploying anything.
-| | `bananas.sam-mesh.dev` | `hub.sam-mesh.dev` |
+| | `bananas.__PROTECT_Agent Mesh_MESH_DEV__` | `hub.__PROTECT_Agent Mesh_MESH_DEV__` |
|---|---|---|
| Built from | every push to `main` | every `v*` tag |
| Image tag | the commit SHA | the release version |
@@ -18,17 +18,17 @@ wants to try the software without deploying anything.
Both are deployed by `.github/workflows/deploy.yaml` to a GKE cluster from
the templates in `.github/k8s/`. Each testnet has a control plane Deployment
on PostgreSQL, a router StatefulSet that announces
-`/dnsaddr/bootstrap.<env>.sam-mesh.dev` (a DNS-sync CronJob keeps the record
+`/dnsaddr/bootstrap.<env>.__PROTECT_Agent Mesh_MESH_DEV__` (a DNS-sync CronJob keeps the record
current), the console, and a few canary nodes that publish demo services:
the MCP `everything` server, an OpenRouter proxy, and a vLLM instance when
-one is running. Identity comes from a Dex instance at `auth.sam-mesh.dev`
+one is running. Identity comes from a Dex instance at `auth.__PROTECT_Agent Mesh_MESH_DEV__`
that accepts Google and GitHub logins, and from the cluster's own issuer for
in-cluster workloads.
Deploys run one at a time per environment, replace pods one at a time, and
fail the workflow if the rollout does not complete. A probe CronJob enrolls
a new node every half hour and calls a tool through it. The
-[testnet-health](https://github.com/google/sam/actions/workflows/testnet-health.yaml)
+[testnet-health](https://github.com/google/agentmesh/actions/workflows/testnet-health.yaml)
badge on the repository turns red when the probe fails, and an issue
labelled `testnet-health` names the failed check.
diff --git a/site/content/docs/getting-started/_index.md b/site/content/docs/getting-started/_index.md
index fd0dc63c..d21a11e6 100644
--- a/site/content/docs/getting-started/_index.md
+++ b/site/content/docs/getting-started/_index.md
@@ -4,8 +4,8 @@ linkTitle: "Getting started"
weight: 1
---
-Every SAM mesh has a **control plane** (which enrolls members, distributes
-policy, and runs the router) and the **members** (`sam-node` or native SDK
+Every Agent Mesh has a **control plane** (which enrolls members, distributes
+policy, and runs the router) and the **members** (`agentmesh-node` or native SDK
programs) that connect to it.
To connect an agent or machine to a mesh, you need **a running control plane
@@ -17,18 +17,18 @@ Pick the option that matches what you want to do:
| Control plane option | How to run it and obtain its URL | Architecture & Ingress | Best for |
|---|---|---|---|
-| **1. Shared Public Testnet** | Already running — use **`https://bananas.sam-mesh.dev`** | Hosted shared control plane and router | Trying `sam-node` and calling your first remote tool or model in 60 seconds ([Quick start](quickstart/)). |
-| **2. Local Control Plane (`sam-one`)** | Run `sam-one --data-dir ~/sam-one --tunnel cloudflare --tunnel-install` and copy `API URL:` from the startup banner | Single binary (control plane + router + console) with SQLite and an HTTPS tunnel | Running your own private mesh from a workstation or VM in seconds ([Your own mesh](your-own-mesh/)). |
-| **3. Codespace Control Plane (`sam-one`)** | Open the repository in a [GitHub codespace](../guides/codespaces/), run `make testnet`, make port 8080 public | `sam-one` in a container on your GitHub account, published on `https://<codespace>-8080.app.github.dev` | A control plane of your own with nothing installed and no cloud account, for as long as the codespace runs ([Codespaces](../guides/codespaces/)). |
-| **4. Cloud Control Plane (`sam-one`)** | **[Cloud Run](../guides/cloud-run/)**: `gcloud run deploy sam-one --image ghcr.io/google/sam-one:latest ...`<br>**[SkyPilot](../guides/skypilot/)**: `sky launch -c sam-hub deploy/skypilot/sam-one.yaml` | Always-on `sam-one` with managed TLS/WSS ingress + PostgreSQL or persistent disk *(can also run on cloud free tiers for testing)* | Operating a dedicated production control plane in your own cloud account ([Cloud Run](../guides/cloud-run/) · [SkyPilot](../guides/skypilot/)). |
+| **1. Shared Public Testnet** | Already running — use **`https://bananas.__PROTECT_Agent Mesh_MESH_DEV__`** | Hosted shared control plane and router | Trying `agentmesh-node` and calling your first remote tool or model in 60 seconds ([Quick start](quickstart/)). |
+| **2. Local Control Plane (`agentmesh-one`)** | Run `agentmesh-one --data-dir ~/agentmesh-one --tunnel cloudflare --tunnel-install` and copy `API URL:` from the startup banner | Single binary (control plane + router + console) with SQLite and an HTTPS tunnel | Running your own private mesh from a workstation or VM in seconds ([Your own mesh](your-own-mesh/)). |
+| **3. Codespace Control Plane (`agentmesh-one`)** | Open the repository in a [GitHub codespace](../guides/codespaces/), run `make testnet`, make port 8080 public | `agentmesh-one` in a container on your GitHub account, published on `https://<codespace>-8080.app.github.dev` | A control plane of your own with nothing installed and no cloud account, for as long as the codespace runs ([Codespaces](../guides/codespaces/)). |
+| **4. Cloud Control Plane (`agentmesh-one`)** | **[Cloud Run](../guides/cloud-run/)**: `gcloud run deploy agentmesh-one --image ghcr.io/google/agentmesh-one:latest ...`<br>**[SkyPilot](../guides/skypilot/)**: `sky launch -c agentmesh-hub deploy/skypilot/agentmesh-one.yaml` | Always-on `agentmesh-one` with managed TLS/WSS ingress + PostgreSQL or persistent disk *(can also run on cloud free tiers for testing)* | Operating a dedicated production control plane in your own cloud account ([Cloud Run](../guides/cloud-run/) · [SkyPilot](../guides/skypilot/)). |
---
## Walkthroughs
-1. **[Quick start](quickstart/)**: Join the public `bananas.sam-mesh.dev`
+1. **[Quick start](quickstart/)**: Join the public `bananas.__PROTECT_Agent Mesh_MESH_DEV__`
testnet, discover remote MCP tools and inference models, and give your AI
- agent the SAM skill.
-2. **[Your own mesh](your-own-mesh/)**: Start `sam-one` in one command, grab
+ agent the Agent Mesh skill.
+2. **[Your own mesh](your-own-mesh/)**: Start `agentmesh-one` in one command, grab
the Control Plane URL from the startup banner, publish a local Ollama model,
and call it from another node.
diff --git a/site/content/docs/getting-started/quickstart.md b/site/content/docs/getting-started/quickstart.md
index 6b4284f0..d0c343c4 100644
--- a/site/content/docs/getting-started/quickstart.md
+++ b/site/content/docs/getting-started/quickstart.md
@@ -6,7 +6,7 @@ aliases:
- /docs/quickstart/
---
-This page installs `sam-node`, enrolls it in the public `bananas.sam-mesh.dev`
+This page installs `agentmesh-node`, enrolls it in the public `bananas.__PROTECT_Agent Mesh_MESH_DEV__`
testnet, and calls a tool hosted by another node. It takes a few minutes.
The testnet is a shared developer playground with no uptime commitment. See
@@ -19,18 +19,18 @@ On Linux and macOS, the install script downloads the latest release and
places the binaries in `/usr/local/bin`:
```bash
-curl -sL https://sam-mesh.dev/install.sh | bash
+curl -sL https://__PROTECT_Agent Mesh_MESH_DEV__/install.sh | bash
```
With a Go toolchain, you can build from source instead:
```bash
-go install github.com/google/sam/cmd/sam-node@latest
-go install github.com/google/sam/cmd/mcp-client@latest
+go install github.com/google/agentmesh/cmd/agentmesh-node@latest
+go install github.com/google/agentmesh/cmd/mcp-client@latest
```
-On Windows, download `sam_Windows_x86_64.zip` from the
-[releases page](https://github.com/google/sam/releases) and put `sam-node.exe`
+On Windows, download `agentmesh_Windows_x86_64.zip` from the
+[releases page](https://github.com/google/agentmesh/releases) and put `agentmesh-node.exe`
on your `PATH`.
## 2. Enroll with a control plane
@@ -38,59 +38,59 @@ on your `PATH`.
Every node joins a mesh by enrolling with a running **control plane** at its
**URL**:
-- **Shared public testnet (used below)**: `https://bananas.sam-mesh.dev` is an already-running control plane open to any developer; it authenticates in your browser.
-- **Your own control plane**: start your own control plane with `sam-one` on your workstation or in the cloud ([Your own mesh](../your-own-mesh/), [Cloud Run](../../guides/cloud-run/), or [SkyPilot](../../guides/skypilot/)) and copy the `API URL` and `sam-node join` command printed in the `sam-one` startup banner.
+- **Shared public testnet (used below)**: `https://bananas.__PROTECT_Agent Mesh_MESH_DEV__` is an already-running control plane open to any developer; it authenticates in your browser.
+- **Your own control plane**: start your own control plane with `agentmesh-one` on your workstation or in the cloud ([Your own mesh](../your-own-mesh/), [Cloud Run](../../guides/cloud-run/), or [SkyPilot](../../guides/skypilot/)) and copy the `API URL` and `agentmesh-node join` command printed in the `agentmesh-one` startup banner.
Enroll your node against the public testnet control plane:
```bash
-sam-node join https://bananas.sam-mesh.dev
+agentmesh-node join https://bananas.__PROTECT_Agent Mesh_MESH_DEV__
```
The command opens a browser for the login. If no browser is available, it
prints a URL and a code to enter on another device. (When joining your own
-`sam-one` server before setting up OIDC, pass `--bootstrap-token-path <join-token-file>`
-as shown in the `sam-one` banner instead of logging in through a browser.)
-When enrollment completes, the credential is stored under `~/.config/sam-mesh/`.
+`agentmesh-one` server before setting up OIDC, pass `--bootstrap-token-path <join-token-file>`
+as shown in the `agentmesh-one` banner instead of logging in through a browser.)
+When enrollment completes, the credential is stored under `~/.config/agentmesh/`.
You do this once per machine. Later starts reuse the stored identity and renew
it automatically.
## 3. Run the node
```bash
-sam-node run --daemonize
+agentmesh-node run --daemonize
```
The node starts in the background, connects to the mesh, and prints where its
local API is:
```text
-sam-node is running in the background.
+agentmesh-node is running in the background.
PID 48213
Endpoint http://127.0.0.1:8080/mcp
- Socket /home/you/.config/sam-mesh/sam.sock
- Token /home/you/.config/sam-mesh/api-token
- Logs /home/you/.config/sam-mesh/sam-node.log
+ Socket /home/you/.config/agentmesh/agentmesh.sock
+ Token /home/you/.config/agentmesh/api-token
+ Logs /home/you/.config/agentmesh/agentmesh-node.log
Stop kill 48213
```
The local API is served on two listeners. The TCP port requires the token
from the file shown. The Unix socket requires no token, because only your
user can open it. `--daemonize` generates the token on first use. To choose
-the token yourself, set `SAM_API_TOKEN` or pass `--api-token-path`. Run the
+the token yourself, set `AGENTMESH_API_TOKEN` or pass `--api-token-path`. Run the
command without `--daemonize` to keep the node in the foreground.
-You can run `sam-node run --daemonize` again at any time. If a node is
+You can run `agentmesh-node run --daemonize` again at any time. If a node is
already running, the command does not start a second one. It prints the
address of the running node and exits.
## 4. Call a tool on the mesh
The node's local API is an MCP server. `mcp-client` is installed together
-with `sam-node` and is the quickest way to talk to it. Export the token once:
+with `agentmesh-node` and is the quickest way to talk to it. Export the token once:
```bash
-export TOKEN=$(cat ~/.config/sam-mesh/api-token)
+export TOKEN=$(cat ~/.config/agentmesh/api-token)
```
List the tools the node itself offers:
@@ -131,7 +131,7 @@ services, and the same node offers their models on an OpenAI-compatible
endpoint. The Unix socket needs no token:
```bash
-curl -s --unix-socket ~/.config/sam-mesh/sam.sock http://localhost/v1/models
+curl -s --unix-socket ~/.config/agentmesh/agentmesh.sock http://localhost/v1/models
```
A completion request to `/v1/chat/completions` for one of those models is
@@ -141,23 +141,23 @@ model from your laptop and shows where each type fits.
## 5. Give your agent the skill
-The MCP tools tell an agent what it can do. The SAM skill tells it when and
+The MCP tools tell an agent what it can do. The Agent Mesh skill tells it when and
how to use them: start a node, discover services, describe a tool before
calling it, reach a mesh inference model. Install it once:
```bash
-sam-node skill install
+agentmesh-node skill install
```
This writes `SKILL.md` into the directories that the common agent harnesses
-read: `~/.claude/skills/sam-mesh/` for Claude Code and Claude Desktop, and
-`~/.gemini/config/skills/sam-mesh/` for Antigravity. Then register the node's
+read: `~/.claude/skills/agentmesh/` for Claude Code and Claude Desktop, and
+`~/.gemini/config/skills/agentmesh/` for Antigravity. Then register the node's
MCP endpoint with your agent. [Connecting agents](../../guides/connecting-agents/)
has the configuration for each client.
With the skill installed, you can ask an agent to "connect to the mesh" and
it brings a node online by itself. The one step it cannot do for you is the
-`sam-node join` login, which requires a person.
+`agentmesh-node join` login, which requires a person.
## Starting over
@@ -165,14 +165,14 @@ The node reuses whatever is in its data directory. To forget the mesh
identity but keep the node's key:
```bash
-sam-node reset
+agentmesh-node reset
```
To delete everything the node stores, including its key (the node gets a new
peer ID and must enroll again):
```bash
-sam-node reset --all
+agentmesh-node reset --all
```
Both commands refuse to run while a node is up. Stop the node first with the
diff --git a/site/content/docs/getting-started/your-own-mesh.md b/site/content/docs/getting-started/your-own-mesh.md
index cfeea5c9..62b4892f 100644
--- a/site/content/docs/getting-started/your-own-mesh.md
+++ b/site/content/docs/getting-started/your-own-mesh.md
@@ -7,65 +7,65 @@ aliases:
---
This page gets a mesh of your own running in a few minutes: a control plane,
-a router and a web console on your laptop, in one process called `sam-one`.
+a router and a web console on your laptop, in one process called `agentmesh-one`.
You then put a member on it, open the console, and see a model that runs on
-your machine answer a request from another member. `sam-one` runs the same
+your machine answer a request from another member. `agentmesh-one` runs the same
code as a Kubernetes deployment, so what you learn here applies there too.
-You need the `sam-one` and `sam-node` binaries. The
+You need the `agentmesh-one` and `agentmesh-node` binaries. The
[install script](../quickstart/#1-install) provides both.
## 1. Start the control plane and obtain its URL
-Every SAM mesh needs a running control plane and router. `sam-one` packages the
+Every Agent Mesh needs a running control plane and router. `agentmesh-one` packages the
control plane, the libp2p WebSocket router, and the web console into a single
-binary on one port. When `sam-one` starts—on your machine, in a container, or
+binary on one port. When `agentmesh-one` starts—on your machine, in a container, or
on a cloud VM—it brings up the control plane and prints a startup banner
-containing its **URL (`API URL`)**, its tokens, and the `sam-node join` command
+containing its **URL (`API URL`)**, its tokens, and the `agentmesh-node join` command
for nodes to connect to it.
-### Ways to run `sam-one` and obtain its URL
+### Ways to run `agentmesh-one` and obtain its URL
-| Where your nodes run | How to run `sam-one` | Control plane URL you get |
+| Where your nodes run | How to run `agentmesh-one` | Control plane URL you get |
|---|---|---|
-| **Across machines, VMs, or phones** *(Instant HTTPS tunnel)* | `sam-one --data-dir ~/sam-one --tunnel cloudflare --tunnel-install` | Public `https://<name>.trycloudflare.com` URL + terminal QR code |
-| **Same machine only** *(Local development)* | `sam-one --data-dir ~/sam-one` | Local `http://127.0.0.1:<port>` URL |
-| **Custom domain behind NAT/firewall** | `sam-one --data-dir ~/sam-one --tunnel cloudflare --tunnel-token-path ~/token --external-url https://mesh.example.com` | Permanent `https://mesh.example.com` URL (no inbound firewall ports) |
+| **Across machines, VMs, or phones** *(Instant HTTPS tunnel)* | `agentmesh-one --data-dir ~/agentmesh-one --tunnel cloudflare --tunnel-install` | Public `https://<name>.trycloudflare.com` URL + terminal QR code |
+| **Same machine only** *(Local development)* | `agentmesh-one --data-dir ~/agentmesh-one` | Local `http://127.0.0.1:<port>` URL |
+| **Custom domain behind NAT/firewall** | `agentmesh-one --data-dir ~/agentmesh-one --tunnel cloudflare --tunnel-token-path ~/token --external-url https://mesh.example.com` | Permanent `https://mesh.example.com` URL (no inbound firewall ports) |
| **A GitHub codespace, nothing installed** | Open the repository in a codespace and run `make testnet` ([Codespaces](../../guides/codespaces/)) | Public `https://<codespace>-8080.app.github.dev` URL once you make the port public |
| **Always-on Cloud Deployment** *(Cloud Run, SkyPilot)* | See [Cloud Run](../../guides/cloud-run/) (`gcloud run deploy`) or [SkyPilot](../../guides/skypilot/) (`sky launch`) | `https://<svc>.a.run.app` or `https://mesh.example.com` |
-For example, starting `sam-one` locally:
+For example, starting `agentmesh-one` locally:
```bash
-sam-one --data-dir ~/sam-one
+agentmesh-one --data-dir ~/agentmesh-one
```
`--data-dir` holds the database, the router's key and the generated tokens.
-Delete it and you get a new mesh. After a moment `sam-one` prints a banner:
+Delete it and you get a new mesh. After a moment `agentmesh-one` prints a banner:
```text
══════════════════════════════════════════════════════════════════
-SAM standalone mesh is ready!
+Agent Mesh standalone mesh is ready!
API URL: http://0.0.0.0:33775
Web Console: http://0.0.0.0:33775/console
Router Peer: 12D3KooWBzUDQCkZhz2rWrYBhpjcCH8VnrRNcwCW6DoF36iADYrY
-Admin Token: sam_adm_…
+Admin Token: mesh_adm_…
Join Token: mesh_tok_…
To enroll a node:
- sam-node join http://0.0.0.0:33775 --bootstrap-token-path /home/you/sam-one/join-token
+ agentmesh-node join http://0.0.0.0:33775 --bootstrap-token-path /home/you/agentmesh-one/join-token
══════════════════════════════════════════════════════════════════
```
Two things in the banner matter for the rest of this page:
-- The **API URL** is the address of the mesh. `sam-one` picked a free port;
+- The **API URL** is the address of the mesh. `agentmesh-one` picked a free port;
pass `--port 8080` for a fixed one.
- The **join token** admits new members. It is also written to
- `~/sam-one/join-token`, and the steps below read it from there. The
+ `~/agentmesh-one/join-token`, and the steps below read it from there. The
**admin token** opens the console and the admin API; it is in
- `~/sam-one/admin-token`.
+ `~/agentmesh-one/admin-token`.
Keep this terminal open. Everything else happens in a second one, with the
URL from your banner:
@@ -74,7 +74,7 @@ URL from your banner:
export URL=http://127.0.0.1:33775
```
-On first boot `sam-one` seeds an open development policy and logs a warning:
+On first boot `agentmesh-one` seeds an open development policy and logs a warning:
any enrolled member may publish any service and call any service. That is
right for a laptop and wrong for anything shared; [step 5](#5-before-you-share-it)
replaces it.
@@ -83,18 +83,18 @@ replaces it.
Skip this if everything stays on your laptop. A member on another machine
needs an `https` URL, because the control plane is the member's trust root
-and SAM refuses to fetch it over plaintext from a remote address.
+and Agent Mesh refuses to fetch it over plaintext from a remote address.
On a laptop behind NAT, the quickest way to an `https` URL is a temporary
tunnel:
```bash
-sam-one --data-dir ~/sam-one --tunnel cloudflare
+agentmesh-one --data-dir ~/agentmesh-one --tunnel cloudflare
```
This publishes the port on a random `trycloudflare.com` hostname, with no
account needed, and prints that URL in the banner in place of the local one.
-If `cloudflared` is not installed, `sam-one` offers to download a pinned,
+If `cloudflared` is not installed, `agentmesh-one` offers to download a pinned,
checksum-verified release into the data directory; `--tunnel-install`
accepts without asking. Set `URL` to the tunnel URL, copy the join token
file to the other machine, and the commands below work there unchanged.
@@ -103,8 +103,8 @@ With a real hostname and a reverse proxy in front, pass
`--external-url https://mesh.example.com` instead. The
[Cloud Run guide](../../guides/cloud-run/) shows a hosted variant.
-With `--tunnel` or any other `https` URL, `sam-one` also prints a QR code
-that enrolls a phone running the SAM Connect app, which is in
+With `--tunnel` or any other `https` URL, `agentmesh-one` also prints a QR code
+that enrolls a phone running the Agent Mesh Connect app, which is in
[preview](../../preview/mobile/).
<!-- TODO(screenshot): the banner with a tunnel URL and the QR code. -->
@@ -112,9 +112,9 @@ that enrolls a phone running the SAM Connect app, which is in
## 2. Put a member on it
A member is anything that holds an identity the control plane issued and
-speaks to the mesh through the router: a `sam-node` beside an application, a
+speaks to the mesh through the router: a `agentmesh-node` beside an application, a
program written with a [native SDK](../../guides/native-sdks/), or a phone.
-This page uses `sam-node` because it needs no code.
+This page uses `agentmesh-node` because it needs no code.
Pull a small model with [Ollama](https://ollama.com) (any OpenAI-compatible
server works in its place) and declare it as an `inference` service. The
@@ -132,8 +132,8 @@ services:
target_url: "http://127.0.0.1:11434"
EOF
-sam-node run --control-plane $URL \
- --bootstrap-token-path ~/sam-one/join-token \
+agentmesh-node run --control-plane $URL \
+ --bootstrap-token-path ~/agentmesh-one/join-token \
--config ~/node-a.yaml \
--data-dir ~/node-a --bind-addr= --allow-loopback --listen /ip4/127.0.0.1/tcp/0
```
@@ -142,7 +142,7 @@ The node enrolls with the join token, connects to the router and prints its
peer ID:
```text
-SAM Node Online.
+Agent Mesh Node Online.
PeerID: 12D3KooWSCnbUoZ8Jv3EKGv17LqEWtnTMfZ3XYJUg2WTm5Gz2hUK
```
@@ -167,23 +167,23 @@ plain web server declared under any of these types is never advertised.
## 3. See it in the console
Open `http://127.0.0.1:33775/console` (the **Web Console** line of your
-banner) and paste the admin token from `~/sam-one/admin-token`. The console
+banner) and paste the admin token from `~/agentmesh-one/admin-token`. The console
shows the enrolled members, the router, the services each member reports,
the bootstrap tokens with their remaining uses, and the mesh policy, which
you can edit in place.
<!-- TODO(screenshot): the console's nodes view with node A and its laptop-llm service. -->
-The same operations are available from the command line. `sam-one` is also
+The same operations are available from the command line. `agentmesh-one` is also
an admin client for a running server. It reads the admin token from the data
-directory, from `SAM_ADMIN_TOKEN` or from `--admin-token-path`, never from a
+directory, from `AGENTMESH_ADMIN_TOKEN` or from `--admin-token-path`, never from a
flag value:
```bash
-sam-one token list --server $URL --data-dir ~/sam-one
-sam-one token create --server $URL --data-dir ~/sam-one --description "node c" --max-usages 1
-sam-one token revoke <token-id> --server $URL --data-dir ~/sam-one
-sam-one admin ban <peer-id> --server $URL --data-dir ~/sam-one
+agentmesh-one token list --server $URL --data-dir ~/agentmesh-one
+agentmesh-one token create --server $URL --data-dir ~/agentmesh-one --description "node c" --max-usages 1
+agentmesh-one token revoke <token-id> --server $URL --data-dir ~/agentmesh-one
+agentmesh-one admin ban <peer-id> --server $URL --data-dir ~/agentmesh-one
```
## 4. Call the model from a second member
@@ -193,8 +193,8 @@ In a third terminal, start a node with no services of its own:
```bash
export URL=http://127.0.0.1:33775
-sam-node run --control-plane $URL \
- --bootstrap-token-path ~/sam-one/join-token \
+agentmesh-node run --control-plane $URL \
+ --bootstrap-token-path ~/agentmesh-one/join-token \
--data-dir ~/node-b --bind-addr= --allow-loopback --listen /ip4/127.0.0.1/tcp/0
```
@@ -204,7 +204,7 @@ completion request is routed to a provider of the model it names. Ask node
B:
```bash
-SOCK=~/node-b/sam.sock
+SOCK=~/node-b/agentmesh.sock
curl -s --unix-socket $SOCK http://localhost/v1/models
@@ -221,7 +221,7 @@ a moment to arrive.
The request went from B's socket to B, then over an authenticated connection
to A, through A's policy check, to Ollama, and back. Both nodes verified the
other's credential before any data moved. If A and B cannot reach each other
-directly, the connection is relayed through the router inside `sam-one`,
+directly, the connection is relayed through the router inside `agentmesh-one`,
which carries ciphertext and learns only that the two are talking.
The socket needs no token: only your user can open it. To point an OpenAI
@@ -235,20 +235,20 @@ SDK at the mesh instead, give node B a TCP port with
## 5. Before you share it
- **Policy**: replace the open development policy. Write a
- [mesh policy](../../reference/policy/) file and start `sam-one` with
+ [mesh policy](../../reference/policy/) file and start `agentmesh-one` with
`--policy-file` on a fresh data directory, or edit the policy in the
console. Once the database has a policy, the database is the source of
truth.
- **Enrollment**: run with `--no-join-token` so members can only enroll with
- tokens you mint (`sam-one token create`, single-use by default), or give
+ tokens you mint (`agentmesh-one token create`, single-use by default), or give
the mesh an identity provider with `--issuer` and let people log in.
- **State**: keep the data directory on durable storage, or point
`--db-driver postgres --db-dsn ...` at a database.
-- **Tokens in logs**: read the admin token from `SAM_ADMIN_TOKEN` or
+- **Tokens in logs**: read the admin token from `AGENTMESH_ADMIN_TOKEN` or
`--admin-token-path` instead of the banner, and pass `--enroll-qr=false`
in non-interactive environments.
-The [sam-one reference](../../reference/sam-one/) lists every flag.
+The [agentmesh-one reference](../../reference/agentmesh-one/) lists every flag.
## Where next
diff --git a/site/content/docs/guides/cloud-run.md b/site/content/docs/guides/cloud-run.md
index 0071c3c9..3b47c99f 100644
--- a/site/content/docs/guides/cloud-run.md
+++ b/site/content/docs/guides/cloud-run.md
@@ -6,45 +6,45 @@ aliases:
- /docs/user/cloud-run-deployment/
---
-`sam-one` serves its HTTP API, the web console, and the router's WebSocket
+`agentmesh-one` serves its HTTP API, the web console, and the router's WebSocket
transport on a single port (`8080`), and ships as a pre-built container image
-(`ghcr.io/google/sam-one:latest`). Because `sam-one` automatically infers its
+(`ghcr.io/google/agentmesh-one:latest`). Because `agentmesh-one` automatically infers its
public `wss://` router address from Cloud Run's `Host` and `X-Forwarded-Proto`
headers on `/info` and `/enroll` and derives a deterministic router `PeerID`
-from `SAM_ADMIN_TOKEN`, you can deploy a standalone control plane and router to
+from `AGENTMESH_ADMIN_TOKEN`, you can deploy a standalone control plane and router to
Google Cloud Run in a single command.
*(Note: For multi-cloud VM deployments on GCP, AWS, Azure, OCI, or Kubernetes,
see the [SkyPilot guide](../skypilot/).)*
-## 1. Deploy `sam-one` to Cloud Run
+## 1. Deploy `agentmesh-one` to Cloud Run
```bash
PROJECT=my-gcp-project
REGION=us-central1
JOIN_TOKEN="mesh_tok_$(openssl rand -hex 16)"
-ADMIN_TOKEN="sam_adm_$(openssl rand -hex 16)"
+ADMIN_TOKEN="mesh_adm_$(openssl rand -hex 16)"
-gcloud run deploy sam-one \
+gcloud run deploy agentmesh-one \
--project "$PROJECT" --region "$REGION" \
- --image ghcr.io/google/sam-one:latest \
+ --image ghcr.io/google/agentmesh-one:latest \
--allow-unauthenticated \
--min-instances 1 --max-instances 1 \
--port 8080 \
--no-cpu-throttling \
--timeout 3600 \
- --set-env-vars "SAM_TOKEN=${JOIN_TOKEN},SAM_ADMIN_TOKEN=${ADMIN_TOKEN}"
+ --set-env-vars "AGENTMESH_TOKEN=${JOIN_TOKEN},AGENTMESH_ADMIN_TOKEN=${ADMIN_TOKEN}"
```
### Production persistence with PostgreSQL
By default, Cloud Run's container filesystem is in-memory. When an instance
-restarts, `sam-one` preserves its router `PeerID` (derived from
-`SAM_ADMIN_TOKEN`) and pinned tokens (`SAM_TOKEN`, `SAM_ADMIN_TOKEN`), and
+restarts, `agentmesh-one` preserves its router `PeerID` (derived from
+`AGENTMESH_ADMIN_TOKEN`) and pinned tokens (`AGENTMESH_TOKEN`, `AGENTMESH_ADMIN_TOKEN`), and
active nodes re-enroll automatically.
For full state durability across container revisions and restarts (preserving
-enrolled peers, minted tokens, and console policy edits), connect `sam-one` to
+enrolled peers, minted tokens, and console policy edits), connect `agentmesh-one` to
a PostgreSQL database (such as Cloud SQL, AlloyDB, or a serverless Postgres
instance for testing):
@@ -70,14 +70,14 @@ Why each Cloud Run flag matters:
`gcloud run deploy` prints your `Service URL` when deployment completes:
```text
-Service [sam-one] revision [sam-one-00001-xxx] has been deployed and is serving 100 percent of traffic.
-Service URL: https://sam-one-628944397724.us-central1.run.app
+Service [agentmesh-one] revision [agentmesh-one-00001-xxx] has been deployed and is serving 100 percent of traffic.
+Service URL: https://agentmesh-one-628944397724.us-central1.run.app
```
You can also query it at any time:
```bash
-URL=$(gcloud run services describe sam-one --project "$PROJECT" --region "$REGION" \
+URL=$(gcloud run services describe agentmesh-one --project "$PROJECT" --region "$REGION" \
--format='value(status.url)')
curl -s "$URL/readyz" # {"status":"ready"}
```
@@ -87,7 +87,7 @@ curl -s "$URL/readyz" # {"status":"ready"}
Once your control plane URL (`$URL`) is ready, verify end-to-end service
discovery, Biscuit authorization, and WebSocket relay routing across two nodes:
-1. **Save the bootstrap token** (or mint one with `sam-one token create`):
+1. **Save the bootstrap token** (or mint one with `agentmesh-one token create`):
```bash
echo -n "$JOIN_TOKEN" > join-token
```
@@ -101,31 +101,31 @@ discovery, Biscuit authorization, and WebSocket relay routing across two nodes:
target_url: "http://127.0.0.1:11434"
EOF
- sam-node run --control-plane "$URL" \
+ agentmesh-node run --control-plane "$URL" \
--bootstrap-token-path join-token \
--config node-a.yaml --data-dir ~/node-a --bind-addr=
```
3. **Start Node B and call Node A's service through the mesh**:
```bash
- sam-node run --control-plane "$URL" \
+ agentmesh-node run --control-plane "$URL" \
--bootstrap-token-path join-token \
--data-dir ~/node-b --bind-addr=
- curl -s --unix-socket ~/node-b/sam.sock http://localhost/v1/models
- curl -s --unix-socket ~/node-b/sam.sock http://localhost/v1/chat/completions \
+ curl -s --unix-socket ~/node-b/agentmesh.sock http://localhost/v1/models
+ curl -s --unix-socket ~/node-b/agentmesh.sock http://localhost/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model":"gemma3:1b","messages":[{"role":"user","content":"Ping across the mesh"}]}'
```
## 4. Administer from your workstation
-`sam-one` is also the admin client. With `SAM_ADMIN_TOKEN` exported:
+`agentmesh-one` is also the admin client. With `AGENTMESH_ADMIN_TOKEN` exported:
```bash
-export SAM_ADMIN_TOKEN="$ADMIN_TOKEN"
-sam-one token create --server "$URL" --role mesh:role:node --max-usages 1
-sam-one token qr --server "$URL"
-sam-one token list --server "$URL"
-sam-one token revoke <token-id> --server "$URL"
-sam-one admin ban <peer-id> --server "$URL"
+export AGENTMESH_ADMIN_TOKEN="$ADMIN_TOKEN"
+agentmesh-one token create --server "$URL" --role mesh:role:node --max-usages 1
+agentmesh-one token qr --server "$URL"
+agentmesh-one token list --server "$URL"
+agentmesh-one token revoke <token-id> --server "$URL"
+agentmesh-one admin ban <peer-id> --server "$URL"
```
diff --git a/site/content/docs/guides/codespaces.md b/site/content/docs/guides/codespaces.md
index cccc8b70..7eb47737 100644
--- a/site/content/docs/guides/codespaces.md
+++ b/site/content/docs/guides/codespaces.md
@@ -7,10 +7,10 @@ weight: 5
A codespace is a container that GitHub runs for you, with a terminal, an
editor and an `https` URL for every port you forward. Started from this
repository, it gives you a control plane of your own with nothing installed
-on your machine and no cloud account. `sam-one` runs inside it, your laptop
+on your machine and no cloud account. `agentmesh-one` runs inside it, your laptop
and your phone enroll over the public URL, and your GitHub account pays with
its free Codespaces quota (120 core-hours a month on a Free plan; a 2-core
-machine is enough). The same setup lets you develop SAM, or a program that
+machine is enough). The same setup lets you develop Agent Mesh, or a program that
uses one of its SDKs, against a mesh that external clients can reach.
## 1. Open a codespace
@@ -20,11 +20,11 @@ badge, or from **Code → Codespaces → New with options** on GitHub:
| Configuration | Contents | For |
|---|---|---|
-| **testnet** (default badge in the README) | The released `sam-one` and `sam-node` binaries, copied from the `stable` images that also run `hub.sam-mesh.dev`. No toolchain. | Trying SAM, enrolling your devices. |
-| **testnet-latest** | The same, from the `latest` images built from `main`, which also run `bananas.sam-mesh.dev`. | Trying what is not released yet. |
+| **testnet** (default badge in the README) | The released `agentmesh-one` and `agentmesh-node` binaries, copied from the `stable` images that also run `hub.__PROTECT_Agent Mesh_MESH_DEV__`. No toolchain. | Trying Agent Mesh, enrolling your devices. |
+| **testnet-latest** | The same, from the `latest` images built from `main`, which also run `bananas.__PROTECT_Agent Mesh_MESH_DEV__`. | Trying what is not released yet. |
| **develop** (`.devcontainer/devcontainer.json`) | Go, Node, Python and Docker. `make build` runs when the codespace is created, so `./bin` holds the binaries of the branch you opened. | Contributing, or developing an SDK program against your own branch. |
-[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/google/sam?quickstart=1&devcontainer_path=.devcontainer%2Ftestnet%2Fdevcontainer.json)
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/google/agentmesh?quickstart=1&devcontainer_path=.devcontainer%2Ftestnet%2Fdevcontainer.json)
The codespace opens with this page in the editor and a terminal at the
repository root.
@@ -37,68 +37,68 @@ make testnet
The target runs one command, which is the same command you would run
anywhere else (the codespace checks the repository out under
-`/workspaces/sam`):
+`/workspaces/agentmesh`):
```bash
-sam-one --data-dir /workspaces/sam/.sam-one --port 8080 --tunnel codespaces
+agentmesh-one --data-dir /workspaces/agentmesh/.agentmesh-one --port 8080 --tunnel codespaces
```
-`--tunnel codespaces` tells `sam-one` that GitHub already forwards the port:
+`--tunnel codespaces` tells `agentmesh-one` that GitHub already forwards the port:
it reads the codespace name and the forwarding domain from the environment,
advertises `https://<codespace>-8080.app.github.dev` as the mesh URL, and
starts nothing. After a moment the banner appears:
```text
══════════════════════════════════════════════════════════════════
-SAM standalone mesh is ready!
+Agent Mesh standalone mesh is ready!
-API URL: https://octocat-sam-abc123-8080.app.github.dev
-Tunnel: https://octocat-sam-abc123-8080.app.github.dev -> http://0.0.0.0:8080
-Web Console: https://octocat-sam-abc123-8080.app.github.dev/console
+API URL: https://octocat-agentmesh-abc123-8080.app.github.dev
+Tunnel: https://octocat-agentmesh-abc123-8080.app.github.dev -> http://0.0.0.0:8080
+Web Console: https://octocat-agentmesh-abc123-8080.app.github.dev/console
Router Peer: 12D3KooWBzUDQCkZhz2rWrYBhpjcCH8VnrRNcwCW6DoF36iADYrY
-Admin Token: sam_adm_…
+Admin Token: mesh_adm_…
Join Token: mesh_tok_…
To enroll a node:
- sam-node join https://octocat-sam-abc123-8080.app.github.dev --bootstrap-token-path /workspaces/sam/.sam-one/join-token
+ agentmesh-node join https://octocat-agentmesh-abc123-8080.app.github.dev --bootstrap-token-path /workspaces/agentmesh/.agentmesh-one/join-token
══════════════════════════════════════════════════════════════════
```
A QR code for the [mobile app](../../preview/mobile/) follows the banner.
-Any `sam-one` flag passes through `ARGS`. To let people log in with an
+Any `agentmesh-one` flag passes through `ARGS`. To let people log in with an
identity provider instead of the join token, for example:
```bash
make testnet ARGS="--issuer https://accounts.google.com --allowed-audiences <client-id>"
```
-The [sam-one reference](../../reference/sam-one/) lists every flag. Outside
-a codespace, `make testnet` starts a plain local `sam-one` on port 8080.
+The [agentmesh-one reference](../../reference/agentmesh-one/) lists every flag. Outside
+a codespace, `make testnet` starts a plain local `agentmesh-one` on port 8080.
## 3. Make the port public
Every forwarded port starts **private**: GitHub's proxy lets your own
browser through and answers everyone else with its login page. Open the
**Web Console** URL from the banner in your browser now and it works. A
-`sam-node` on your laptop or the app on your phone cannot log in to GitHub,
-so `sam-one` tells you in its log, after a few seconds:
+`agentmesh-node` on your laptop or the app on your phone cannot log in to GitHub,
+so `agentmesh-one` tells you in its log, after a few seconds:
```text
-WARN tunnel GitHub answers for https://octocat-sam-abc123-8080.app.github.dev: port 8080 is private, so only your own browser can open it. To let devices enroll, make it public: PORTS tab -> right-click 8080 -> Port Visibility -> Public (or `gh codespace ports visibility 8080:public -c octocat-sam-abc123`)
+WARN tunnel GitHub answers for https://octocat-agentmesh-abc123-8080.app.github.dev: port 8080 is private, so only your own browser can open it. To let devices enroll, make it public: PORTS tab -> right-click 8080 -> Port Visibility -> Public (or `gh codespace ports visibility 8080:public -c octocat-agentmesh-abc123`)
```
Do that once, in the **PORTS** tab next to the terminal, or from your own
machine with the `gh` command from the message (the codespace image does
-not include `gh`). `sam-one` keeps checking and confirms within a few
+not include `gh`). `agentmesh-one` keeps checking and confirms within a few
seconds:
```text
-INFO tunnel https://octocat-sam-abc123-8080.app.github.dev answers from the internet; devices can enroll
+INFO tunnel https://octocat-agentmesh-abc123-8080.app.github.dev answers from the internet; devices can enroll
```
A public port is reachable by anyone who has the URL, with the same exposure
-as a `sam-one` on Cloud Run: `/healthz`, `/info` and the console login page
+as a `agentmesh-one` on Cloud Run: `/healthz`, `/info` and the console login page
answer without credentials, enrollment needs the join token or a token you
minted, the console and the admin API need the admin token, and every
router connection needs a credential the control plane issued. The first
@@ -107,34 +107,34 @@ before you share the URL, as described in
[Your own mesh](../../getting-started/your-own-mesh/#5-before-you-share-it).
If your organization forbids public ports, keep the port private and let
-`sam-one` publish itself through a Cloudflare quick tunnel instead:
+`agentmesh-one` publish itself through a Cloudflare quick tunnel instead:
`make testnet ARGS="--tunnel cloudflare --tunnel-install"`.
## 4. Enroll your devices
-On your laptop, install `sam-node` ([quick start](../../getting-started/quickstart/#1-install)),
+On your laptop, install `agentmesh-node` ([quick start](../../getting-started/quickstart/#1-install)),
save the join token from the banner to a file, and join:
```bash
-URL=https://octocat-sam-abc123-8080.app.github.dev
+URL=https://octocat-agentmesh-abc123-8080.app.github.dev
echo -n 'mesh_tok_…' > join-token
-sam-node join "$URL" --bootstrap-token-path join-token
-sam-node run --daemonize
+agentmesh-node join "$URL" --bootstrap-token-path join-token
+agentmesh-node run --daemonize
```
The node appears in the console under **Nodes**. From here the
[Your own mesh](../../getting-started/your-own-mesh/#2-put-a-member-on-it)
walkthrough applies unchanged: publish a model or an MCP server from one
device and call it from another. The second device can be the codespace
-itself, where `sam-node` is installed too. It reaches `sam-one` over
+itself, where `agentmesh-node` is installed too. It reaches `agentmesh-one` over
loopback, which `--allow-loopback` permits, and `--bind-addr=` keeps its
-local API on a Unix socket so it does not compete with `sam-one` for port
+local API on a Unix socket so it does not compete with `agentmesh-one` for port
8080:
```bash
-sam-node run --control-plane http://127.0.0.1:8080 \
- --bootstrap-token-path .sam-one/join-token \
+agentmesh-node run --control-plane http://127.0.0.1:8080 \
+ --bootstrap-token-path .agentmesh-one/join-token \
--data-dir ~/node-a --bind-addr= --allow-loopback
```
@@ -142,7 +142,7 @@ Scan the QR code under the banner with the mobile app to enroll a phone.
## 5. Develop against it
-In the **develop** configuration, `make testnet` runs `./bin/sam-one`, the
+In the **develop** configuration, `make testnet` runs `./bin/agentmesh-one`, the
binary built from your branch. Edit, `make build`, stop the mesh with
`Ctrl-C` and start it again; the data directory keeps the identity and the
tokens, and enrolled devices reconnect on their own as long as the mesh is
@@ -158,25 +158,25 @@ CI.
- **The URL.** The codespace name is fixed for the codespace's lifetime, so
the URL survives stop and start.
-- **The mesh state.** `.sam-one` in the checkout holds the database (members,
+- **The mesh state.** `.agentmesh-one` in the checkout holds the database (members,
policy, bootstrap tokens), the router key and the two tokens. Git ignores
it, and it survives stops, starts and container rebuilds, so the router
keeps its peer ID and devices keep their identity: nothing enrolls twice.
- **The idle stop.** A codespace stops after 30 minutes without activity by
default; you can raise that to four hours in your GitHub settings. While it
- is stopped nothing answers at the URL. A `sam-node` that finds no router
+ is stopped nothing answers at the URL. A `agentmesh-node` that finds no router
for about three minutes exits on purpose, so after a longer stop you start
- your nodes again (`sam-node run --daemonize`; they need no new
+ your nodes again (`agentmesh-node run --daemonize`; they need no new
enrollment) or run them under a service manager that restarts them.
Resume the codespace from [github.com/codespaces](https://github.com/codespaces),
the README badge, or by connecting to it with `gh codespace code`, and run
`make testnet` again.
-- **Port visibility.** A restart makes the port private again. `sam-one`
+- **Port visibility.** A restart makes the port private again. `agentmesh-one`
says so in its log, and you set it to public once more.
- **Deletion.** A stopped codespace is deleted after 30 days by default. The
mesh is gone with it, and devices enroll elsewhere.
- **One mesh per codespace.** The router's relay and discovery state live in
- the single `sam-one` process. A second codespace is a second mesh.
+ the single `agentmesh-one` process. A second codespace is a second mesh.
When you want the mesh to stay up, take the same command and its flags to
[Cloud Run](../cloud-run/), [SkyPilot](../skypilot/) or
diff --git a/site/content/docs/guides/connecting-agents.md b/site/content/docs/guides/connecting-agents.md
index 3f84b3f3..50928def 100644
--- a/site/content/docs/guides/connecting-agents.md
+++ b/site/content/docs/guides/connecting-agents.md
@@ -12,26 +12,26 @@ aliases:
- /docs/integrations/vscode-copilot/
---
-An agent uses the mesh through the `sam-node` that runs on its own machine.
+An agent uses the mesh through the `agentmesh-node` that runs on its own machine.
The node is an MCP server, so you can point any MCP client at it. This guide
gives the configuration for the common clients and explains what the agent
gets.
## What every client needs
-Three values, all printed by `sam-node run --daemonize`:
+Three values, all printed by `agentmesh-node run --daemonize`:
- **The endpoint**: `http://127.0.0.1:8080/mcp` (Streamable HTTP).
-- **The token**: the contents of `~/.config/sam-mesh/api-token`, or the
- `SAM_API_TOKEN` you started the node with. It goes in the header
+- **The token**: the contents of `~/.config/agentmesh/api-token`, or the
+ `AGENTMESH_API_TOKEN` you started the node with. It goes in the header
`X-Mesh-Authentication: Bearer <token>`.
-- **The socket**: `~/.config/sam-mesh/sam.sock`. Anything the agent runs in a
+- **The socket**: `~/.config/agentmesh/agentmesh.sock`. Anything the agent runs in a
shell can use the socket without a token. This is the easier way to reach
the node's `/v1` inference endpoint from scripts.
The node must be running before the client starts. MCP clients start and
-manage stdio servers themselves, but `sam-node` is an HTTP server that they
-connect to. You can run `sam-node run --daemonize` as often as you like, so it
+manage stdio servers themselves, but `agentmesh-node` is an HTTP server that they
+connect to. You can run `agentmesh-node run --daemonize` as often as you like, so it
is safe to put it in a shell profile or to let the agent run it.
## What the agent gets
@@ -69,24 +69,24 @@ come back with an `error` field next to the good ones.
## The skill
Tools tell an agent what it can do. A skill tells it when and how to use
-them. `sam-node` ships one:
+them. `agentmesh-node` ships one:
```bash
-sam-node skill install # ~/.claude/skills/sam-mesh/ and ~/.gemini/config/skills/sam-mesh/
-sam-node skill install --project # ./.claude/skills/ and ./.agents/skills/ in the current repository
-sam-node skill install --dir DIR # anywhere else
-sam-node skill list # where it is installed and whether it is current
-sam-node skill show # print it, for a harness with its own layout
+agentmesh-node skill install # ~/.claude/skills/agentmesh/ and ~/.gemini/config/skills/agentmesh/
+agentmesh-node skill install --project # ./.claude/skills/ and ./.agents/skills/ in the current repository
+agentmesh-node skill install --dir DIR # anywhere else
+agentmesh-node skill list # where it is installed and whether it is current
+agentmesh-node skill show # print it, for a harness with its own layout
```
-Reinstall the skill after you upgrade `sam-node`. `list` says `outdated` when
+Reinstall the skill after you upgrade `agentmesh-node`. `list` says `outdated` when
the installed copy differs from the one in the binary. Restart the client
afterwards so that it loads both the skill and the tools.
## Claude Code
```bash
-claude mcp add --transport http sam-mesh http://127.0.0.1:8080/mcp \
+claude mcp add --transport http agentmesh http://127.0.0.1:8080/mcp \
--header "X-Mesh-Authentication: Bearer <token>"
```
@@ -97,7 +97,7 @@ The equivalent file entry, where `type` is required:
```json
{
"mcpServers": {
- "sam-mesh": {
+ "agentmesh": {
"type": "http",
"url": "http://127.0.0.1:8080/mcp",
"headers": { "X-Mesh-Authentication": "Bearer <token>" }
@@ -108,7 +108,7 @@ The equivalent file entry, where `type` is required:
`claude mcp list` should report the server as connected. Tools load at
session start. `/mcp` inside a session shows them, and `/skills` shows
-`sam-mesh` once the skill is installed.
+`agentmesh-p2p` once the skill is installed.
## Google Antigravity
@@ -117,7 +117,7 @@ Add to `~/.gemini/config/mcp_config.json`:
```json
{
"mcpServers": {
- "sam-mesh": {
+ "agentmesh": {
"serverUrl": "http://127.0.0.1:8080/mcp",
"headers": { "X-Mesh-Authentication": "Bearer <token>" }
}
@@ -125,7 +125,7 @@ Add to `~/.gemini/config/mcp_config.json`:
}
```
-Antigravity picks up the change without a restart. `sam-node skill install`
+Antigravity picks up the change without a restart. `agentmesh-node skill install`
writes the skill to Antigravity's global skills directory. `--project` writes
it to `.agents/skills/` in the workspace instead.
@@ -137,14 +137,14 @@ and keeps it in its secret store, so the file is safe to commit:
```json
{
"inputs": [
- { "type": "promptString", "id": "sam-api-token",
- "description": "SAM node API token", "password": true }
+ { "type": "promptString", "id": "agentmesh-api-token",
+ "description": "Agent Mesh node API token", "password": true }
],
"servers": {
- "sam-mesh": {
+ "agentmesh": {
"type": "http",
"url": "http://127.0.0.1:8080/mcp",
- "headers": { "X-Mesh-Authentication": "Bearer ${input:sam-api-token}" }
+ "headers": { "X-Mesh-Authentication": "Bearer ${input:agentmesh-api-token}" }
}
}
}
@@ -155,7 +155,7 @@ use the **Start** action shown above the entry, or run **MCP: List Servers**
from the command palette. A server listed as stopped was read correctly and
is waiting to be started. If you entered a wrong token, clear it with
**MCP: Reset Cached Tokens**. New tools may not appear in a chat that is
-already in progress. Start a new chat and check that `sam-mesh` is ticked in
+already in progress. Start a new chat and check that `agentmesh-p2p` is ticked in
the tools picker. To use the server in all workspaces, put the same JSON in
the user-level configuration (**MCP: Open User Configuration**). Copilot
reads `~/.claude/skills/`, so the default skill install applies.
@@ -171,7 +171,7 @@ macOS, `%APPDATA%\Claude\` on Windows):
```json
{
"mcpServers": {
- "sam-mesh": {
+ "agentmesh": {
"command": "npx",
"args": [
"mcp-remote", "http://127.0.0.1:8080/mcp", "--allow-http",
@@ -190,7 +190,7 @@ connectors" cannot reach a node on your machine, so use the bridge.
## OpenClaw
```bash
-openclaw mcp set sam-mesh '{
+openclaw mcp set agentmesh '{
"url": "http://127.0.0.1:8080/mcp",
"headers": { "X-Mesh-Authentication": "Bearer <token>" }
}'
@@ -221,7 +221,7 @@ version of this example. For inference, point any OpenAI SDK at
no key.
Native SDKs that join the mesh from inside the agent process, without a
-`sam-node` sidecar, are being built under `sdk/` in the repository; see
+`agentmesh-node` sidecar, are being built under `sdk/` in the repository; see
`sdk/README.md` for their status.
## A note on trust
diff --git a/site/content/docs/guides/egress-destinations.md b/site/content/docs/guides/egress-destinations.md
index 9753f1d5..9ec83c75 100644
--- a/site/content/docs/guides/egress-destinations.md
+++ b/site/content/docs/guides/egress-destinations.md
@@ -6,7 +6,7 @@ weight: 3
An agentic application calls APIs that are not on the mesh: a source
forge, a ticketing system, an internal REST service, a model provider. This
-guide puts a `sam-node` in front of such a destination as a policy
+guide puts a `agentmesh-node` in front of such a destination as a policy
enforcement point. The application changes one base URL. The admin writes
one policy document. The node decides every request on the method, the
path and the caller, holds the credential the destination needs, and keeps
@@ -57,7 +57,7 @@ may call it and how.
- `egress[].name` is the destination hostname. It is the service name in
grants (`egress://api.github.com`) and the name a caller looks up.
- `egress[].credential` is a name, never a value. The serving node reads
- the file `/etc/sam/secrets/github-eu` (or under `--secrets-dir`) and
+ the file `/etc/agentmesh/secrets/github-eu` (or under `--secrets-dir`) and
presents its content as `Authorization: Bearer <content>`; `user:pass`
is sent as HTTP Basic. Whatever puts secrets in files on the host, a
Kubernetes Secret volume, a vault agent, a secrets-store CSI driver,
@@ -80,7 +80,7 @@ curl -sS -X POST "$CONTROL_PLANE/policies" \
## What the node does
-Nothing in `sam-node.yaml` changes, and `type: egress` is refused there. A
+Nothing in `agentmesh-node.yaml` changes, and `type: egress` is refused there. A
node holding the `pep` role pulls its assignments from the control plane on
the same schedule as the mesh policy, and sooner when the policy changes.
For each destination that selects it, the node registers the service,
@@ -107,7 +107,7 @@ bearer, in the place it would hold a provider key:
```bash
export GITHUB_API_URL=http://127.0.0.1:8080/egress/api.github.com
-export GITHUB_TOKEN=$(cat /etc/sam/api-token)
+export GITHUB_TOKEN=$(cat /etc/agentmesh/api-token)
```
A request then travels like this:
@@ -120,13 +120,13 @@ node accepts the API token; drops it
path("/repos/acme/dubbing/pulls") host("api.github.com") port(443)
authorizes on its own credential, with its attenuation
GET https://api.github.com/repos/acme/dubbing/pulls?state=open
- Authorization: Bearer <content of /etc/sam/secrets/github-eu>
+ Authorization: Bearer <content of /etc/agentmesh/secrets/github-eu>
```
The destination sees the node's credential and none of the application's
headers (`Authorization`, `Cookie`, `X-*`). A `403` is a policy decision; a
`404` is a destination this node was not assigned. Both carry
-`Proxy-Status: sam-node; error=...`, so your client can tell them from an
+`Proxy-Status: agentmesh-node; error=...`, so your client can tell them from an
answer the destination sent.
Every decision, allowed or denied, is one `Audit Traceability` line in the
@@ -140,10 +140,10 @@ without reading logs:
| Metric | Labels | Counts |
|---|---|---|
-| `sam_node_egress_decisions_total` | `destination`, `outcome` | requests for a destination, by outcome: `allow`, `deny`, `not_assigned` (the node does not serve that name) and `credential_unavailable` (the credential file could not be read when the request arrived) |
-| `sam_node_egress_assignments_total` | `outcome` | assignments applied from the control plane: `registered`, `withdrawn` and `refused` |
+| `agentmesh_node_egress_decisions_total` | `destination`, `outcome` | requests for a destination, by outcome: `allow`, `deny`, `not_assigned` (the node does not serve that name) and `credential_unavailable` (the credential file could not be read when the request arrived) |
+| `agentmesh_node_egress_assignments_total` | `outcome` | assignments applied from the control plane: `registered`, `withdrawn` and `refused` |
-`sam_node_services_registered{type="egress"}` is the number of destinations
+`agentmesh_node_services_registered{type="egress"}` is the number of destinations
the node serves right now. A `refused` assignment or a `credential_unavailable`
decision means the platform did not deliver a credential the policy names.
@@ -168,7 +168,7 @@ the same path, and `403` on `GET /user`.
## Narrowing on the node
The serving node's operator can refuse what the mesh policy allows, in
-`sam-node.yaml`. The request facts are available there. The dialect has no
+`agentmesh-node.yaml`. The request facts are available there. The dialect has no
`!=`; a negation is `!`:
```yaml
diff --git a/site/content/docs/guides/exposing-services.md b/site/content/docs/guides/exposing-services.md
index d60f8100..fb011388 100644
--- a/site/content/docs/guides/exposing-services.md
+++ b/site/content/docs/guides/exposing-services.md
@@ -7,13 +7,13 @@ aliases:
---
A node does not publish any service by default. You declare the services it
-offers in `sam-node.yaml`. This guide covers the three kinds of service a
+offers in `agentmesh-node.yaml`. This guide covers the three kinds of service a
node can serve and what the mesh policy must contain before anyone can reach
them.
## The configuration file
-`sam-node` reads `sam-node.yaml` from the working directory, or the file
+`agentmesh-node` reads `agentmesh-node.yaml` from the working directory, or the file
named by `--config`. Both `join` and `run` read it, because labels are
declared at enrollment. A minimal file with one service:
@@ -118,7 +118,7 @@ credential, the node checks the policy, and the proxy adds the key on the way
out. If the backend itself requires a credential, put it in a file and name
the file in `target_auth_path`. A bare token is sent as
`Authorization: Bearer`, and a `user:pass` pair as HTTP Basic. This is a
-file and not an inline value because `sam-node.yaml` is copied into
+file and not an inline value because `agentmesh-node.yaml` is copied into
ConfigMaps and repositories. For the same reason, a URL with embedded
credentials is refused.
@@ -173,7 +173,7 @@ Post it to the control plane, or paste it into the console's policy editor:
```bash
curl -fsS -X POST https://mesh.example.com/policies \
- -H "Authorization: Bearer $SAM_ADMIN_TOKEN" \
+ -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN" \
-H "Content-Type: application/json" \
--data @policy.json
```
@@ -247,6 +247,6 @@ target is wrong. The node's log names the check that failed.
## Kubernetes
On Kubernetes a service is a pod with your backend container and a
-`sam-node` sidecar, deployed with the `charts/sam-node` Helm chart; the
+`agentmesh-node` sidecar, deployed with the `charts/agentmesh-node` Helm chart; the
`config:` value is this file. The [Kubernetes guide](../kubernetes/) covers
it.
diff --git a/site/content/docs/guides/headless-enrollment.md b/site/content/docs/guides/headless-enrollment.md
index 32c3a904..4f77ae68 100644
--- a/site/content/docs/guides/headless-enrollment.md
+++ b/site/content/docs/guides/headless-enrollment.md
@@ -26,17 +26,17 @@ plane's audience:
```yaml
volumes:
- - name: sam-token
+ - name: agentmesh-token
projected:
sources:
- serviceAccountToken:
- path: sam-token
+ path: agentmesh-token
expirationSeconds: 3600
audience: agentmesh-audience
```
```bash
-sam-node run --control-plane https://mesh.example.com --jwt-path /var/run/secrets/tokens/sam-token
+agentmesh-node run --control-plane https://mesh.example.com --jwt-path /var/run/secrets/tokens/agentmesh-token
```
List the cluster's issuer in `--issuer` (`controlPlane.oidcIssuer` in the Helm
@@ -45,17 +45,17 @@ chart) and the audience in `--allowed-audiences`; add the cluster issuer to
tokens off `/user/*` and `/oauth/authorize`. Bind either a specific service
account (`user:system:serviceaccount:<namespace>:<name>`) or a namespace prefix
(`user:system:serviceaccount:<namespace>:*`) to `mesh:role:node`. Routers enroll
-the same way with `sam-router --jwt-path`. The [Kubernetes guide](../kubernetes/)
+the same way with `agentmesh-router --jwt-path`. The [Kubernetes guide](../kubernetes/)
shows the complete setup.
### GCE VMs and Cloud Run (`--cloud-provider`)
On Compute Engine and Cloud Run there is no Kubernetes projected volume, so
-`sam-node` can fetch an OIDC identity token directly from the instance
+`agentmesh-node` can fetch an OIDC identity token directly from the instance
metadata server (`.../computeMetadata/v1/instance/service-accounts/default/identity?audience=<aud>&format=full`):
```bash
-sam-node run --control-plane https://mesh.example.com --cloud-provider gcp
+agentmesh-node run --control-plane https://mesh.example.com --cloud-provider gcp
```
`--cloud-provider auto` probes the metadata server at startup and uses it
@@ -68,7 +68,7 @@ both GCE and Cloud Run are treated as workload tokens while human Google
accounts remain able to use `/user/*` and `/oauth/authorize`:
```bash
-sam-control-plane \
+agentmesh-control-plane \
--issuer https://accounts.google.com \
--workload-issuer https://accounts.google.com=.gserviceaccount.com \
--allowed-audiences agentmesh-audience
@@ -81,18 +81,18 @@ example, `email:*@my-project.iam.gserviceaccount.com`) to `mesh:role:node`.
For VMs and bare metal running SPIRE (or multi-cluster meshes sharing a
SPIFFE trust domain), run [`spiffe-helper`](https://github.com/spiffe/spiffe-helper)
-beside `sam-node` to fetch a JWT-SVID from the SPIFFE Workload API and keep
+beside `agentmesh-node` to fetch a JWT-SVID from the SPIFFE Workload API and keep
the file at `--jwt-path` rotated across the SVID's lifetime:
```hcl
# spiffe-helper.conf
agent_address = "/run/spire/sockets/agent.sock"
-cert_dir = "/run/sam"
+cert_dir = "/run/agentmesh"
jwt_svids = [{ jwt_audience = "agentmesh-audience", jwt_svid_file_name = "jwt_svid.token" }]
```
```bash
-sam-node run --control-plane https://mesh.example.com --jwt-path /run/sam/jwt_svid.token
+agentmesh-node run --control-plane https://mesh.example.com --jwt-path /run/agentmesh/jwt_svid.token
```
List the SPIRE OIDC Discovery Provider URL in `--issuer` and `--workload-issuer`
@@ -103,7 +103,7 @@ on the control plane, and bind the SPIFFE ID or path prefix
A workload with an OAuth client ID and secret can use the client-credentials
grant instead, with `--oidc-issuer`, `--client-id` and
-`--client-secret-path` (or `SAM_CLIENT_SECRET`).
+`--client-secret-path` (or `AGENTMESH_CLIENT_SECRET`).
## With a bootstrap token
@@ -111,26 +111,26 @@ For a machine that has no identity of its own, an operator mints a token.
### 1. Mint
-Call the control plane API with the admin token. `sam-one` prints the admin
+Call the control plane API with the admin token. `agentmesh-one` prints the admin
token at start and writes it to its data directory. A separate
-`sam-control-plane` reads it from the file given by `--admin-token-path` or
-from the `SAM_ADMIN_TOKEN` environment variable.
+`agentmesh-control-plane` reads it from the file given by `--admin-token-path` or
+from the `AGENTMESH_ADMIN_TOKEN` environment variable.
```bash
curl -fsS -X POST https://mesh.example.com/admin/bootstrap-tokens \
- -H "Authorization: Bearer $SAM_ADMIN_TOKEN" \
+ -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN" \
-H "Content-Type: application/json" \
-d '{"role":"mesh:role:node","ttl_hours":24,"max_usages":1,"description":"build-runner-3"}'
```
```json
-{"id":"62e92ffca…","token":"sam-bt-72fb0175788dee0…","role":"mesh:role:node","expire_time":"2026-09-20T15:00:00Z"}
+{"id":"62e92ffca…","token":"mesh-bt-72fb0175788dee0…","role":"mesh:role:node","expire_time":"2026-09-20T15:00:00Z"}
```
The plaintext `token` is shown once. The control plane keeps only its hash.
`role` is the role that the token enrolls into (`mesh:role:router` for a
router). `ttl_hours` defaults to 24 and `max_usages` to 1. The Bootstrap
-Tokens view in the console and `sam-one token create` do the same thing. An
+Tokens view in the console and `agentmesh-one token create` do the same thing. An
OIDC user who is already enrolled can mint tokens for their own machines
through `POST /user/bootstrap-tokens` with their ID token. Such tokens
record the user as owner, and banning the user disables them.
@@ -142,27 +142,27 @@ the shell history.
### 2. Enroll
```bash
-sam-node join https://mesh.example.com --bootstrap-token-path /etc/sam/bootstrap-token
+agentmesh-node join https://mesh.example.com --bootstrap-token-path /etc/agentmesh/bootstrap-token
```
or, to enroll and start in one step:
```bash
-sam-node run --control-plane https://mesh.example.com --bootstrap-token-path /etc/sam/bootstrap-token
+agentmesh-node run --control-plane https://mesh.example.com --bootstrap-token-path /etc/agentmesh/bootstrap-token
```
The node submits its public key, the token, and a signature over a fresh
challenge to `POST /enroll`. If the control plane runs with
-`--auto-approve-enrollment` (the default in the Helm chart and in `sam-one`),
+`--auto-approve-enrollment` (the default in the Helm chart and in `agentmesh-one`),
the credential comes back immediately. Otherwise the request is queued and
the node polls until an administrator decides.
### 3. Approve
```bash
-curl -fsS https://mesh.example.com/admin/enrollments -H "Authorization: Bearer $SAM_ADMIN_TOKEN"
+curl -fsS https://mesh.example.com/admin/enrollments -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN"
curl -fsS -X POST https://mesh.example.com/admin/enrollments/<request-id>/approve \
- -H "Authorization: Bearer $SAM_ADMIN_TOKEN"
+ -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN"
```
`.../reject` refuses the request. The console lists pending requests with
@@ -182,7 +182,7 @@ The grant decides which labels a node may carry.
```bash
curl -fsS -X DELETE https://mesh.example.com/admin/bootstrap-tokens/<id> \
- -H "Authorization: Bearer $SAM_ADMIN_TOKEN"
+ -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN"
```
The token stays in the list, marked as revoked, so the record of what it
@@ -210,7 +210,7 @@ again on start when its `enroll` call is given a token, and otherwise
fails with `CredentialRetiredError` naming the state directory. There are
three ways out, in order of preference.
-**Enroll again.** Mint a new token and run `sam-node join` with it. The
+**Enroll again.** Mint a new token and run `agentmesh-node join` with it. The
control plane already knows the peer ID, so it mints a new credential
directly instead of queueing a new approval, as long as the token's role
matches and the node is not banned. Each re-enrollment spends one token
@@ -233,7 +233,7 @@ afterwards:
# on an enrolled node
curl -fsS -X POST https://mesh.example.com/admin/nodes/<peer-id>/autonomous-recovery \
- -H "Authorization: Bearer $SAM_ADMIN_TOKEN" -H "Content-Type: application/json" \
+ -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN" -H "Content-Type: application/json" \
-d '{"enabled":true}'
```
@@ -246,11 +246,11 @@ machines are controlled in other ways.
```bash
curl -fsS -X POST https://mesh.example.com/admin/revoke \
- -H "Authorization: Bearer $SAM_ADMIN_TOKEN" -H "Content-Type: application/json" \
+ -H "Authorization: Bearer $AGENTMESH_ADMIN_TOKEN" -H "Content-Type: application/json" \
-d '{"peer_id":"12D3KooW…"}'
```
The node's next refresh fails and its daemon exits. Connected peers drop it
as soon as the ban event reaches them. `POST /admin/nodes/<peer-id>/unban`
-reverses the ban. `sam-control-plane admin ban --peer <id>` and `unban` do
+reverses the ban. `agentmesh-control-plane admin ban --peer <id>` and `unban` do
the same directly in the database, for cases where the API is not reachable.
diff --git a/site/content/docs/guides/kubernetes.md b/site/content/docs/guides/kubernetes.md
index e09a7e56..d0114210 100644
--- a/site/content/docs/guides/kubernetes.md
+++ b/site/content/docs/guides/kubernetes.md
@@ -7,8 +7,8 @@ aliases:
---
This guide deploys a control plane, a router and a console into a cluster
-with the `sam-mesh` Helm chart, then puts services on the mesh with the
-`sam-node` chart. The last section lists the settings to change when you
+with the `agentmesh-p2p` Helm chart, then puts services on the mesh with the
+`agentmesh-node` chart. The last section lists the settings to change when you
move from a test cluster to one that you keep. The public testnets run this
setup on GKE. Their manifests are in `.github/k8s/` in the repository.
@@ -16,10 +16,10 @@ setup on GKE. Their manifests are in `.github/k8s/` in the repository.
| Component | Kind | Notes |
|---|---|---|
-| `sam-control-plane` | Deployment (2 replicas) | Stateless. All state is in PostgreSQL. |
+| `agentmesh-control-plane` | Deployment (2 replicas) | Stateless. All state is in PostgreSQL. |
| PostgreSQL | StatefulSet | In-cluster by default (`database.postgres.deployInternal`). You can point the chart at your own database instead. |
-| `sam-router` | StatefulSet | A PVC holds `router.key`, so the peer ID survives rescheduling. |
-| `sam-console` | Deployment | Optional (`console.enabled`). |
+| `agentmesh-router` | StatefulSet | A PVC holds `router.key`, so the peer ID survives rescheduling. |
+| `agentmesh-console` | Deployment | Optional (`console.enabled`). |
| bootstrap Job | Job (post-install hook) | Seeds the mesh policy and mints the router's bootstrap token. |
| Gateway + HTTPRoute | Gateway API | Optional (`gateway.enabled`). Routes the enrollment paths and the console. |
@@ -33,12 +33,12 @@ to be distributed.
```bash
ISSUER=$(kubectl get --raw /.well-known/openid-configuration | jq -r .issuer)
-helm upgrade --install sam-mesh ./charts/sam-mesh \
- --namespace sam --create-namespace \
+helm upgrade --install agentmesh ./charts/agentmesh \
+ --namespace agentmesh --create-namespace \
--set controlPlane.oidcIssuer="$ISSUER" \
--set controlPlane.workloadIssuer="$ISSUER" \
--set controlPlane.insecureSkipTlsVerify=true \
- --set bootstrap.nodeMembers='{user:system:serviceaccount:sam-nodes:calc-mcp-sam-node}' \
+ --set bootstrap.nodeMembers='{user:system:serviceaccount:agentmesh-nodes:calc-mcp-agentmesh-node}' \
--set bootstrap.nodeServices='{mcp://calculator,system://mesh.catalog}'
```
@@ -67,23 +67,23 @@ install and on upgrade, but once the database has a policy, the database is
the source of truth.
The chart generates an admin token and a database password and stores them
-in the `sam-mesh-secrets` Secret. The release notes print the command to
+in the `agentmesh-secrets` Secret. The release notes print the command to
read them:
```bash
-kubectl -n sam get secret sam-mesh-secrets -o jsonpath='{.data.admin-token}' | base64 -d
+kubectl -n agentmesh get secret agentmesh-secrets -o jsonpath='{.data.admin-token}' | base64 -d
```
The router enrolls with a bootstrap token that the job writes into
-`sam-mesh-router-token`, with `max_usages` equal to `router.replicaCount`.
+`agentmesh-router-token`, with `max_usages` equal to `router.replicaCount`.
Set `router.useOidcToken=true` to make it use a projected service account
token instead.
## 2. Expose it
Inside the cluster, the control plane answers at
-`http://sam-mesh-control-plane.sam.svc:8080` and the router at
-`sam-mesh-router.sam.svc:4501`. That is enough for nodes in the same cluster.
+`http://agentmesh-control-plane.agentmesh.svc:8080` and the router at
+`agentmesh-router.agentmesh.svc:4501`. That is enough for nodes in the same cluster.
Nodes outside the cluster need two things: the control plane over HTTPS
(nodes refuse to fetch their trust root over plaintext from a remote
@@ -99,7 +99,7 @@ gateway:
protocol: HTTPS
port: 443
tls:
- certificateRefs: [{ name: sam-mesh-tls }]
+ certificateRefs: [{ name: agentmesh-tls }]
allowedRoutes: { namespaces: { from: Same } }
hostnames: [mesh.example.com]
```
@@ -132,14 +132,14 @@ current works.
## 3. Put a service on the mesh
A service on Kubernetes is a pod with your backend container and a
-`sam-node` sidecar, both deployed by the `sam-node` chart. The node enrolls
+`agentmesh-node` sidecar, both deployed by the `agentmesh-node` chart. The node enrolls
with the pod's projected service account token, so its identity is
-`user:system:serviceaccount:<namespace>:<release>-sam-node`. This is the
+`user:system:serviceaccount:<namespace>:<release>-agentmesh-node`. This is the
identity that the binding in step 1 named.
```yaml
# calc-mcp.values.yaml
-controlPlaneUrl: http://sam-mesh-control-plane.sam.svc:8080
+controlPlaneUrl: http://agentmesh-control-plane.agentmesh.svc:8080
config:
version: v1alpha1
services:
@@ -154,13 +154,13 @@ service:
```
```bash
-helm upgrade --install calc-mcp ./charts/sam-node \
- --namespace sam-nodes --create-namespace -f calc-mcp.values.yaml
+helm upgrade --install calc-mcp ./charts/agentmesh-node \
+ --namespace agentmesh-nodes --create-namespace -f calc-mcp.values.yaml
```
-`config` is the node's `sam-node.yaml`. The pod restarts when it changes.
+`config` is the node's `agentmesh-node.yaml`. The pod restarts when it changes.
The sidecar and the backend share the pod's network, so `target_url` is
-always `127.0.0.1`. `extraArgs` passes additional `sam-node run` flags. The
+always `127.0.0.1`. `extraArgs` passes additional `agentmesh-node run` flags. The
chart adds `--insecure-control-plane` for you when the control plane URL is
plain `http` inside the cluster. With a `replicaCount` above one, each
replica enrolls as its own node and offers the same service name.
@@ -172,7 +172,7 @@ kind cluster. See [Contributing](../../contributing/#a-local-mesh-in-kind).
## 4. Check it
```bash
-kubectl -n sam-nodes logs deploy/calc-mcp -c sam-node | grep -E "Online|PeerID"
+kubectl -n agentmesh-nodes logs deploy/calc-mcp -c agentmesh-node | grep -E "Online|PeerID"
```
From a node enrolled anywhere in the mesh:
@@ -184,7 +184,7 @@ mcp-client -url http://127.0.0.1:8080/mcp -token "$TOKEN" \
The console shows the same information: enrolled nodes, their reported
services, the router, and the policy. It is at `/console/` behind the
-gateway, or you can port-forward `svc/sam-mesh-console`.
+gateway, or you can port-forward `svc/agentmesh-console`.
## Keeping it
@@ -193,7 +193,7 @@ keep, review these settings:
- **Database.** Set `database.postgres.deployInternal=false` and give the
control plane the DSN of a managed PostgreSQL through `--db-dsn-path` or
- the `SAM_DB_DSN` environment variable. The DSN contains a password, so it
+ the `AGENTMESH_DB_DSN` environment variable. The DSN contains a password, so it
should not be a flag value.
- **Enrollment.** `controlPlane.autoApproveEnrollment` defaults to `true`.
That is fine when every enrollee holds an OIDC token from an issuer that
@@ -214,7 +214,7 @@ keep, review these settings:
scrape the control plane and the router. Both metrics endpoints are
unauthenticated, so keep them inside the cluster.
-The chart's [README](https://github.com/google/sam/blob/main/charts/sam-mesh/README.md)
+The chart's [README](https://github.com/google/agentmesh/blob/main/charts/agentmesh/README.md)
documents every value. The [control plane](../../reference/control-plane/)
and [router](../../reference/router/) references list the flags the chart
sets.
diff --git a/site/content/docs/guides/native-sdks.md b/site/content/docs/guides/native-sdks.md
index dd905fed..f08f6737 100644
--- a/site/content/docs/guides/native-sdks.md
+++ b/site/content/docs/guides/native-sdks.md
@@ -77,8 +77,8 @@ The programs below read the mesh from two environment variables. Set them in
every terminal you use:
```bash
-export SAM_CONTROL_PLANE_URL=http://127.0.0.1:33775 # the API URL from the banner
-export SAM_BOOTSTRAP_TOKEN_PATH=~/agentmesh-one/join-token
+export AGENTMESH_CONTROL_PLANE_URL=http://127.0.0.1:33775 # the API URL from the banner
+export AGENTMESH_BOOTSTRAP_TOKEN_PATH=~/agentmesh-one/join-token
```
A plain `http://` URL is accepted only for a control plane on the same
@@ -86,15 +86,15 @@ machine. Anything else needs `https://`, because the control plane is the
trust root of every member and the SDK refuses to fetch it over plaintext
from a remote address. Inside a network you already trust, such as a
Kubernetes cluster where the control plane is a cluster-local service, set
-`SAM_INSECURE_CONTROL_PLANE=true` (`allowInsecure` in code), the same choice
+`AGENTMESH_INSECURE_CONTROL_PLANE=true` (`allowInsecure` in code), the same choice
as `agentmesh-node --insecure-control-plane`.
On a platform that issues workload identity tokens, a program needs no
bootstrap token. A mesh whose control plane trusts the platform's issuer
enrolls the program from that token instead; on Kubernetes that is a
projected service account token, as [Headless enrollment](../headless-enrollment/)
-shows for `agentmesh-node`. Set `SAM_JWT_PATH` (`jwtPath` / `jwt_path`) to the
-token file rather than `SAM_BOOTSTRAP_TOKEN_PATH`, or pass a `jwt` callback
+shows for `agentmesh-node`. Set `AGENTMESH_JWT_PATH` (`jwtPath` / `jwt_path`) to the
+token file rather than `AGENTMESH_BOOTSTRAP_TOKEN_PATH`, or pass a `jwt` callback
(`() => string | Promise<string>` in JS, `Callable[[], str]` in Python) that
fetches a fresh token (for example, from a cloud metadata server). On every
credential refresh, the SDK re-reads `jwtPath` or invokes the `jwt` callback
diff --git a/site/content/docs/guides/skypilot.md b/site/content/docs/guides/skypilot.md
index c9329836..de2d97e7 100644
--- a/site/content/docs/guides/skypilot.md
+++ b/site/content/docs/guides/skypilot.md
@@ -7,30 +7,30 @@ weight: 6
[SkyPilot](https://docs.skypilot.co/) provisions and manages compute across
Google Cloud, AWS, Azure, OCI, and Kubernetes using your existing cloud
credentials (`sky check`). The repository includes a ready-to-run recipe,
-[`deploy/skypilot/sam-one.yaml`](https://github.com/google/sam/blob/main/deploy/skypilot/sam-one.yaml),
-that deploys a standalone `sam-one` control plane and router with a persistent
+[`deploy/skypilot/agentmesh-one.yaml`](https://github.com/google/agentmesh/blob/main/deploy/skypilot/agentmesh-one.yaml),
+that deploys a standalone `agentmesh-one` control plane and router with a persistent
disk and an outbound Cloudflare HTTPS tunnel (requiring no inbound firewall
rules).
-*(Note: While `deploy/skypilot/sam-one.yaml` defaults to production VM sizing
+*(Note: While `deploy/skypilot/agentmesh-one.yaml` defaults to production VM sizing
(`cpus: 2+`, `memory: 8+`, matching `e2-standard-2` on GCP or `t3.large` on AWS),
you can also set `cpus: 0.25+` and `memory: 1+` to run on cloud provider free
tiers such as GCP `e2-micro` or AWS `t4g.micro` for testing.)*
-## 1. Deploy `sam-one` with SkyPilot
+## 1. Deploy `agentmesh-one` with SkyPilot
### Production deployment (custom domain)
If you have a tunnel authentication token bound to a custom hostname (such as
-`https://mesh.example.com`), launch the cluster with `SAM_EXTERNAL_URL` and
-`SAM_TUNNEL_TOKEN`:
+`https://mesh.example.com`), launch the cluster with `AGENTMESH_EXTERNAL_URL` and
+`AGENTMESH_TUNNEL_TOKEN`:
```bash
-export SAM_TUNNEL_TOKEN="eyJhIjoi..."
+export AGENTMESH_TUNNEL_TOKEN="eyJhIjoi..."
-sky launch -y -c sam-hub deploy/skypilot/sam-one.yaml --detach-run \
- --env SAM_EXTERNAL_URL=https://mesh.example.com \
- --secret SAM_TUNNEL_TOKEN
+sky launch -y -c agentmesh-hub deploy/skypilot/agentmesh-one.yaml --detach-run \
+ --env AGENTMESH_EXTERNAL_URL=https://mesh.example.com \
+ --secret AGENTMESH_TUNNEL_TOKEN
```
### Quick deployment (automatic HTTPS tunnel)
@@ -39,36 +39,36 @@ To launch immediately with an automatic `https://<name>.trycloudflare.com`
address and zero DNS setup:
```bash
-sky launch -y -c sam-hub deploy/skypilot/sam-one.yaml --detach-run
+sky launch -y -c agentmesh-hub deploy/skypilot/agentmesh-one.yaml --detach-run
```
To target a specific cloud provider (for example Google Cloud), pass `--infra gcp`:
```bash
-sky launch -y -c sam-hub deploy/skypilot/sam-one.yaml --infra gcp --detach-run
+sky launch -y -c agentmesh-hub deploy/skypilot/agentmesh-one.yaml --infra gcp --detach-run
```
## 2. Obtain your Control Plane URL and tokens
-Read the `sam-one` startup banner from job `1`:
+Read the `agentmesh-one` startup banner from job `1`:
```bash
-sky logs sam-hub 1 --no-follow
+sky logs agentmesh-hub 1 --no-follow
```
```text
══════════════════════════════════════════════════════════════════
-SAM standalone mesh is ready!
+Agent Mesh standalone mesh is ready!
API URL: https://distinct-kent-bradford-elderly.trycloudflare.com
Tunnel: https://distinct-kent-bradford-elderly.trycloudflare.com -> http://0.0.0.0:8080
Web Console: https://distinct-kent-bradford-elderly.trycloudflare.com/console
Router Peer: 12D3KooWScRWXVx2zSaPWC7NectYnuyhaGxpLYkNgCkp2g2tkfkY
-Admin Token: sam_adm_e4075529d72bb22d78446799f683dd89
+Admin Token: mesh_adm_e4075529d72bb22d78446799f683dd89
Join Token: mesh_tok_05a5d01cf091187c980e68e1bd7d7d7a
To enroll a node:
- sam-node join https://distinct-kent-bradford-elderly.trycloudflare.com --bootstrap-token-path /home/gcpuser/sam-one/join-token
+ agentmesh-node join https://distinct-kent-bradford-elderly.trycloudflare.com --bootstrap-token-path /home/gcpuser/agentmesh-one/join-token
══════════════════════════════════════════════════════════════════
```
@@ -94,18 +94,18 @@ Biscuit authorization, and WebSocket relay forwarding between two nodes:
target_url: "http://127.0.0.1:11434"
EOF
- sam-node run --control-plane "$URL" \
+ agentmesh-node run --control-plane "$URL" \
--bootstrap-token-path join-token \
--config node-a.yaml --data-dir ~/node-a --bind-addr=
```
2. **Start Node B and call Node A's service through the mesh**:
```bash
- sam-node run --control-plane "$URL" \
+ agentmesh-node run --control-plane "$URL" \
--bootstrap-token-path join-token \
--data-dir ~/node-b --bind-addr=
- curl -s --unix-socket ~/node-b/sam.sock http://localhost/v1/models
- curl -s --unix-socket ~/node-b/sam.sock http://localhost/v1/chat/completions \
+ curl -s --unix-socket ~/node-b/agentmesh.sock http://localhost/v1/models
+ curl -s --unix-socket ~/node-b/agentmesh.sock http://localhost/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model":"gemma3:1b","messages":[{"role":"user","content":"Ping across the mesh"}]}'
```
@@ -114,13 +114,13 @@ Biscuit authorization, and WebSocket relay forwarding between two nodes:
```bash
# Check status of the SkyPilot cluster
-sky status sam-hub
+sky status agentmesh-hub
-# Administer tokens and policies remotely using sam-one
-export SAM_ADMIN_TOKEN="sam_adm_..."
-sam-one token create --server "$URL" --role mesh:role:node --max-usages 1
-sam-one token list --server "$URL"
+# Administer tokens and policies remotely using agentmesh-one
+export AGENTMESH_ADMIN_TOKEN="mesh_adm_..."
+agentmesh-one token create --server "$URL" --role mesh:role:node --max-usages 1
+agentmesh-one token list --server "$URL"
# Tear down the cluster when no longer needed
-sky down -y sam-hub
+sky down -y agentmesh-hub
```
diff --git a/site/content/docs/preview/_index.md b/site/content/docs/preview/_index.md
index f1dded60..fa62793e 100644
--- a/site/content/docs/preview/_index.md
+++ b/site/content/docs/preview/_index.md
@@ -15,7 +15,7 @@ you find.
- [Agent architecture](agent-architecture/): the design behind the
sandbox: why the boundary uses named HTTP tunnels, how an agent gets an
identity, and how an agent serves.
-- [SAM Connect](mobile/): the Android and iOS app that turns a phone into a
+- [Agent Mesh Connect](mobile/): the Android and iOS app that turns a phone into a
node.
- [Scale report](scale-report/) and [how to reproduce it](scale-experiment/):
what a sandboxed agent costs, measured up to a thousand agents on one host.
diff --git a/site/content/docs/preview/agent-architecture.md b/site/content/docs/preview/agent-architecture.md
index 7bce5fff..55a0dcd2 100644
--- a/site/content/docs/preview/agent-architecture.md
+++ b/site/content/docs/preview/agent-architecture.md
@@ -6,7 +6,7 @@ aliases:
- /docs/agent-architecture/
---
-This page explains how SAM authenticates workloads and users, scopes authority
+This page explains how Agent Mesh authenticates workloads and users, scopes authority
to individual tasks and sub-agent hops, integrates with existing gateways and
sandbox runtimes, and brokers short-lived credentials to external cloud APIs
without placing standing cloud credentials inside the agent environment.
@@ -15,23 +15,23 @@ without placing standing cloud credentials inside the agent environment.
![The Agent Mesh as a courier network](/images/agent-mesh-courier.svg)
-SAM moves tasks between environments that trust nothing on arrival, the way a
+Agent Mesh moves tasks between environments that trust nothing on arrival, the way a
courier network moves parcels between post offices:
-| In the picture | In SAM |
+| In the picture | In Agent Mesh |
|---|---|
| **Parcel** | One request: an MCP tool call, a chat completion, a BigQuery query, an A2A message. |
| **Sender** | The agent wherever it runs: a developer laptop, Kubernetes on premises or in a cloud, a SaaS platform, or a sandbox runtime. |
-| **Local post office** | The `sam-node` next to the agent, or the native SDK (`@sam-mesh/sdk`, `sam-mesh`) inside its process. It verifies the sender's platform credential and obtains a task waybill from the control plane. |
-| **Your gateway** | Istio, `agentgateway`, Envoy AI Gateway, or `kgateway` where a cluster already runs one. It stays in the data path and consults `sam-node` over Envoy `ext_proc`, `ext_authz`, or RFC 8693 `/oauth/token`. |
-| **Waybill** | The SAM Biscuit credential: who the subject is, through which actor node it travels, which roles it holds, and when it expires. |
+| **Local post office** | The `agentmesh-node` next to the agent, or the native SDK (`@agentmesh-p2p/sdk`, `agentmesh-p2p`) inside its process. It verifies the sender's platform credential and obtains a task waybill from the control plane. |
+| **Your gateway** | Istio, `agentgateway`, Envoy AI Gateway, or `kgateway` where a cluster already runs one. It stays in the data path and consults `agentmesh-node` over Envoy `ext_proc`, `ext_authz`, or RFC 8693 `/oauth/token`. |
+| **Waybill** | The Agent Mesh Biscuit credential: who the subject is, through which actor node it travels, which roles it holds, and when it expires. |
| **Stamp** | An offline attenuation block (`tar_block`) appended at a task or sub-agent hop. Each stamp carries a serialized `TaskAuthorizationRule` and can only narrow authority. |
| **Sealed bag** | The mutually authenticated, encrypted libp2p stream between two nodes. Routers relay ciphertext across NATs, clusters, and clouds and cannot inspect it. |
-| **Registry** | `sam-control-plane`: verifies identities, issues Biscuits (`POST /token/exchange`), distributes Datalog policy, and acts as an OIDC issuer (`POST /sts/token`, `/.well-known/openid-configuration`, `/jwks`) for outbound cloud federation. |
-| **Destination office** | The serving or egress `sam-node` for `mcp://`, `inference://`, `a2a://`, or `egress://`: verifies the Biscuit and every `tar_block` stamp, runs content inspection, brokers the upstream credential, and delivers the request. |
+| **Registry** | `agentmesh-control-plane`: verifies identities, issues Biscuits (`POST /token/exchange`), distributes Datalog policy, and acts as an OIDC issuer (`POST /sts/token`, `/.well-known/openid-configuration`, `/jwks`) for outbound cloud federation. |
+| **Destination office** | The serving or egress `agentmesh-node` for `mcp://`, `inference://`, `a2a://`, or `egress://`: verifies the Biscuit and every `tar_block` stamp, runs content inspection, brokers the upstream credential, and delivers the request. |
| **Customs** | Content inspection at the egress node: built-in policy facts, Google Cloud Model Armor, and Envoy `ext_proc` callout processors. |
| **Permit** | The upstream destination credential: a federated cloud token exchanged via `CloudTokenExchanger` or a secret from the node's vault, never held by the agent. |
-| **Receipts** | Structured audit logs at the control plane, the origin and egress nodes, and the cloud provider, joined by principal and `sam_task`. |
+| **Receipts** | Structured audit logs at the control plane, the origin and egress nodes, and the cloud provider, joined by principal and `mesh_task`. |
## Why workload identity alone is not enough
@@ -52,7 +52,7 @@ SPIFFE SVID). Workload identity is necessary, but insufficient for AI agents:
(`Token_2 = Attenuate(Token_1, TaskRule)`) without minting a new identity at
the identity provider on every hop.
-SAM separates the two layers:
+Agent Mesh separates the two layers:
| Layer | Question answered | Primitive |
|---|---|---|
@@ -64,16 +64,16 @@ SAM separates the two layers:
OS and container confinement belongs to the sandbox platform (**Kubernetes
`agent-sandbox`**, **NVIDIA OpenShell**, **Docker Sandbox `docker sbx`**).
Local traffic interception belongs to the proxy (**`agentgateway`**, **Istio**,
-**Envoy**, or **`sam-node`**). SAM provides:
+**Envoy**, or **`agentmesh-node`**). Agent Mesh provides:
-- **`sam-control-plane`**: the mesh authority, Datalog policy distributor,
+- **`agentmesh-control-plane`**: the mesh authority, Datalog policy distributor,
OAuth 2.1 Authorization Server, stateless token exchanger
(`POST /token/exchange`), and OIDC issuer (`POST /sts/token`) for cloud
federation.
-- **`sam-node`**: the Policy Decision Point (PDP), RFC 8693 Security Token
+- **`agentmesh-node`**: the Policy Decision Point (PDP), RFC 8693 Security Token
Service (`POST /oauth/token`), Envoy `ext_authz` and `ext_proc` server, mesh
router client, and egress credential broker.
-- **Native SDKs (`@sam-mesh/sdk`, `sam-mesh`)**: in-process mesh clients for
+- **Native SDKs (`@agentmesh-p2p/sdk`, `agentmesh-p2p`)**: in-process mesh clients for
TypeScript and Python that enroll, open authenticated streams, verify peers,
and attenuate and seal task credentials in memory (`session.attenuate(rule)`,
`session.seal()`).
@@ -81,11 +81,11 @@ Local traffic interception belongs to the proxy (**`agentgateway`**, **Istio**,
## The two-token model: Biscuit inside, JWT at both borders
Inside the mesh, every credential is a Biscuit. External identity providers and
-cloud APIs speak standard JWTs and OAuth 2.1 / RFC 8693. SAM translates at both
+cloud APIs speak standard JWTs and OAuth 2.1 / RFC 8693. Agent Mesh translates at both
borders:
1. **Inbound border (`POST /token/exchange` on the control plane, `POST /oauth/token` on the node):**
- The origin `sam-node` presents its own node Biscuit, a proof-of-possession
+ The origin `agentmesh-node` presents its own node Biscuit, a proof-of-possession
signature over `mesh:token-exchange:<peer_id>:<challenge_unix_ms>`, and the
caller's `subject_token` (an OIDC JWT, Kubernetes projected SA token, or
SPIFFE JWT-SVID). The control plane verifies both, resolves the caller's
@@ -102,19 +102,19 @@ borders:
optionally seals the token (`Seal()`) so downstream leaf processes cannot
append further blocks.
3. **Outbound border (`POST /sts/token` + `CloudTokenExchanger`):**
- When a request reaches an egress `sam-node` (`egress://<destination>`), the
+ When a request reaches an egress `agentmesh-node` (`egress://<destination>`), the
node verifies the Biscuit signature, channel binding, standing Datalog
policy, and every appended `TaskAuthorizationRule`. On a cache miss for the
Biscuit digest, it calls `POST /sts/token` on the control plane, which
re-verifies the token and mints a short-lived **ES256 JWT** (`iss` = control
plane, `sub` = caller principal, `act.sub` = egress node peer ID, `aud` =
- destination audience, `sam_roles` = caller roles, `sam_task` = innermost
+ destination audience, `mesh_roles` = caller roles, `mesh_task` = innermost
task name). The egress node's `CloudTokenExchanger` exchanges that JWT at
the cloud provider's STS endpoint.
## Safe Biscuit attenuation (`tar_block`)
-SAM never evaluates holder-authored Datalog rules or checks. In `biscuit-go`,
+Agent Mesh never evaluates holder-authored Datalog rules or checks. In `biscuit-go`,
Datalog `check if` queries are not bounded by rule-iteration limits, and
allowing both Datalog checks and a serialized protobuf in an appended block
would let a crafted token make the mesh PEP and the cloud STS adapter disagree.
@@ -154,13 +154,13 @@ Each `TaskRule` scopes:
## Gateway integration (`agentgateway`, Istio, Envoy)
-Where a cluster already runs Envoy, Istio, or `agentgateway`, `sam-node` acts
+Where a cluster already runs Envoy, Istio, or `agentgateway`, `agentmesh-node` acts
as their external Policy Decision Point and Token Service over three standard
interfaces:
1. **Envoy `ext_authz` (on the local API listeners):** evaluates standing
policy and `tar_block` chains on incoming `CheckRequest` calls. The caller
- presents a Biscuit, or a platform JWT that `sam-node` exchanges at the
+ presents a Biscuit, or a platform JWT that `agentmesh-node` exchanges at the
control plane into a delegated Biscuit. On `OK` it returns `X-Mesh-Biscuit`,
`X-Mesh-Principal`, `X-Mesh-Roles`, `X-Mesh-Task-Id` and, for `egress://`
targets with a credential broker, the brokered `Authorization` header.
@@ -216,7 +216,7 @@ reach an external service:
- **Named TCP tunnels (`mode: EGRESS_MODE_TCP`):**
For non-HTTP TLS protocols (PostgreSQL, Cloud SQL, AlloyDB, Redis, SSH), the
egress node exposes named `CONNECT host:port` tunnels and the local
- `sam-node forward egress://<name>:<port> <local-addr>` port forwarder. The
+ `agentmesh-node forward egress://<name>:<port> <local-addr>` port forwarder. The
egress node enforces the destination's `ports` allow-list and inspects the
TLS `ClientHello` before splicing, refusing connections whose SNI does not
match the authorized destination name or that hide the SNI with Encrypted
@@ -224,13 +224,13 @@ reach an external service:
## Control-plane STS sizing
-`sam-node` caches exchanged Delegated Biscuits by `SHA-256(subject_jwt + tar)`
+`agentmesh-node` caches exchanged Delegated Biscuits by `SHA-256(subject_jwt + tar)`
and caches minted border JWTs and upstream cloud tokens by Biscuit digest,
keeping the control plane off the per-request hot path. You can measure raw
control-plane mint throughput and node cache hit rates on your hardware with:
```bash
-sam-bench sts --requests 200 --concurrency 8 --warmup 10
+agentmesh-bench sts --requests 200 --concurrency 8 --warmup 10
```
On a standard development workstation (8 concurrent workers, SQLite store):
diff --git a/site/content/docs/preview/mobile.md b/site/content/docs/preview/mobile.md
index de6723d7..ad6dc463 100644
--- a/site/content/docs/preview/mobile.md
+++ b/site/content/docs/preview/mobile.md
@@ -1,6 +1,6 @@
---
-title: "SAM Connect (Android)"
-linkTitle: "SAM Connect"
+title: "Agent Mesh Connect (Android)"
+linkTitle: "Agent Mesh Connect"
weight: 3
aliases:
- /docs/user/mobile-app/
@@ -8,12 +8,12 @@ aliases:
---
{{% alert title="Preview" color="warning" %}}
-SAM Connect currently supports Android only. There is no iOS app.
+Agent Mesh Connect currently supports Android only. There is no iOS app.
The app is tested in CI on an Android emulator. Its screens, the on-device
tools it exposes and the FFI surface may change.
{{% /alert %}}
-SAM Connect is a Flutter app that runs `sam-node` on an Android phone. The Go node is
+Agent Mesh Connect is a Flutter app that runs `agentmesh-node` on an Android phone. The Go node is
compiled into a shared library and driven over Dart FFI. The app is the UI
around it, plus a small MCP server that exposes the phone's sensors to the
mesh. A phone enrolled this way is a node like any other. It has a key, a
@@ -23,13 +23,13 @@ credential and a peer ID, and it appears in discovery with its
## Android tester tutorial
You need an Android 10 or newer phone and an internet connection. You can
-join a public testnet through browser login, or join your own `sam-one`
+join a public testnet through browser login, or join your own `agentmesh-one`
mesh by scanning its QR code. Choose one enrollment path, then follow the
same connection checks.
Keep **Location** off throughout this tutorial, and leave external MCP
bridging unconfigured. Other participants may be able to call services you
-expose. The public testnets have no uptime commitment. A new `sam-one`
+expose. The public testnets have no uptime commitment. A new `agentmesh-one`
mesh uses an open development policy that lets enrolled nodes call each
other's services. Share enrollment codes only with people you intend to
admit.
@@ -38,14 +38,14 @@ admit.
1. Open the Google Play testing invitation supplied by the test coordinator.
Use the invited Google account, join the test, and install or update
- **SAM Connect**. If you were given an APK instead, download it from the
+ **Agent Mesh Connect**. If you were given an APK instead, download it from the
supplied build link and open it on the phone. Android may ask you to
allow installation from that source.
2. Check that you have the build requested in the invitation. Record its
version and build number, along with your phone model and Android
version. The coordinator can identify the build number from the APK
link if Android's app information only shows the version name.
-3. Open **SAM Connect**. A new installation shows **Welcome to SAM**.
+3. Open **Agent Mesh Connect**. A new installation shows **Welcome to Agent Mesh**.
If you already see the dashboard, the app has a saved enrollment. Keep
it for an upgrade test, or use step 7 to change meshes.
@@ -54,25 +54,25 @@ update because its signature differs from the installed app, report it to
the coordinator. Uninstalling or clearing app storage deletes the saved
identity and settings.
-{{< figure src="/images/sam-connect-welcome.png" alt="SAM Connect welcome screen with Scan enrollment code and Enter details manually buttons" caption="The welcome screen offers both paths: Enter details manually for a public testnet, or Scan enrollment code for your own mesh." width="320" >}}
+{{< figure src="/images/sam-connect-welcome.png" alt="Agent Mesh Connect welcome screen with Scan enrollment code and Enter details manually buttons" caption="The welcome screen offers both paths: Enter details manually for a public testnet, or Scan enrollment code for your own mesh." width="320" >}}
### 2. Choose your mesh
| Option | What you need | Enrollment path |
| --- | --- | --- |
| Public testnet | A Google or GitHub account and a browser. You do not need to run a server. | [Option A: Public testnet](#option-a-public-testnet) |
-| Your own mesh | A computer running `sam-one`, or a QR code from a trusted operator who runs it. No Google or GitHub login is needed for enrollment. | [Option B: Your own mesh with a QR code](#option-b-your-own-mesh-with-a-qr-code) |
+| Your own mesh | A computer running `agentmesh-one`, or a QR code from a trusted operator who runs it. No Google or GitHub login is needed for enrollment. | [Option B: Your own mesh with a QR code](#option-b-your-own-mesh-with-a-qr-code) |
For the public-testnet option, choose one of these URLs:
| Testnet | Control plane URL | When to use it |
| --- | --- | --- |
-| Bananas | `https://bananas.sam-mesh.dev` | Recommended for testing current development code. Its servers follow `main`. |
-| Hub | `https://hub.sam-mesh.dev` | Compare against servers running the latest release. |
+| Bananas | `https://bananas.__PROTECT_Agent Mesh_MESH_DEV__` | Recommended for testing current development code. Its servers follow `main`. |
+| Hub | `https://hub.__PROTECT_Agent Mesh_MESH_DEV__` | Compare against servers running the latest release. |
See [Testnets](../../contributing/testnets/) for their access policy and
availability details. For your own mesh, use the HTTPS URL printed by
-`sam-one`, as described in option B.
+`agentmesh-one`, as described in option B.
Record the control plane URL you use. It is not an app download link.
The dashboard currently shows **Mesh: public-mesh** for either enrollment
@@ -95,8 +95,8 @@ Then follow option A or option B.
3. Leave **Enrollment token** empty. Public-testnet browser login does not
require a token or QR code.
4. Tap **Login & Enroll (Browser)**. Complete the Google or GitHub sign-in
- offered by `auth.sam-mesh.dev` in the browser on this phone.
-5. When the browser shows **Authorization successful!**, return to SAM
+ offered by `auth.__PROTECT_Agent Mesh_MESH_DEV__` in the browser on this phone.
+5. When the browser shows **Authorization successful!**, return to Agent Mesh
Connect using the app switcher. Keep the app open while enrollment
finishes. The browser message only confirms the login callback.
@@ -104,7 +104,7 @@ Then follow option A or option B.
If you need to sign in on another device, choose **Device Login (TV / Other
Device)** instead. Open the displayed verification URL on that device,
-enter the code shown by the app, and complete sign-in. Keep SAM Connect
+enter the code shown by the app, and complete sign-in. Keep Agent Mesh Connect
open while it waits for approval. Treat the verification URL and code as
private login information.
@@ -113,17 +113,17 @@ Once the dashboard appears, continue to step 4.
#### Option B: Your own mesh with a QR code
The [Your own mesh guide](../../getting-started/your-own-mesh/#reaching-it-from-other-machines)
-covers running `sam-one` and reaching it from a phone. For this enrollment
+covers running `agentmesh-one` and reaching it from a phone. For this enrollment
test, you only need the server and its QR code. You can skip that guide's
model-serving steps.
Use this command to start the mesh and print its enrollment QR code:
```bash
-sam-one --data-dir ~/sam-one --tunnel cloudflare --enroll-qr
+agentmesh-one --data-dir ~/agentmesh-one --tunnel cloudflare --enroll-qr
```
-1. On your computer, install `sam-one` using the
+1. On your computer, install `agentmesh-one` using the
[installation instructions](../../getting-started/quickstart/#1-install).
If a trusted operator already has a mesh running, ask them for an
enrollment code and its expected hostname, then continue at item 4.
@@ -131,7 +131,7 @@ sam-one --data-dir ~/sam-one --tunnel cloudflare --enroll-qr
3. If prompted, approve the download of `cloudflared`. Wait for the HTTPS
API URL and enrollment QR code in the terminal. The tunnel provides a
temporary `trycloudflare.com` address without requiring a Cloudflare
- account. Keep `sam-one` running and the computer awake during the test.
+ account. Keep `agentmesh-one` running and the computer awake during the test.
4. On the phone, return to **Dashboard** and tap **Scan enrollment code**.
Allow camera access when asked and scan the code from the computer's
@@ -143,14 +143,14 @@ sam-one --data-dir ~/sam-one --tunnel cloudflare --enroll-qr
of the tutorial. This enrollment path does not open Google or GitHub
login.
-The following output was captured from a temporary `sam-one` instance.
+The following output was captured from a temporary `agentmesh-one` instance.
Its QR token successfully enrolled a test node and was consumed. The server
and tunnel were then stopped and their state deleted. Token values and the
temporary directory path are redacted below. Use the URL and QR code from
your own terminal, not this example.
```text
-SAM standalone mesh is ready!
+Agent Mesh standalone mesh is ready!
API URL: https://used-encryption-assumptions-miller.trycloudflare.com
Tunnel: https://used-encryption-assumptions-miller.trycloudflare.com -> http://127.0.0.1:46289
@@ -160,10 +160,10 @@ Admin Token: [redacted]
Join Token: [redacted]
To enroll a node:
- sam-node join https://used-encryption-assumptions-miller.trycloudflare.com --bootstrap-token-path <temporary-data-dir>/join-token
+ agentmesh-node join https://used-encryption-assumptions-miller.trycloudflare.com --bootstrap-token-path <temporary-data-dir>/join-token
══════════════════════════════════════════════════════════════════
-Scan with the SAM app to enroll a device into used-encryption-assumptions-miller.trycloudflare.com
+Scan with the Agent Mesh app to enroll a device into used-encryption-assumptions-miller.trycloudflare.com
(single use, valid for 1h0m0s):
█████████████████████████████████████████████████████████
@@ -197,7 +197,7 @@ Scan with the SAM app to enroll a device into used-encryption-assumptions-miller
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
mesh://enroll?server=https%3A%2F%2Fused-encryption-assumptions-miller.trycloudflare.com&token=[redacted]
-Token ID: 2542ac5fa60e (revoke early with: sam-one token revoke 2542ac5fa60e)
+Token ID: 2542ac5fa60e (revoke early with: agentmesh-one token revoke 2542ac5fa60e)
```
{{< figure src="/images/sam-connect-join.png" alt="Join this mesh confirmation dialog showing a control plane hostname and Cancel and Join buttons" caption="After scanning, check the control plane hostname before tapping Join. This screenshot shows an example tunnel address and the app's shortened token hint; your values will differ." width="320" >}}
@@ -214,7 +214,7 @@ a fresh code in another terminal. Replace the example hostname with the
HTTPS API hostname from the server's banner:
```bash
-sam-one token qr --data-dir ~/sam-one \
+agentmesh-one token qr --data-dir ~/agentmesh-one \
--server https://YOUR-HOSTNAME.trycloudflare.com
```
@@ -247,14 +247,14 @@ or shows an error, record the status text before retrying.
**Node is Running** alone does not prove a mesh connection. Report a peer
count that remains zero, even if the app shows no error.
-{{< figure src="/images/sam-connect-running.png" alt="SAM Connect dashboard showing Node is Running, one connected peer, DHT size one, and a Node ID" caption="A connected node shows Node is Running, a Node ID, and at least one Connected Peer. Your Node ID and peer counts will differ from this example." width="320" >}}
+{{< figure src="/images/sam-connect-running.png" alt="Agent Mesh Connect dashboard showing Node is Running, one connected peer, DHT size one, and a Node ID" caption="A connected node shows Node is Running, a Node ID, and at least one Connected Peer. Your Node ID and peer counts will differ from this example." width="320" >}}
### 5. Check restart and reconnection
1. Tap **Stop**. Confirm **Node is Stopped**, then tap **Start** again.
Check that peers reconnect and **Node ID** is unchanged.
2. With the node running, lock the phone for one minute. Unlock it and
- return to SAM Connect. Check the running state and peer count. Record
+ return to Agent Mesh Connect. Check the running state and peer count. Record
any stop, crash, or failure to reconnect.
3. If mobile data is available, switch from Wi-Fi to mobile data while the
node is running, then switch back. Allow up to a minute after each
@@ -309,11 +309,11 @@ Use it only when the coordinator explicitly asks for a fresh-identity test.
| Symptom | What to check or report |
| --- | --- |
-| The testnet URL shows `404` in a browser | The root page is not a health check. Enter the URL in the app. Check the [testnet health workflow](https://github.com/google/sam/actions/workflows/testnet-health.yaml) for service incidents. |
+| The testnet URL shows `404` in a browser | The root page is not a health check. Enter the URL in the app. Check the [testnet health workflow](https://github.com/google/agentmesh/actions/workflows/testnet-health.yaml) for service incidents. |
| Login finishes but the app stays on enrollment | Return to the app on the same phone. Report the full status text and whether the browser showed the success message. |
-| No enrollment QR appears | Check that `sam-one` printed an HTTPS API URL and is running in an interactive terminal. You can generate a code with `sam-one token qr` using that HTTPS URL. |
-| A QR code or enrollment link is rejected | Confirm it is a SAM enrollment code from your operator and points to the expected HTTPS hostname. Request a fresh code if it expired or has already been used. |
-| Your own mesh is unreachable | Check that the computer is awake and `sam-one` and its tunnel are still running. Compare the recorded URL with the current banner. |
+| No enrollment QR appears | Check that `agentmesh-one` printed an HTTPS API URL and is running in an interactive terminal. You can generate a code with `agentmesh-one token qr` using that HTTPS URL. |
+| A QR code or enrollment link is rejected | Confirm it is a Agent Mesh enrollment code from your operator and points to the expected HTTPS hostname. Request a fresh code if it expired or has already been used. |
+| Your own mesh is unreachable | Check that the computer is awake and `agentmesh-one` and its tunnel are still running. Compare the recorded URL with the current banner. |
| `no good addresses` or `[::1]:53` | Report the app build and testnet. These were symptoms of the Android DNS bootstrap bug; confirm you installed the requested fixed build. |
| Enrollment is denied | Record the denial text and any configured labels. Do not paste a login token into the enrollment-token field. |
| Peers remain at zero or disappear after a network change | Report the network type, VPN/Private DNS state, and whether a manual stop/start recovers. |
@@ -327,9 +327,9 @@ status and the approximate time with time zone.
App version and build number:
Installation source or build link:
Phone model and Android version:
-Mesh (Bananas, Hub, or your own sam-one):
+Mesh (Bananas, Hub, or your own agentmesh-one):
Control plane URL:
-sam-one version and tunnel/proxy type (if applicable):
+agentmesh-one version and tunnel/proxy type (if applicable):
Date, time, and time zone:
Wi-Fi or mobile data; VPN/Private DNS enabled:
Fresh enrollment or upgrade with saved identity:
@@ -349,7 +349,7 @@ reports. You do not need to share the **Local API Token** for these tests.
## Configuration
-The Config tab holds what `sam-node.yaml` holds on a desktop: labels
+The Config tab holds what `agentmesh-node.yaml` holds on a desktop: labels
(comma-separated `key=value`) and the attenuation rules, policies and checks
(one Datalog statement per line, with the same syntax and the same errors as
the file). Labels are attested at enrollment, so changing them requires
@@ -385,15 +385,15 @@ further.
## How it is built
```text
-Flutter app (mobile/sam-node-app)
+Flutter app (mobile/agentmesh-node-app)
lib/main.dart the UI; talks to the node's local API over 127.0.0.1
lib/sam_ffi.dart Dart FFI wrapper
│ C calls
-Go FFI library (mobile/sam-node-ffi)
+Go FFI library (mobile/agentmesh-node-ffi)
StartNode, StopNode, EnrollNode, EnrollNodeBootstrap, ReEnrollNode,
UnenrollNode, IsEnrolled, GetNodeID, GetMeshInfo, CallRemoteTool, ...
│
-sam-node (internal/node), unchanged
+agentmesh-node (internal/node), unchanged
```
The FFI package is a thin export layer over the same node code that the CLI
@@ -415,15 +415,15 @@ For an edit-run loop on a device:
```bash
make mobile-ffi-android
-mkdir -p mobile/sam-node-app/android/app/src/main/jniLibs/arm64-v8a
-cp bin/android/libsam.so mobile/sam-node-app/android/app/src/main/jniLibs/arm64-v8a/
-cd mobile/sam-node-app && flutter run
+mkdir -p mobile/agentmesh-node-app/android/app/src/main/jniLibs/arm64-v8a
+cp bin/android/libsam.so mobile/agentmesh-node-app/android/app/src/main/jniLibs/arm64-v8a/
+cd mobile/agentmesh-node-app && flutter run
```
Release builds read signing material from `ANDROID_KEYSTORE_PATH`,
`ANDROID_KEYSTORE_PASSWORD`, `ANDROID_KEY_ALIAS` and `ANDROID_KEY_PASSWORD`,
and Firebase configuration from `GOOGLE_SERVICES_JSON` or its base64 form.
-`mobile/sam-node-app/README.md` covers the toolchain setup.
+`mobile/agentmesh-node-app/README.md` covers the toolchain setup.
## Testing
diff --git a/site/content/docs/preview/sandboxed-agents.md b/site/content/docs/preview/sandboxed-agents.md
index 4adeb0b9..9cfdf647 100644
--- a/site/content/docs/preview/sandboxed-agents.md
+++ b/site/content/docs/preview/sandboxed-agents.md
@@ -13,14 +13,14 @@ one safely, you need two things that work together:
1. **OS and network confinement**, provided by a dedicated sandbox runtime
(NVIDIA OpenShell, Kubernetes `agent-sandbox` with gVisor or Kata, or Docker
Sandbox `docker sbx`), so the process can only talk to the local gateway.
-2. **Task-scoped authorization and credential brokering**, provided by SAM
- (`sam-node` or `agentgateway` + `sam-node`), so the sandbox never holds a
+2. **Task-scoped authorization and credential brokering**, provided by Agent Mesh
+ (`agentmesh-node` or `agentgateway` + `agentmesh-node`), so the sandbox never holds a
standing cloud credential or ambient workload token and can only call the
services, MCP tools, HTTP paths, and cloud resources permitted for its
current task.
This page shows the four deployment blueprints for connecting sandboxed agents
-and multi-hop sub-agents to a SAM mesh.
+and multi-hop sub-agents to a Agent Mesh.
## Blueprint 1: NVIDIA OpenShell (zero credentials inside the sandbox)
@@ -35,32 +35,32 @@ flowchart LR
end
subgraph Host["Host / Orchestrator Boundary"]
OSProxy["OpenShell Egress Proxy<br/>& Secret Injector"]
- SamNode["Local sam-node Gateway"]
+ AgentMeshNode["Local agentmesh-node Gateway"]
end
- Mesh(["SAM Mesh & Cloud Egress"])
+ Mesh(["Agent Mesh Mesh & Cloud Egress"])
- Harness -- "Plain HTTP to sam-node:8080/mcp & /v1" --> OSProxy
- OSProxy -- "Injects X-Mesh-Authentication:<br/>Bearer <Sealed-Task-Biscuit>" --> SamNode
- SamNode -- "Verified Task Biscuit" --> Mesh
+ Harness -- "Plain HTTP to agentmesh-node:8080/mcp & /v1" --> OSProxy
+ OSProxy -- "Injects X-Mesh-Authentication:<br/>Bearer <Sealed-Task-Biscuit>" --> AgentMeshNode
+ AgentMeshNode -- "Verified Task Biscuit" --> Mesh
```
1. **Mint and seal a task token before starting the task:**
- The orchestrator calls `POST /oauth/token` on the local `sam-node` with a
+ The orchestrator calls `POST /oauth/token` on the local `agentmesh-node` with a
`TaskAuthorizationRule` (and `seal=true`), receiving a **sealed Task
Biscuit** scoped to the single task:
```bash
- TASK_TOKEN=$(curl -sS --unix-socket ~/.config/sam-mesh/sam.sock \
+ TASK_TOKEN=$(curl -sS --unix-socket ~/.config/agentmesh/agentmesh.sock \
http://localhost/oauth/token \
-d 'grant_type=urn:ietf:params:oauth:grant-type:token-exchange' \
-d 'subject_token_type=urn:agentmesh:params:oauth:token-type:biscuit' \
- -d "subject_token=$(jq -r .biscuit ~/.config/sam-mesh/credential.json 2>/dev/null || true)" \
+ -d "subject_token=$(jq -r .biscuit ~/.config/agentmesh/credential.json 2>/dev/null || true)" \
-d 'seal=true' \
--data-urlencode 'options={"name":"tasks/pr-review-42","rules":[{"allowed_services":["mcp://github","inference://*"],"operation":{"allowed_tools":["get_pull_request","list_PullRequest_files"]}}]}' \
| jq -r .access_token)
```
2. **Register the sealed token in OpenShell's proxy:**
Configure OpenShell's secret injector to attach
- `X-Mesh-Authentication: Bearer $TASK_TOKEN` on requests to `sam-node:8080`.
+ `X-Mesh-Authentication: Bearer $TASK_TOKEN` on requests to `agentmesh-node:8080`.
The sandboxed process has no credential in its environment variables or
filesystem.
@@ -68,39 +68,39 @@ flowchart LR
In `docker sbx` (local microVM) and Kubernetes `agent-sandbox`
(`RuntimeClass: gvisor` or `kata`) without an external header-injecting proxy,
-the sandbox container authenticates to `sam-node` using a task token passed as
+the sandbox container authenticates to `agentmesh-node` using a task token passed as
`OPENAI_API_KEY` / `Authorization: Bearer <token>` (for `/mcp` and `/v1/*`) or
-`X-Mesh-Authentication: Bearer <token>` (for `/sam/*` and `/egress/*`).
+`X-Mesh-Authentication: Bearer <token>` (for `/mesh/*` and `/egress/*`).
-### How SAM bounds the token held by the sandbox
+### How Agent Mesh bounds the token held by the sandbox
1. **Sealed leaf token (`Seal()`):** The orchestrator hands the sandbox a
sealed, task-attenuated Biscuit. The sandbox cannot append blocks or widen
its permissions.
2. **Channel binding (`client_peer_id`):** The Biscuit's authority block binds
- `client_peer_id` to the local or cluster `sam-node`'s `peer_id`. If a
+ `client_peer_id` to the local or cluster `agentmesh-node`'s `peer_id`. If a
prompt-injected agent exfiltrates the token to an external attacker, the
token is rejected by every other node in the mesh because the attacker
cannot authenticate over libp2p as that `peer_id`.
3. **Short TTL and explicit revocation on exit:** Scope the task's
`expire_time` to the expected task duration (for example, 15 minutes) and
- revoke it on `sam-node` (`POST /oauth/revoke`) as soon as the sandbox exits:
+ revoke it on `agentmesh-node` (`POST /oauth/revoke`) as soon as the sandbox exits:
```bash
- curl -sS --unix-socket ~/.config/sam-mesh/sam.sock \
+ curl -sS --unix-socket ~/.config/agentmesh/agentmesh.sock \
http://localhost/oauth/revoke \
-d "token=$TASK_TOKEN"
```
4. **Standard Kubernetes isolation (`RuntimeClass: gvisor` + `NetworkPolicy`):**
No `/dev/net/tun`, `CAP_NET_ADMIN`, or custom PID 1 wrapper is needed. The
sandbox pod runs unprivileged under `gvisor` or `kata`, and a standard
- Kubernetes `NetworkPolicy` restricts its egress to the cluster `sam-node`
+ Kubernetes `NetworkPolicy` restricts its egress to the cluster `agentmesh-node`
(or `agentgateway`) Service:
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
- name: sandbox-to-sam-node-only
+ name: sandbox-to-agentmesh-node-only
namespace: agents
spec:
podSelector:
@@ -111,10 +111,10 @@ spec:
- to:
- namespaceSelector:
matchLabels:
- kubernetes.io/metadata.name: sam-system
+ kubernetes.io/metadata.name: agentmesh-system
podSelector:
matchLabels:
- app: sam-node
+ app: agentmesh-node
ports:
- protocol: TCP
port: 8080
@@ -124,20 +124,20 @@ spec:
In clusters that already route agent traffic through **`agentgateway`**,
**Istio Ambient** (waypoints or sidecars), or **Envoy AI Gateway**, traffic
-continues to flow through those proxies while `sam-node` serves as the Policy
+continues to flow through those proxies while `agentmesh-node` serves as the Policy
Decision Point and Token Service:
- **Envoy `ext_authz` and `ext_proc` (on the local API listeners):**
Istio `AuthorizationPolicy (action: CUSTOM)` or `agentgateway` calls
- `sam-node` with the caller's Biscuit, or with a platform JWT that
- `sam-node` exchanges at the control plane into a delegated Biscuit.
- `sam-node` evaluates the standing Datalog policy and any
+ `agentmesh-node` with the caller's Biscuit, or with a platform JWT that
+ `agentmesh-node` exchanges at the control plane into a delegated Biscuit.
+ `agentmesh-node` evaluates the standing Datalog policy and any
`TaskAuthorizationRule` chain (including MCP tool names in JSON-RPC bodies
via `ext_proc`), and for `egress://` targets injects the brokered upstream
credential into `Authorization` before the gateway forwards the request.
- **RFC 8693 backend token exchange (`POST /oauth/token`):**
`agentgateway`'s built-in RFC 8693 token exchange policy can point directly
- at `http://sam-node:8080/oauth/token` to exchange workload JWTs or narrow
+ at `http://agentmesh-node:8080/oauth/token` to exchange workload JWTs or narrow
existing Biscuits per route.
## Blueprint 4: Multi-hop sub-agent delegation and cloud egress
@@ -145,7 +145,7 @@ Decision Point and Token Service:
When an agent delegates work to a sub-agent or calls a cloud API through an
egress node (`egress://bigquery.googleapis.com`), it attenuates its credential
offline in memory using the TypeScript or Python SDK (or `POST /oauth/token` on
-`sam-node`).
+`agentmesh-node`).
### Example: two-hop attenuation in Python
@@ -214,7 +214,7 @@ hop2_session = hop1_session.attenuate(
```typescript
import { create } from "@bufbuild/protobuf";
import { timestampFromDate } from "@bufbuild/protobuf/wkt";
-import { TaskAuthorizationRuleSchema } from "@sam-mesh/sdk/gen/agentmesh_pb.ts";
+import { TaskAuthorizationRuleSchema } from "@agentmesh-p2p/sdk/gen/agentmesh_pb.ts";
const hop1 = session.attenuate(
create(TaskAuthorizationRuleSchema, {
@@ -245,7 +245,7 @@ const leafSession = hop1
```
When `hop2_session` calls `egress://bigquery.googleapis.com`, the egress
-`sam-node` verifies the Control Plane signature, the standing policy, and the
+`agentmesh-node` verifies the Control Plane signature, the standing policy, and the
intersection of `TAR_1` and `TAR_2`, mints an ES256 border JWT at the control
plane (`POST /sts/token`), and exchanges it via `CloudTokenExchanger` for a
downscoped cloud token.
diff --git a/site/content/docs/preview/scale-experiment.md b/site/content/docs/preview/scale-experiment.md
index fc37114f..f4f47b08 100644
--- a/site/content/docs/preview/scale-experiment.md
+++ b/site/content/docs/preview/scale-experiment.md
@@ -13,17 +13,17 @@ supported product surface.
{{% /alert %}}
The report says what was measured and what it means. This page says how to
-run it again. The setup is one host, one `sam-node`, and *N* agents. Each
+run it again. The setup is one host, one `agentmesh-node`, and *N* agents. Each
agent is a Firecracker microVM with no network device, and its only way out
-is a vsock to its own `sam-box`. A thousand agents have been run on one
+is a vsock to its own `agentmesh-box`. A thousand agents have been run on one
`n2-standard-64`.
| Component | Role |
|---|---|
-| host VM | `n2-standard-64` on GCP with nested virtualisation; runs the node and one `sam-box` per agent |
+| host VM | `n2-standard-64` on GCP with nested virtualisation; runs the node and one `agentmesh-box` per agent |
| guest | Firecracker microVM, Alpine, about 160 MiB, no network device |
| `nano-init` | PID 1 in the guest: builds `tun0`, carries its own TCP stack, keeps the mesh name on every flow |
-| agent | the [example harness](https://github.com/google/sam/tree/main/development/examples/agent-harness), holding no credentials |
+| agent | the [example harness](https://github.com/google/agentmesh/tree/main/development/examples/agent-harness), holding no credentials |
## Prerequisites
@@ -31,7 +31,7 @@ is a vsock to its own `sam-box`. A thousand agents have been run on one
6.1 CI kernels do not have it. 6.18.41 does. `startup-script.sh` downloads
a TUN-capable kernel, and fails with a clear error instead of booting a
guest whose agent can never get a route.
-- A bootstrap token at `/etc/sam-bootstrap-token` on the host. The launcher
+- A bootstrap token at `/etc/agentmesh-bootstrap-token` on the host. The launcher
refuses to start without one.
- KVM, with `/dev/kvm` writable by the invoking user.
@@ -40,7 +40,7 @@ is a vsock to its own `sam-box`. A thousand agents have been run on one
Build once, locally, then upload:
```bash
-./scripts/build-rootfs.sh gs://my-sam-bucket/scale-test
+./scripts/build-rootfs.sh gs://my-agentmesh-bucket/scale-test
```
The image holds Alpine, Python, `nano-init` and the example harness as an
@@ -57,9 +57,9 @@ ROOTFS_MB=2048 AGENT_SRC=cmd/chaos-agent ./scripts/build-rootfs.sh
```bash
./scripts/provision-scale-vm.sh \
- --prefix sam-minions --count 1 \
+ --prefix agentmesh-minions --count 1 \
--machine-type n2-standard-64 \
- --local-binaries gs://my-sam-bucket/scale-test \
+ --local-binaries gs://my-agentmesh-bucket/scale-test \
--no-spot
```
@@ -86,15 +86,15 @@ speed, against a working set of about 206 MiB.
## 4. Launch
```bash
-gcloud compute ssh sam-minions-1 --zone us-central1-c
+gcloud compute ssh agentmesh-minions-1 --zone us-central1-c
sudo tests/scale/validate-launcher.sh # check that one works before asking for a thousand
sudo SANDBOX_LINGER=2400 /opt/microvm/launch-microvms.sh 1000
```
The launcher checks Firecracker, KVM, the kernel, the rootfs, the binaries
-and the token. It then starts one `sam-box` per agent and one microVM per
-`sam-box`, all against one node. The rootfs is shared read-only. A private
+and the token. It then starts one `agentmesh-box` per agent and one microVM per
+`agentmesh-box`, all against one node. The rootfs is shared read-only. A private
copy per agent would be half a terabyte at a thousand agents.
`SANDBOX_LINGER` keeps each sandbox open after its agent finishes. A density
@@ -107,7 +107,7 @@ for real work.
|---|---|
| `VM_MEM_MIB` | guest memory, default 160 |
| `SANDBOX_LINGER` | seconds to keep a sandbox after the agent exits, default 0 |
-| `SAM_MODEL` | model to ask the mesh for; when unset, the first model in the catalog is used |
+| `AGENTMESH_MODEL` | model to ask the mesh for; when unset, the first model in the catalog is used |
| `CONTROL_PLANE` | defaults to the `bananas` testnet |
| `AGENT_DOMAIN` | the domain under which agents are named |
@@ -119,14 +119,14 @@ rejects values that do.
```bash
sudo tests/scale/collect-fleet.sh \
- --node-socket /var/run/sam-node.sock --duration 1500 --out fleet.jsonl
+ --node-socket /var/run/agentmesh-node.sock --duration 1500 --out fleet.jsonl
```
The headline number is how many agents the *node* is serving, and not how
many microVMs were started. A guest that booted and never reached its
boundary is a process, not an agent. The script asks the node and samples
over time, because the shape of the curve shows whether the population came
-up smoothly. Watch `sam_node_agents_untracked_total`. If it is not zero, the
+up smoothly. Watch `agentmesh_node_agents_untracked_total`. If it is not zero, the
agent count is a lower bound and not a measurement.
## 6. Drive load
@@ -145,7 +145,7 @@ one boundary would measure a socket, not a mesh.
```bash
sudo tail -f /var/log/startup-script.log # host setup
sudo tail -f /var/log/fc-vm-1.log # one guest's console, agent output included
-sudo curl -s --unix-socket /var/run/sam-node.sock http://localhost/metrics | grep sam_node_agents_seen
+sudo curl -s --unix-socket /var/run/agentmesh-node.sock http://localhost/metrics | grep agentmesh_node_agents_seen
```
## The boundary sweep
@@ -170,7 +170,7 @@ it never issues the same request twice.
```bash
ROOTFS_MB=2048 AGENT_SRC=cmd/chaos-agent ./scripts/build-rootfs.sh
-sudo SAM_MODEL=google/gemma-2-2b-it CHAOS_SLEEP=30 VM_MEM_MIB=512 \
+sudo AGENTMESH_MODEL=google/gemma-2-2b-it CHAOS_SLEEP=30 VM_MEM_MIB=512 \
/opt/microvm/launch-microvms.sh 25
```
diff --git a/site/content/docs/preview/scale-report.md b/site/content/docs/preview/scale-report.md
index 46efa301..d157a63d 100644
--- a/site/content/docs/preview/scale-report.md
+++ b/site/content/docs/preview/scale-report.md
@@ -38,9 +38,9 @@ on one host.
One real mesh (control plane, router, node) on a kind cluster, as in the
end-to-end suite. Boundaries were attached to the node one at a time, as
host processes and not as containers, because the question is what
-`sam-box` costs. A container would measure the container runtime.
+`agentmesh-box` costs. A container would measure the container runtime.
-The load generator, `sam-bench`, issues the same request every time
+The load generator, `agentmesh-bench`, issues the same request every time
(`GET /v1/models`) and enters the mesh in the same way an agent does,
through the boundary's socket. Each step of the sweep was measured in four
conditions:
@@ -127,23 +127,23 @@ dialled.
## Experiment 2: a thousand agents on one host
-One `n2-standard-64`, one `sam-node` enrolled in the public `bananas`
+One `n2-standard-64`, one `agentmesh-node` enrolled in the public `bananas`
testnet, and a thousand agents. Each agent is a Firecracker microVM with no
-network device, and it reaches the mesh through its own `sam-box` over
+network device, and it reaches the mesh through its own `agentmesh-box` over
vsock. The agent is the example harness: connect, discover tools, attempt a
model call, stop. Raw samples are in
-[`tests/scale/results/fleet-1k`](https://github.com/google/sam/tree/main/tests/scale/results/fleet-1k).
+[`tests/scale/results/fleet-1k`](https://github.com/google/agentmesh/tree/main/tests/scale/results/fleet-1k).
### Cost
| | total | per agent |
|---|---|---|
| guest microVMs | 162.7 GiB | **167 MiB** |
-| boundaries (`sam-box`) | 24.6 GiB | **25 MiB** |
+| boundaries (`agentmesh-box`) | 24.6 GiB | **25 MiB** |
| node (one, for all) | 386 MiB | 0.4 MiB |
| **together** | **187 GiB of 251 GiB** | **192 MiB** |
-The node figure is the one that matters for the design. One `sam-node`
+The node figure is the one that matters for the design. One `agentmesh-node`
served a thousand distinct agent principals in 386 MB, because an agent is
not a peer. It has no enrollment, no key and no place in the DHT. The mesh
gained a thousand principals and no members.
@@ -164,7 +164,7 @@ as it was started:
Agents trail microVMs by a few seconds and never by more than about fifty.
That gap is a guest booting and resolving its first mesh name, and not a
-queue forming. `sam_node_agents_untracked_total` was 0, so the thousand is a
+queue forming. `agentmesh_node_agents_untracked_total` was 0, so the thousand is a
count and not a limit.
### Throughput
@@ -211,7 +211,7 @@ instead of sharing one.
Separately, one sandbox was booted and asked what the mesh would give it. The
sandbox was a microVM with no network device, no API key, no model endpoint
-and no tool server address. It had only `mesh.sam.alt` to ask.
+and no tool server address. It had only `mesh.alt` to ask.
| | |
|---|---|
@@ -273,10 +273,10 @@ short:
./tests/scale/run-density.sh --steps 1,2,4,8,16,32,64 --requests 500
# Experiment 2: a host with KVM, a TUN-capable guest kernel, a bootstrap token
-./scripts/provision-scale-vm.sh --no-spot --local-binaries gs://your-bucket/sam
+./scripts/provision-scale-vm.sh --no-spot --local-binaries gs://your-bucket/agentmesh
# then on the host
SANDBOX_LINGER=2400 /opt/microvm/launch-microvms.sh 1000
-/opt/microvm/collect-fleet.sh --node-socket /var/run/sam-node.sock --duration 1500
+/opt/microvm/collect-fleet.sh --node-socket /var/run/agentmesh-node.sock --duration 1500
```
Results land in `tests/scale/results/` with `environment.json`, the raw
@@ -284,10 +284,10 @@ observations and a rendered `table.md`. Single measurements by hand:
```bash
# through a boundary, as an agent would
-sam-bench run --socket /run/agent.sock --target http://mesh.sam.alt/v1/models \
+agentmesh-bench run --socket /run/agent.sock --target http://mesh.alt/v1/models \
--requests 500 --concurrency 4 --scrape http://127.0.0.1:9600/metrics
# the same request with no boundary, for the baseline
-sam-bench run --target-unix /run/node.sock --target http://localhost/v1/models \
+agentmesh-bench run --target-unix /run/node.sock --target http://localhost/v1/models \
--requests 500 --concurrency 4
```
diff --git a/site/content/docs/privacy.md b/site/content/docs/privacy.md
index f91da7fd..be94ded9 100644
--- a/site/content/docs/privacy.md
+++ b/site/content/docs/privacy.md
@@ -2,17 +2,17 @@
title: Privacy Policy
linkTitle: Privacy
weight: 900
-description: "Privacy policy and data transparency declaration for Agent Mesh (SAM) and SAM Connect."
+description: "Privacy policy and data transparency declaration for Agent Mesh and Agent Mesh Connect."
---
**Last Updated:** September 17, 2026
-This Privacy Policy explains how SAM Connect ("we", "us", or "our") collects, uses, and protects your information when you use our mobile application.
-SAM Connect is an open-source Agent Mesh (SAM) network client designed for zero-trust, peer-to-peer connectivity.
+This Privacy Policy explains how Agent Mesh Connect ("we", "us", or "our") collects, uses, and protects your information when you use our mobile application.
+Agent Mesh Connect is an open-source Agent Mesh network client designed for zero-trust, peer-to-peer connectivity.
## 1. Information We Collect
-To function as a background mesh network node, SAM Connect requests the following device permissions and data:
+To function as a background mesh network node, Agent Mesh Connect requests the following device permissions and data:
* **Location Data (Foreground and Background):** We request access to your device's precise and coarse location (`ACCESS_FINE_LOCATION`, `ACCESS_COARSE_LOCATION`, and `ACCESS_BACKGROUND_LOCATION`).
* **Network State:** We monitor your WiFi and network connections to maintain the mesh tunnel.
@@ -20,14 +20,14 @@ To function as a background mesh network node, SAM Connect requests the followin
## 2. How We Use Location Data
-Because SAM Connect operates as a continuous mesh network router, it requires **Background Location** access to maintain network stability, handle routing via the Model Context Protocol (MCP), and keep the foreground service alive even when the app is closed.
+Because Agent Mesh Connect operates as a continuous mesh network router, it requires **Background Location** access to maintain network stability, handle routing via the Model Context Protocol (MCP), and keep the foreground service alive even when the app is closed.
* **Ephemeral Processing:** Your location data is processed ephemerally in memory to facilitate real-time mesh routing.
* **No Server Storage:** We do not store your location history on any central servers, control planes, or databases.
## 3. Data Sharing and End-to-End Encryption
-SAM Connect does **not** sell, rent, or share your personal data with third-party data brokers, analytics companies, or advertising networks. The architecture contains no telemetry, tracking, or proprietary phone-home mechanisms.
+Agent Mesh Connect does **not** sell, rent, or share your personal data with third-party data brokers, analytics companies, or advertising networks. The architecture contains no telemetry, tracking, or proprietary phone-home mechanisms.
* **Within the Mesh:** Information necessary for routing (which may optionally include location data if configured by the user via MCP) is transmitted strictly to other authorized participants within your specific Agent Mesh network.
* **Encrypted in Transit:** All data transmitted across the mesh network is secured using end-to-end encryption. The centralized control plane cannot access or decrypt your local node traffic.
@@ -36,11 +36,11 @@ SAM Connect does **not** sell, rent, or share your personal data with third-part
Cryptographic keys and local identity tokens are stored strictly locally on your device. Because we do not store your personal data or location history on our servers, there is no centralized data to delete.
-You can instantly erase all app data, destroy your local node identity, and revoke access by uninstalling the SAM Connect application or clearing the app's local storage in your device settings.
+You can instantly erase all app data, destroy your local node identity, and revoke access by uninstalling the Agent Mesh Connect application or clearing the app's local storage in your device settings.
## 5. Contact Us
If you have any questions about this Privacy Policy, architecture, or how your data is handled, please contact us at:
-* **Project Website:** [https://sam-mesh.dev/](https://sam-mesh.dev/)
-* **GitHub Repository:** [https://github.com/google/sam](https://github.com/google/sam)
+* **Project Website:** [https://__PROTECT_Agent Mesh_MESH_DEV__/](https://__PROTECT_Agent Mesh_MESH_DEV__/)
+* **GitHub Repository:** [https://github.com/google/agentmesh](https://github.com/google/agentmesh)
diff --git a/site/content/docs/reference/sam-node.md b/site/content/docs/reference/agentmesh-node.md
similarity index 78%
rename from site/content/docs/reference/sam-node.md
rename to site/content/docs/reference/agentmesh-node.md
index a3fba857..105fcdcf 100644
--- a/site/content/docs/reference/sam-node.md
+++ b/site/content/docs/reference/agentmesh-node.md
@@ -1,35 +1,37 @@
---
-title: "sam-node"
-linkTitle: "sam-node"
+title: "agentmesh-node"
+linkTitle: "agentmesh-node"
+aliases:
+ - /docs/reference/sam-node/
weight: 1
---
-`sam-node` is the mesh member that runs beside an agent or a service.
+`agentmesh-node` is the mesh member that runs beside an agent or a service.
```text
-sam-node join [control-plane-url] [flags] enroll and store a credential
-sam-node run [flags] run the node
-sam-node forward egress://<name>:<port> [local-addr] forward a local TCP port to a named egress tunnel
-sam-node reset [--all] [--yes] forget the credential or everything
-sam-node state export|import <dir> move the identity to or from a state directory
-sam-node skill install|list|show manage the agent skill document
+agentmesh-node join [control-plane-url] [flags] enroll and store a credential
+agentmesh-node run [flags] run the node
+agentmesh-node forward egress://<name>:<port> [local-addr] forward a local TCP port to a named egress tunnel
+agentmesh-node reset [--all] [--yes] forget the credential or everything
+agentmesh-node state export|import <dir> move the identity to or from a state directory
+agentmesh-node skill install|list|show manage the agent skill document
```
## Files
-The data directory is `--data-dir` if set, otherwise `$SAM_DATA_DIR`,
+The data directory is `--data-dir` if set, otherwise `$AGENTMESH_DATA_DIR`,
otherwise the user configuration directory of the operating system
-(`~/.config/sam-mesh` on Linux, `~/Library/Application Support/sam-mesh` on
+(`~/.config/agentmesh` on Linux, `~/Library/Application Support/agentmesh` on
macOS). It is created with mode `0700` and holds:
| File | Contents |
|---|---|
| `agent.db` | The node's key and its `MemberCredential` (`api/agentmesh.proto`): biscuit, expiry, trusted control plane keys, router addresses, control plane URL and OIDC session. A running node holds a lock on this file. A second node started on the same directory refuses to start. A database written by an earlier release, which kept these as separate entries, is converted on first open. |
-| `sam.sock` | The local API Unix socket, mode `0600`, removed on exit. |
+| `agentmesh.sock` | The local API Unix socket, mode `0600`, removed on exit. |
| `api-token` | Generated by `--daemonize` when no token is configured. |
-| `sam-node.pid`, `sam-node.log` | Written by `--daemonize`. |
+| `agentmesh-node.pid`, `agentmesh-node.log` | Written by `--daemonize`. |
-The configuration file is `--config`, by default `sam-node.yaml` in the
+The configuration file is `--config`, by default `agentmesh-node.yaml` in the
working directory. A missing file is treated as an empty one. See
[node configuration](../node-config/).
@@ -41,7 +43,7 @@ Accepted by every subcommand.
|---|---|---|
| `--control-plane` | stored value | Control plane URL. `join` takes it as a positional argument. `https://` is required unless the host is loopback. |
| `--insecure-control-plane` | `false` | Accept a plaintext `http://` URL to a non-loopback host. Whoever answers that URL becomes the node's trust root. Intended for networks that are already trusted, such as a cluster. |
-| `--config` | `sam-node.yaml` | Node configuration file. |
+| `--config` | `agentmesh-node.yaml` | Node configuration file. |
| `--data-dir` | see above | Data directory. |
| `--audience` | `agentmesh-audience` | OIDC audience to request. |
| `--oidc-issuer` | from `/info` | Override the identity provider that the control plane advertises. |
@@ -66,7 +68,7 @@ bootstrap token, `join` runs an interactive OIDC login.
Labels declared in the configuration file are sent with the enrollment.
Running `join` for a node that already holds a credential for the same
control plane enrolls it again. For a different control plane, `join`
-refuses until `sam-node reset` has been run.
+refuses until `agentmesh-node reset` has been run.
## `run`
@@ -85,7 +87,7 @@ explains how to enroll.
| `--jwt` | | The token as a value. Logged as a warning. The file form is preferred. |
| `--cloud-provider` | | Cloud metadata provider for workload identity enrollment and refresh: `gcp` (GCE and Cloud Run metadata identity endpoint) or `auto` (probe GCE/Cloud Run metadata at startup). |
| `--bootstrap-token-path`, `--bootstrap-token` | | As for `join`. |
-| `--client-id`, `--client-secret-path` | | OAuth client-credentials grant against `--oidc-issuer`. The secret can also come from `SAM_CLIENT_SECRET`. |
+| `--client-id`, `--client-secret-path` | | OAuth client-credentials grant against `--oidc-issuer`. The secret can also come from `AGENTMESH_CLIENT_SECRET`. |
| `--offline-access` | `false` | With `--join`, as for `join`. |
| `--control-plane-public-key` | stored value | Control plane Ed25519 public key, 32 bytes in hex. Only needed when the store lacks it. |
@@ -94,8 +96,8 @@ explains how to enroll.
| Flag | Default | Meaning |
|---|---|---|
| `--bind-addr` | `127.0.0.1:8080` | TCP address for the local API. An empty value disables TCP. |
-| `--socket-path` | `<data-dir>/sam.sock` | Unix socket for the same API. An empty value disables it. At least one listener is required. |
-| `--api-token-path` | | File containing the bearer token for the TCP listener, or `SAM_API_TOKEN`. Required when TCP is enabled, unless mTLS is enabled. |
+| `--socket-path` | `<data-dir>/agentmesh.sock` | Unix socket for the same API. An empty value disables it. At least one listener is required. |
+| `--api-token-path` | | File containing the bearer token for the TCP listener, or `AGENTMESH_API_TOKEN`. Required when TCP is enabled, unless mTLS is enabled. |
| `--tls-cert`, `--tls-key` | | Serve the TCP listener over TLS. |
| `--tls-ca` | | Require client certificates signed by this CA (mTLS). Callers with a verified certificate need no token. |
| `--metrics-addr` | off | Serve `/metrics`, `/healthz` and `/readyz` without authentication on this address, for scrapers. Do not expose it on shared networks. |
@@ -116,7 +118,7 @@ explains how to enroll.
| `--dht-provider-addr-ttl` | `15m` | How long a service announcement lives after a node last made it. Nodes re-announce every 5 minutes, so a node that is gone drops out of discovery within this time. `0` keeps the default. |
| `--dht-max-record-age` | library default | DHT value record lifetime. |
| `--backend-probe-timeout` | `2s` | How long a service backend may take to answer before the node declines to advertise it. Raise it for subprocesses that start slowly. |
-| `--secrets-dir` | `/etc/sam/secrets` | Directory holding the credentials that the control plane's [egress destinations](../policy/#egress-destinations) name, one file per credential name. The platform puts the files there; the node reads a file on every request to the destination. |
+| `--secrets-dir` | `/etc/agentmesh/secrets` | Directory holding the credentials that the control plane's [egress destinations](../policy/#egress-destinations) name, one file per credential name. The platform puts the files there; the node reads a file on every request to the destination. |
| `--control-plane-sync-interval` | `15m` | How often signing keys, the ban set, router addresses and the mesh policy are pulled from the control plane. Keep it well below the control plane's `--key-grace-period`; raise it on large meshes. |
| `--key-grace-period` | `24h` | How long a rotated-out control plane key is still accepted for verifying peers. |
| `--monitor-bootstrap` | `2m` | Delay before the router-connection monitor starts. |
@@ -129,7 +131,7 @@ explains how to enroll.
| Flag | Meaning |
|---|---|
| (none) | Delete the credential and control plane binding. The key and peer ID stay. |
-| `--all` | Delete every file the node keeps: `agent.db`, `api-token`, `sam-node.pid`, `sam-node.log`. The node gets a new peer ID. Asks for confirmation. |
+| `--all` | Delete every file the node keeps: `agent.db`, `api-token`, `agentmesh-node.pid`, `agentmesh-node.log`. The node gets a new peer ID. Asks for confirmation. |
| `--yes` | Skip the confirmation, for scripts. |
Both variants refuse while a node has the store locked.
@@ -140,13 +142,13 @@ A state directory is how the [native SDKs](../../guides/native-sdks/) keep a
member: `identity.key`, the libp2p private key, and `credential.json`, the
`MemberCredential` message of `api/agentmesh.proto` as JSON with proto field names.
It is the same message `agent.db` holds, so a member moves between a
-`sam-node` and a program written with an SDK by copying files. Both
+`agentmesh-node` and a program written with an SDK by copying files. Both
subcommands refuse while a node has the store locked.
| Command | Meaning |
|---|---|
| `state export <dir>` | Write this node's key and credential to `<dir>`, creating it with mode `0700` and the files with mode `0600`. The files are the node's identity; whoever reads them is this member. |
-| `state import <dir>` | Replace this node's key and credential with the directory's. Refuses when the data directory already holds an identity unless `--yes` is passed. The next `sam-node run` resumes as that member; no token is needed. |
+| `state import <dir>` | Replace this node's key and credential with the directory's. Refuses when the data directory already holds an identity unless `--yes` is passed. The next `agentmesh-node run` resumes as that member; no token is needed. |
## `skill`
@@ -155,9 +157,9 @@ node.
| Command | Effect |
|---|---|
-| `skill install` | Write to `~/.claude/skills/sam-mesh/SKILL.md` and `~/.gemini/config/skills/sam-mesh/SKILL.md`. |
-| `skill install --project` | Write to `./.claude/skills/sam-mesh/` and `./.agents/skills/sam-mesh/` in the current directory. |
-| `skill install --dir DIR` | Write to `DIR/sam-mesh/SKILL.md`. |
+| `skill install` | Write to `~/.claude/skills/agentmesh/SKILL.md` and `~/.gemini/config/skills/agentmesh/SKILL.md`. |
+| `skill install --project` | Write to `./.claude/skills/agentmesh/` and `./.agents/skills/agentmesh/` in the current directory. |
+| `skill install --dir DIR` | Write to `DIR/agentmesh/SKILL.md`. |
| `skill list` | Show each install location and whether the copy matches this binary. |
| `skill show` | Print the document. |
@@ -165,9 +167,9 @@ node.
| Variable | Equivalent |
|---|---|
-| `SAM_API_TOKEN` | `--api-token-path` contents |
-| `SAM_CLIENT_SECRET` | `--client-secret-path` contents |
-| `SAM_DATA_DIR` | `--data-dir` |
+| `AGENTMESH_API_TOKEN` | `--api-token-path` contents |
+| `AGENTMESH_CLIENT_SECRET` | `--client-secret-path` contents |
+| `AGENTMESH_DATA_DIR` | `--data-dir` |
## Exit behaviour
diff --git a/site/content/docs/reference/sam-one.md b/site/content/docs/reference/agentmesh-one.md
similarity index 76%
rename from site/content/docs/reference/sam-one.md
rename to site/content/docs/reference/agentmesh-one.md
index 03beb851..dbe1b099 100644
--- a/site/content/docs/reference/sam-one.md
+++ b/site/content/docs/reference/agentmesh-one.md
@@ -1,23 +1,25 @@
---
-title: "sam-one"
-linkTitle: "sam-one"
+title: "agentmesh-one"
+linkTitle: "agentmesh-one"
+aliases:
+ - /docs/reference/sam-one/
weight: 4
---
-`sam-one` runs a control plane, a router and the web console in one process
+`agentmesh-one` runs a control plane, a router and the web console in one process
on one port. The router's libp2p transport is WebSocket on the same port as
the HTTP API, so a node needs only one `https` URL. The same binary is also
the admin client for a running instance.
```text
-sam-one [flags] run the mesh
-sam-one token create|list|revoke|qr manage bootstrap tokens on a running instance
-sam-one admin ban <peer-id> ban a node
+agentmesh-one [flags] run the mesh
+agentmesh-one token create|list|revoke|qr manage bootstrap tokens on a running instance
+agentmesh-one admin ban <peer-id> ban a node
```
## Files
-Everything lives in `--data-dir` (default `.`): `sam.db` (SQLite), the
+Everything lives in `--data-dir` (default `.`): `agentmesh.db` (SQLite), the
router key, `join-token` and `admin-token` when generated, and `bin/` for a
downloaded tunnel connector.
@@ -27,18 +29,18 @@ downloaded tunnel connector.
|---|---|---|
| `--bind-address` | `0.0.0.0` | Host to bind. |
| `--port` | `0` | TCP port. `0` picks a free one and prints it in the banner. |
-| `--external-url` | | Public URL on which nodes reach this instance, for a reverse proxy or a hosted platform. Can also be set with `SAM_EXTERNAL_URL`. When omitted behind an HTTPS proxy (Cloud Run, Fly.io, a forwarded Codespaces port), `/info` infers the advertised `wss` address from the incoming `Host` or `X-Forwarded-Host` and `X-Forwarded-Proto` headers automatically. |
+| `--external-url` | | Public URL on which nodes reach this instance, for a reverse proxy or a hosted platform. Can also be set with `AGENTMESH_EXTERNAL_URL`. When omitted behind an HTTPS proxy (Cloud Run, Fly.io, a forwarded Codespaces port), `/info` infers the advertised `wss` address from the incoming `Host` or `X-Forwarded-Host` and `X-Forwarded-Proto` headers automatically. |
| `--tunnel` | | Publish the port through a tunnel provider and use the resulting URL as the external URL. Providers: `cloudflare` (a free quick tunnel on `*.trycloudflare.com` by default, no account needed) and `codespaces` (the `https` URL GitHub Codespaces assigns to the forwarded port, read from `CODESPACE_NAME` and `GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN`; nothing is started, and the log reports whether the port answers from the internet). |
-| `--tunnel-token-path` | | File containing the tunnel provider authentication token (can also be set with `SAM_TUNNEL_TOKEN`). Use together with `--tunnel <provider> --external-url https://mesh.example.com` for a permanent custom domain. |
+| `--tunnel-token-path` | | File containing the tunnel provider authentication token (can also be set with `AGENTMESH_TUNNEL_TOKEN`). Use together with `--tunnel <provider> --external-url https://mesh.example.com` for a permanent custom domain. |
| `--tunnel-install` | `false` | Download the pinned, digest-verified `cloudflared` into `<data-dir>/bin` without asking. Implies acceptance of its license. |
| `--cloudflared-path` | `PATH`, then `<data-dir>/bin` | Explicit connector binary. |
| `--p2p-listen` | none | Extra native libp2p listen addresses, in addition to the WebSocket transport on the main port. |
-| `--data-dir` | `.` | See above. On stateless platforms where `router.key` is absent and `SAM_ADMIN_TOKEN` / `--admin-token-path` is supplied, `router.key` is derived deterministically so the router keeps its PeerID across restarts. |
+| `--data-dir` | `.` | See above. On stateless platforms where `router.key` is absent and `AGENTMESH_ADMIN_TOKEN` / `--admin-token-path` is supplied, `router.key` is derived deterministically so the router keeps its PeerID across restarts. |
| `--db-driver` | `sqlite` | `sqlite` or `postgres`. |
-| `--db-dsn` | `<data-dir>/sam.db` | Database DSN. |
-| `--token-path` | | File containing the standing join token. Can also be set with `SAM_TOKEN`. Generated and saved to the data directory when neither is set. |
+| `--db-dsn` | `<data-dir>/agentmesh.db` | Database DSN. |
+| `--token-path` | | File containing the standing join token. Can also be set with `AGENTMESH_TOKEN`. Generated and saved to the data directory when neither is set. |
| `--no-join-token` | `false` | Run without a standing join token. Devices can then enroll only with minted tokens or OIDC. |
-| `--admin-token-path` | | File containing the admin token. Can also be set with `SAM_ADMIN_TOKEN`. Generated and saved to the data directory when neither is set. |
+| `--admin-token-path` | | File containing the admin token. Can also be set with `AGENTMESH_ADMIN_TOKEN`. Generated and saved to the data directory when neither is set. |
| `--policy-file` | | Protojson `PolicyConfig` that seeds the mesh policy on first boot. Ignored once the database has a policy. Without it, first boot seeds an open development policy and logs a warning. |
| `--issuer` | | External OIDC issuer(s), comma-separated. Optional. Without an issuer, enrollment works by token only. |
| `--workload-issuer` | | Workload OIDC issuer(s), comma-separated (`<issuer>` or `<issuer>=<email-suffix>`). Automatically added to `--issuer` and refused at `/user/*` and `/oauth/authorize`. |
@@ -55,13 +57,13 @@ of zero leaves the default of that component unchanged.
| Flag | Corresponds to |
|---|---|
-| `--control-plane-lease-duration` | `sam-control-plane --lease-duration` |
+| `--control-plane-lease-duration` | `agentmesh-control-plane --lease-duration` |
| `--control-plane-key-rotation-interval` | `--key-rotation-interval` |
| `--control-plane-key-grace-period` | `--key-grace-period` |
| `--control-plane-biscuit-ttl` | `--biscuit-ttl` |
| `--control-plane-workload-session-ttl` | `--workload-session-ttl` |
| `--control-plane-manual-enrollment` | The opposite of `--auto-approve-enrollment`: queue bootstrap enrollments for approval. |
-| `--router-keys-sync-interval` | `sam-router --keys-sync-interval` |
+| `--router-keys-sync-interval` | `agentmesh-router --keys-sync-interval` |
| `--router-lease-renew-interval` | `--lease-renew-interval` |
| `--router-low-watermark`, `--router-high-watermark` | `--low-watermark`, `--high-watermark` |
| `--router-conns-per-source-ip` | `--conns-per-source-ip`. `0` follows the high watermark, because peers behind a proxy share source IPs. |
@@ -72,18 +74,18 @@ of zero leaves the default of that component unchanged.
## The banner
-On start, `sam-one` prints the API URL, the console URL, the router's peer
-ID, the admin and join tokens, and the `sam-node join` command to use.
+On start, `agentmesh-one` prints the API URL, the console URL, the router's peer
+ID, the admin and join tokens, and the `agentmesh-node join` command to use.
Tokens that the operator supplied (through a flag or the environment) are
shown as their source and not as their value, because stdout is often a log.
-Tokens that `sam-one` generated are shown in full, because the banner is
+Tokens that `agentmesh-one` generated are shown in full, because the banner is
where the operator learns them.
## The development policy
With no `--policy-file` and an empty database, first boot seeds three roles,
each with `allowed_services: ["*"]` and `allowed_targets: ["*"]`:
-`sam-admin`, `mesh:role:router`, and `mesh:role:node`, the last one also with
+`mesh-admin`, `mesh:role:router`, and `mesh:role:node`, the last one also with
`allowed_labels: ["*"]`. Any enrolled node can then call any service and
declare any label. Replace this policy before sharing the mesh with anyone.
@@ -94,7 +96,7 @@ The subcommands talk to a running instance over its HTTP API. Shared flags:
| Flag | Default | Meaning |
|---|---|---|
| `--server` | `http://127.0.0.1:8080` | Base URL of the instance. |
-| `--admin-token-path` | | File containing the admin token. Can also be set with `SAM_ADMIN_TOKEN`, or read from `--data-dir`. |
+| `--admin-token-path` | | File containing the admin token. Can also be set with `AGENTMESH_ADMIN_TOKEN`, or read from `--data-dir`. |
| `--data-dir` | `.` | Where to find the saved admin token. |
| Command | Flags | Effect |
@@ -114,9 +116,9 @@ The subcommands talk to a running instance over its HTTP API. Shared flags:
reach it. See the [Codespaces guide](../../guides/codespaces/).
- **A host with a name**: `--port 8080 --external-url https://mesh.example.com`
behind a reverse proxy that forwards WebSockets.
-- **Cloud Run**: pinned `SAM_TOKEN` and `SAM_ADMIN_TOKEN`, one instance, no
+- **Cloud Run**: pinned `AGENTMESH_TOKEN` and `AGENTMESH_ADMIN_TOKEN`, one instance, no
CPU throttling. See the [Cloud Run guide](../../guides/cloud-run/).
-`sam-one` is a single process by design. For more than one router, or for a
+`agentmesh-one` is a single process by design. For more than one router, or for a
control plane that scales horizontally, use the separate binaries or the
Helm chart.
diff --git a/site/content/docs/reference/control-plane.md b/site/content/docs/reference/control-plane.md
index b5e87c22..001e08bd 100644
--- a/site/content/docs/reference/control-plane.md
+++ b/site/content/docs/reference/control-plane.md
@@ -1,18 +1,18 @@
---
-title: "sam-control-plane"
-linkTitle: "sam-control-plane"
+title: "agentmesh-control-plane"
+linkTitle: "agentmesh-control-plane"
weight: 2
aliases:
- /docs/user/control-plane-configuration/
---
-`sam-control-plane` admits nodes, mints credentials, holds the mesh policy
+`agentmesh-control-plane` admits nodes, mints credentials, holds the mesh policy
and tracks routers. It is an HTTP server over SQLite or PostgreSQL.
```text
-sam-control-plane [flags] run the server
-sam-control-plane admin ban --peer <id> ban a node directly in the database
-sam-control-plane admin unban --peer <id> lift a ban
+agentmesh-control-plane [flags] run the server
+agentmesh-control-plane admin ban --peer <id> ban a node directly in the database
+agentmesh-control-plane admin unban --peer <id> lift a ban
```
## Flags
@@ -27,14 +27,14 @@ sam-control-plane admin unban --peer <id> lift a ban
| `--bind-address` | `0.0.0.0:8080` | HTTP listen address. |
| `--db-driver` | `sqlite` | `sqlite` or `postgres`. |
| `--db-dsn` | `control-plane.db` | Database DSN. A PostgreSQL DSN contains a password, so the next two options are preferred for PostgreSQL. |
-| `--db-dsn-path` | | File containing the DSN. Overrides `--db-dsn`. Can also be set with `SAM_DB_DSN`. |
-| `--admin-token-path` | | File containing the bearer token for `/admin/*` and `POST /policies`. Can also be set with `SAM_ADMIN_TOKEN`. Without a token, the admin API cannot be used. |
+| `--db-dsn-path` | | File containing the DSN. Overrides `--db-dsn`. Can also be set with `AGENTMESH_DB_DSN`. |
+| `--admin-token-path` | | File containing the bearer token for `/admin/*` and `POST /policies`. Can also be set with `AGENTMESH_ADMIN_TOKEN`. Without a token, the admin API cannot be used. |
| `--auto-approve-enrollment` | `false` | Issue credentials for valid bootstrap-token enrollments immediately instead of queueing them for approval. |
| `--biscuit-ttl` | `24h` | Lifetime of each credential. If the OIDC token expires sooner, the credential expires with it. |
| `--oidc-session-ttl` | `2160h` (90 days) | How long a human OIDC enrollment may keep refreshing before the identity must log in again. |
| `--workload-session-ttl` | `48h` | How long a workload OIDC enrollment (`--workload-issuer`) may refresh without presenting a fresh platform JWT in `TokenRefreshRequest.jwt`. |
| `--key-rotation-interval` | `24h` | How often a new signing key is generated. `0` disables rotation. |
-| `--key-grace-period` | `1h` | How long a rotated-out key stays accepted. Credentials signed by a retired key cannot be verified or refreshed. Nodes and routers must pull `/keys` well within this window (`sam-node --control-plane-sync-interval`, `sam-router --keys-sync-interval`). |
+| `--key-grace-period` | `1h` | How long a rotated-out key stays accepted. Credentials signed by a retired key cannot be verified or refreshed. Nodes and routers must pull `/keys` well within this window (`agentmesh-node --control-plane-sync-interval`, `agentmesh-router --keys-sync-interval`). |
| `--lease-duration` | `15m` | How long a router lease lasts without renewal. |
| `--node-retention` | `720h` (30 days) | How long the record of an enrolled node is kept after its session expires. Banned nodes are kept forever. `0` keeps every record. |
| `--mesh-reconnect-interval` | `30s` | How often the event publisher re-reads the router leases and dials any router it is not connected to. |
@@ -67,7 +67,7 @@ Responses that carry credentials are sent with `Cache-Control: no-store`.
### Enrollment, refresh, and STS
Every request below carries a `challenge_unix_ms` and a `challenge_signature`.
-The enrollee signs `sam:<endpoint>:<peer_id>:<challenge_unix_ms>` with its
+The enrollee signs `mesh:<endpoint>:<peer_id>:<challenge_unix_ms>` with its
key, and the control plane accepts the signature within five minutes of that
instant. This proves that the caller holds the key behind the peer ID it
names. Every instant in a response (`expire_time` and the like) is a
@@ -80,7 +80,7 @@ names. Every instant in a response (`expire_time` and the like) is a
| `GET /enroll/status?peer_id=` | headers `X-Mesh-Challenge-Ts`, `X-Mesh-Challenge-Sig` | Poll a pending enrollment. Any authentication failure answers `401`, so the credential is released only to the enrollee. |
| `POST /refresh` | `TokenRefreshRequest` (optional `jwt`), current credential as `Authorization: Bearer <base64>` | Exchange a credential for a new one. When `jwt` is present and its `iss|sub` matches the enrolled node record, re-attests the node in place, updates stored claims and extends the session. Refuses a replayed (superseded) credential, a banned node, an expired session without a matching `jwt`, and a credential signed by a retired key unless the node has `autonomous_recovery`. |
| `POST /token/exchange` | `TokenExchangeRequest` (`subject_token`, optional `task_rule` and `seal`, challenge signature), node credential as bearer | Stateless JWT-to-Biscuit exchange. Mints a Delegated Session Biscuit bound to the calling node (`actor_node`, `client_peer_id`) with zero database writes. |
-| `POST /sts/token` | `STSTokenRequest` (`biscuit`, `destination`, optional `audience`, challenge signature), node credential as bearer | Stateless Biscuit-to-JWT minting. Verifies the Biscuit and `tar_block` chain against `egress://<destination>` and mints a short-lived ES256 border JWT (`sub`, `act.sub`, `aud`, `sam_roles`, `sam_task`). |
+| `POST /sts/token` | `STSTokenRequest` (`biscuit`, `destination`, optional `audience`, challenge signature), node credential as bearer | Stateless Biscuit-to-JWT minting. Verifies the Biscuit and `tar_block` chain against `egress://<destination>` and mints a short-lived ES256 border JWT (`sub`, `act.sub`, `aud`, `mesh_roles`, `mesh_task`). |
| `GET /revocations` | credential as `Authorization: Bearer <base64>` | `RevocationsResponse`: revoked root Biscuit revocation IDs (`revocation_ids`) and banned peer IDs (`banned_peer_ids`). |
| `POST /routers/lease` | `RouterLeaseRequest` (credential, addresses, telemetry) | Register or renew a router lease. Requires `role("mesh:role:router")`. Announced addresses must end in the router's own peer ID. |
| `GET /policies` | credential as `Authorization: Bearer <base64>` | The mesh policy as `PolicyConfigGetResponse`: the Datalog rules a member adds to its authorizer, one per entry. Operators read the document at `GET /admin/policy`. |
@@ -141,6 +141,6 @@ with `403`). The console uses these routes.
## Metrics
-`/metrics` exposes `sam_control_plane_*` counters and gauges: enrolled nodes
+`/metrics` exposes `agentmesh_control_plane_*` counters and gauges: enrolled nodes
by role and state, active routers, mesh-connected peers as reported by
router leases, per-route request counts and latencies, and the Go runtime.
diff --git a/site/content/docs/reference/node-api.md b/site/content/docs/reference/node-api.md
index 8d7aad03..006ccdb7 100644
--- a/site/content/docs/reference/node-api.md
+++ b/site/content/docs/reference/node-api.md
@@ -6,10 +6,10 @@ aliases:
- /docs/development/testnet-validation/
---
-The local API that `sam-node run` serves to agents, gateways, and scripts on
+The local API that `agentmesh-node run` serves to agents, gateways, and scripts on
the same machine or cluster. It is available on TCP (`--bind-addr`, default
`127.0.0.1:8080`) and on a Unix socket (`--socket-path`, default
-`<data-dir>/sam.sock`). The Envoy `ext_authz` and `ext_proc` endpoints are
+`<data-dir>/agentmesh.sock`). The Envoy `ext_authz` and `ext_proc` endpoints are
served on the same listeners.
## Authentication
@@ -17,26 +17,26 @@ served on the same listeners.
| Listener | Requirement |
|---|---|
| TCP (`--bind-addr`) | `X-Mesh-Authentication: Bearer <token>` on every request, or `Authorization: Bearer <token>` on non-proxy endpoints (`/mcp`, `/v1/*`, `/egress/*`, `/oauth/*`), or a client certificate when `--tls-ca` is set. |
-| Unix socket (`--socket-path`) | None required for node-level access (the socket has mode `0600`). A caller may still pass a SAM Task Biscuit or platform JWT in `X-Mesh-Authentication` or `Authorization` to scope the request to that caller's identity and task rules. |
+| Unix socket (`--socket-path`) | None required for node-level access (the socket has mode `0600`). A caller may still pass a Agent Mesh Task Biscuit or platform JWT in `X-Mesh-Authentication` or `Authorization` to scope the request to that caller's identity and task rules. |
-The bearer `<token>` accepted by `sam-node` can be:
+The bearer `<token>` accepted by `agentmesh-node` can be:
-1. **The node's static API token** (`--api-token-path` or `SAM_API_TOKEN`),
+1. **The node's static API token** (`--api-token-path` or `AGENTMESH_API_TOKEN`),
which exercises the node's own enrolled credential.
-2. **A SAM Biscuit** (a Member Biscuit, a Delegated Session Biscuit, or a
+2. **A Agent Mesh Biscuit** (a Member Biscuit, a Delegated Session Biscuit, or a
task-attenuated Biscuit with `tar_block` blocks), base64-encoded.
3. **An external platform JWT** (an OIDC ID token, Kubernetes projected service
- account token, or SPIFFE JWT-SVID). On `/mcp`, `/v1/*`, `/sam/*` (via
- `X-Mesh-Authentication`), and `/egress/*`, `sam-node` exchanges the JWT via
+ account token, or SPIFFE JWT-SVID). On `/mcp`, `/v1/*`, `/mesh/*` (via
+ `X-Mesh-Authentication`), and `/egress/*`, `agentmesh-node` exchanges the JWT via
the control plane's stateless `POST /token/exchange` endpoint (cached until
expiry) and forwards the resulting Delegated Session Biscuit.
On `/mesh/{peer-id}/{type}/{name}/...`, the `Authorization` header is reserved
exclusively for the destination service's own credential and passes through
-untouched; callers of `/sam/...` pass their SAM token or platform JWT in
+untouched; callers of `/mesh/...` pass their Agent Mesh token or platform JWT in
`X-Mesh-Authentication: Bearer <token>`.
-When a request on TCP fails authentication with `401 Unauthorized`, `sam-node`
+When a request on TCP fails authentication with `401 Unauthorized`, `agentmesh-node`
includes `WWW-Authenticate: Bearer resource_metadata="http://<host>/.well-known/oauth-protected-resource"`
per RFC 9728 so standard MCP OAuth 2.1 clients can discover the control plane
Authorization Server.
@@ -46,10 +46,10 @@ Authorization Server.
| Route | Auth | Purpose |
|---|---|---|
| `GET /healthz`, `GET /readyz` | none | `200` while the process is up. Every other route except `/debug/*` and `/.well-known/*` answers `503` until the node is connected to the mesh. |
-| `GET /.well-known/oauth-protected-resource` | none | RFC 9728 OAuth 2.1 Protected Resource Metadata naming the SAM control plane in `authorization_servers`. |
+| `GET /.well-known/oauth-protected-resource` | none | RFC 9728 OAuth 2.1 Protected Resource Metadata naming the Agent Mesh control plane in `authorization_servers`. |
| `POST /oauth/token` | token | RFC 8693 Token Exchange: exchanges a platform JWT or Biscuit into a Delegated or Task-Attenuated Biscuit. See [Token exchange (`/oauth/token`)](#token-exchange-oauthtoken). |
| `POST /oauth/revoke` | token | RFC 7009 Token Revocation: revokes a task Biscuit in this node's local revocation cache. |
-| `GET /metrics` | token | Prometheus metrics (`sam_node_*`). |
+| `GET /metrics` | token | Prometheus metrics (`agentmesh_node_*`). |
| `POST /mcp` | token | The MCP server (Streamable HTTP, sessionless: no `Mcp-Session-Id`, `GET` answers `405`). `/` is an alias. |
| `GET /v1/models` | token | Models served by every reachable inference provider. |
| `POST /v1/chat/completions`, `POST /v1/completions` | token | OpenAI-compatible inference, routed to a provider of the requested model. |
@@ -85,7 +85,7 @@ revocation ID in the node's local revocation cache until the token expires.
## Envoy `ext_authz` and `ext_proc` gateway integration
-On the local API listeners, `sam-node` serves:
+On the local API listeners, `agentmesh-node` serves:
- **Envoy HTTP `ext_authz` (`/ext_authz`, `/ext_authz/*`)** and **gRPC
`envoy.service.auth.v3.Authorization/Check`**: evaluates standing Datalog
@@ -173,7 +173,7 @@ Returns `description`, `input_schema` and `output_schema`.
| `required_labels` | `key=value[,key=value]`. The call is refused unless the peer's credential attests every one of them. |
Returns the tool's result content. If the caller authenticated with a
-Delegated or Task-Attenuated Biscuit, `sam-node` forwards that Biscuit on the
+Delegated or Task-Attenuated Biscuit, `agentmesh-node` forwards that Biscuit on the
mesh stream so the provider enforces the caller's roles and `tar_block` tool
restrictions. A policy denial comes back as a tool error that the caller can
read, not as a transport failure.
@@ -182,7 +182,7 @@ read, not as a transport failure.
A node that starts without a credential and without a way to enroll serves
a reduced MCP server with one tool, `get_login_instructions`, and one
-prompt, `help_user_login`. Both tell the client to run `sam-node join`.
+prompt, `help_user_login`. Both tell the client to run `agentmesh-node join`.
## Service discovery over HTTP
@@ -217,7 +217,7 @@ and `.well-known/agent-card.json` is rewritten for the mesh.
An MCP session with a remote service, without using the node's own tools:
```bash
-SOCK=~/.config/sam-mesh/sam.sock
+SOCK=~/.config/agentmesh/agentmesh.sock
URL=http://localhost/mesh/<peer-id>/mcp/everything
# initialize; the Mcp-Session-Id response header identifies the session
@@ -307,7 +307,7 @@ control plane assigned to this node (an entry of the
curl -s --unix-socket $SOCK "http://localhost/egress/api.github.com/repos/acme/dubbing/pulls?state=open"
```
-`403` is a policy or inspection decision (`Proxy-Status: sam-node; error=http_request_denied`).
+`403` is a policy or inspection decision (`Proxy-Status: agentmesh-node; error=http_request_denied`).
`404` is a destination the control plane did not assign to this node
(`error=destination_not_found`). A destination whose broker cannot obtain a
credential answers `502` with `error=proxy_configuration_error`. The same
@@ -315,16 +315,16 @@ destination is reachable from another mesh member at
`/mesh/<peer-id>/egress/<destination>/<path>` on that member's node, authorized
on the caller's Biscuit.
-### Named TCP tunnels (`CONNECT` and `sam-node forward`)
+### Named TCP tunnels (`CONNECT` and `agentmesh-node forward`)
For destinations with `mode: EGRESS_MODE_TCP` and an allowed `ports` list, the
node accepts HTTP `CONNECT <destination>:<port>` on its local listener and
verifies that the TLS `ClientHello` SNI matches `<destination>` (and does not
use Encrypted Client Hello) before splicing the stream to the remote egress
-node. Clients that do not speak `CONNECT` can use `sam-node forward`:
+node. Clients that do not speak `CONNECT` can use `agentmesh-node forward`:
```bash
-sam-node forward egress://pg.internal.example:5432 127.0.0.1:15432
+agentmesh-node forward egress://pg.internal.example:5432 127.0.0.1:15432
```
## Identity evidence
@@ -341,5 +341,5 @@ material is meant for the node's owner and for auditors, not for agents.
`GET /debug/mesh-info`, `GET /debug/connectivity`, `GET /debug/network-info`,
`GET /debug/token-info`, `GET /debug/logs` and `POST /debug/connect-peer`
report and probe the node's view of the mesh for troubleshooting, and answer
-even while the mesh is unreachable. `sam-node debug` on the command line
+even while the mesh is unreachable. `agentmesh-node debug` on the command line
wraps them. Their output is not stable across releases.
diff --git a/site/content/docs/reference/node-config.md b/site/content/docs/reference/node-config.md
index aa4ddf56..f22fb329 100644
--- a/site/content/docs/reference/node-config.md
+++ b/site/content/docs/reference/node-config.md
@@ -6,10 +6,10 @@ aliases:
- /docs/user/node-configuration/
---
-`sam-node.yaml` declares what a node is (labels), what it publishes
+`agentmesh-node.yaml` declares what a node is (labels), what it publishes
(services), what it requires from callers (attenuation) and what it requires
-from providers (egress). Both `sam-node join` and `sam-node run` read it from
-`--config`, by default `./sam-node.yaml`. A missing file means an empty
+from providers (egress). Both `agentmesh-node join` and `agentmesh-node run` read it from
+`--config`, by default `./agentmesh-node.yaml`. A missing file means an empty
configuration. Unknown keys are an error, because a typo under `attenuation`
would otherwise weaken the node without notice.
@@ -33,7 +33,7 @@ services:
- type: inference
name: vllm
target_url: "http://127.0.0.1:8000"
- target_auth_path: /etc/sam/vllm-key
+ target_auth_path: /etc/agentmesh/vllm-key
- type: a2a
name: triage
target_url: "http://127.0.0.1:9999"
@@ -154,6 +154,6 @@ floor.
## Kubernetes
-The `sam-node` Helm chart renders its `config:` value as this file and
+The `agentmesh-node` Helm chart renders its `config:` value as this file and
restarts the pod when it changes. Because the backend runs in the same pod,
`target_url` there is always `http://127.0.0.1:<port>`.
diff --git a/site/content/docs/reference/policy.md b/site/content/docs/reference/policy.md
index 2bb3526f..63e662e0 100644
--- a/site/content/docs/reference/policy.md
+++ b/site/content/docs/reference/policy.md
@@ -10,7 +10,7 @@ The mesh policy is one document held by the control plane: a list of roles,
a list of bindings and a list of egress destinations. It is posted as JSON
(protojson of `PolicyConfig` in `api/agentmesh.proto`) to `POST /policies`, read
back from `GET /admin/policy`, edited in the console, or given to
-`sam-one --policy-file` for first boot.
+`agentmesh-one --policy-file` for first boot.
```json
{
@@ -36,7 +36,7 @@ back from `GET /admin/policy`, edited in the console, or given to
}
],
"bindings": [
- { "role": "mesh:role:node", "members": ["group:engineering", "user:system:serviceaccount:sam-nodes:calc-mcp-sam-node"] },
+ { "role": "mesh:role:node", "members": ["group:engineering", "user:system:serviceaccount:agentmesh-nodes:calc-mcp-agentmesh-node"] },
{ "role": "developer", "members": ["group:engineering"] },
{ "role": "analyst", "members": ["group:analytics"] }
],
@@ -47,7 +47,7 @@ back from `GET /admin/policy`, edited in the console, or given to
"broker": {
"oidc_federation": {
"token_endpoint": "https://sts.googleapis.com/v1/token",
- "audience": "//iam.googleapis.com/projects/123/locations/global/workloadIdentityPools/sam/providers/sam-cp",
+ "audience": "//iam.googleapis.com/projects/123/locations/global/workloadIdentityPools/agentmesh/providers/agentmesh-cp",
"scopes": ["https://www.googleapis.com/auth/bigquery.readonly"]
}
}
@@ -193,7 +193,7 @@ a single trailing `*` (prefix match, compiled to `$v.starts_with("<prefix>")`)
or a single leading `*` (suffix match, compiled to `$v.ends_with("<suffix>")`),
for example:
-- `user:system:serviceaccount:sam-nodes:*`
+- `user:system:serviceaccount:agentmesh-nodes:*`
- `user:spiffe://acme.example/ns/prod/*`
- `email:*@my-project.iam.gserviceaccount.com`
@@ -214,7 +214,7 @@ An entry of `egress` is a destination outside the mesh that selected nodes
serve as `egress://<name>`. The admin writes it once; each selected node
receives it at `GET /egress`, registers the service, announces it on the DHT
and forwards requests to it. Nodes hold no egress configuration of their
-own, and `type: egress` in `sam-node.yaml` is refused.
+own, and `type: egress` in `agentmesh-node.yaml` is refused.
| Field | Meaning |
|---|---|
@@ -234,7 +234,7 @@ own, and `type: egress` in `sam-node.yaml` is refused.
None of the fields in `broker` is a secret value:
- **`static_secret`** (`string`): name of a file in the node's `--secrets-dir`
- (default `/etc/sam/secrets`). `TOKEN` is sent as `Authorization: Bearer TOKEN`,
+ (default `/etc/agentmesh/secrets`). `TOKEN` is sent as `Authorization: Bearer TOKEN`,
`user:pass` as HTTP Basic. Read on every request so file rotations apply
immediately.
- **`oidc_federation`** (`OIDCFederation`): mints a short-lived ES256 border
@@ -336,7 +336,7 @@ At the destination node, in this order:
## Datalog vocabulary
-Every fact name used by SAM, for writing `custom_datalog` or `attenuation`
+Every fact name used by Agent Mesh, for writing `custom_datalog` or `attenuation`
statements.
| Fact | Terms | Minted by |
diff --git a/site/content/docs/reference/router.md b/site/content/docs/reference/router.md
index 87524a07..39672d87 100644
--- a/site/content/docs/reference/router.md
+++ b/site/content/docs/reference/router.md
@@ -1,16 +1,16 @@
---
-title: "sam-router"
-linkTitle: "sam-router"
+title: "agentmesh-router"
+linkTitle: "agentmesh-router"
weight: 3
---
-`sam-router` is a libp2p peer with a stable identity that new nodes connect
+`agentmesh-router` is a libp2p peer with a stable identity that new nodes connect
to first. It hosts the DHT, relays traffic between nodes that cannot reach
each other, and forwards the control plane's signed events. It has no policy
of its own.
```text
-sam-router [flags]
+agentmesh-router [flags]
```
## Enrollment
@@ -24,7 +24,7 @@ A router enrolls like a node, requesting `mesh:role:router`, with one of:
| `--oidc-token`, `--bootstrap-token` | The same tokens as values. Visible in process listings. The file forms are preferred. |
The mesh policy must bind the router's identity to `mesh:role:router`. The
-`sam-mesh` Helm chart handles this: its bootstrap job binds the router's
+`agentmesh-p2p` Helm chart handles this: its bootstrap job binds the router's
service account and mints a bootstrap token with `max_usages` equal to the
replica count.
@@ -80,20 +80,20 @@ The metrics address exposes, next to the Go runtime metrics:
| Metric | Meaning |
|---|---|
-| `sam_router_ready` | `1` once the router is enrolled and the host is up. |
-| `sam_router_draining` | `1` from the moment the router starts stopping until the process exits. |
-| `sam_router_connections{direction}` | Open connections, `inbound` and `outbound`. |
-| `sam_router_connection_watermark{level}` | The `low` and `high` watermarks in force. The gap between `inbound` connections and the `high` watermark is the free capacity. |
-| `sam_router_conns_per_source_ip_limit` | The per-address cap in force. |
-| `sam_router_relay_limit{limit}` | The relay budget in force: `reservations`, `reservations_per_ip` and `circuits_per_peer`. |
-| `sam_router_connected_peers`, `sam_router_authenticated_peers`, `sam_router_banned_peers` | Peers in each state. |
-| `sam_router_dht_routing_table_size` | DHT routing table size. |
-| `sam_router_auth_handshakes_total{result}`, `sam_router_lease_renewals_total{result}` | Handshakes and lease renewals by outcome. |
-| `sam_router_inbound_connections_refused_total` | Inbound connections refused by the per-address cap. |
-| `libp2p_relaysvc_*` | The relay service's own counters: `reservations_total{type}` and `connections_total{type}` (`opened`, `closed`, `renewed`), requests by response status, rejections and bytes relayed. The difference between `opened` and `closed` is the number in use; read it against `sam_router_relay_limit` to see how close the relay is to its budget. |
+| `agentmesh_router_ready` | `1` once the router is enrolled and the host is up. |
+| `agentmesh_router_draining` | `1` from the moment the router starts stopping until the process exits. |
+| `agentmesh_router_connections{direction}` | Open connections, `inbound` and `outbound`. |
+| `agentmesh_router_connection_watermark{level}` | The `low` and `high` watermarks in force. The gap between `inbound` connections and the `high` watermark is the free capacity. |
+| `agentmesh_router_conns_per_source_ip_limit` | The per-address cap in force. |
+| `agentmesh_router_relay_limit{limit}` | The relay budget in force: `reservations`, `reservations_per_ip` and `circuits_per_peer`. |
+| `agentmesh_router_connected_peers`, `agentmesh_router_authenticated_peers`, `agentmesh_router_banned_peers` | Peers in each state. |
+| `agentmesh_router_dht_routing_table_size` | DHT routing table size. |
+| `agentmesh_router_auth_handshakes_total{result}`, `agentmesh_router_lease_renewals_total{result}` | Handshakes and lease renewals by outcome. |
+| `agentmesh_router_inbound_connections_refused_total` | Inbound connections refused by the per-address cap. |
+| `libp2p_relaysvc_*` | The relay service's own counters: `reservations_total{type}` and `connections_total{type}` (`opened`, `closed`, `renewed`), requests by response status, rejections and bytes relayed. The difference between `opened` and `closed` is the number in use; read it against `agentmesh_router_relay_limit` to see how close the relay is to its budget. |
-A fleet is at capacity when `sam_router_connections{direction="inbound"}`
+A fleet is at capacity when `agentmesh_router_connections{direction="inbound"}`
approaches the `high` watermark or open relay reservations approach
-`sam_router_relay_limit{limit="reservations"}` on every router that is not
+`agentmesh_router_relay_limit{limit="reservations"}` on every router that is not
draining; both are the inputs for an autoscaler. `/healthz` and `/readyz`
on the same address are the probes to use in a pod spec.
diff --git a/site/content/docs/snippets/agent_demo.py b/site/content/docs/snippets/agent_demo.py
index 82dc6040..2a4fb5b5 100644
--- a/site/content/docs/snippets/agent_demo.py
+++ b/site/content/docs/snippets/agent_demo.py
@@ -9,9 +9,9 @@ from mcp.client.streamable_http import streamable_http_client
async def main():
# Connect to the local Agent Mesh node's MCP endpoint.
- # By default, sam-node listens at 127.0.0.1:8080.
- url = os.environ.get("SAM_MCP_URL", "http://127.0.0.1:8080/mcp")
- token = os.environ.get("SAM_API_TOKEN", "")
+ # By default, agentmesh-node listens at 127.0.0.1:8080.
+ url = os.environ.get("AGENTMESH_MCP_URL", "http://127.0.0.1:8080/mcp")
+ token = os.environ.get("AGENTMESH_API_TOKEN", "")
print(f"Connecting to Agent Mesh Node at {url}")
headers = {"X-Mesh-Authentication": f"Bearer {token}"} if token else {}
@@ -35,7 +35,7 @@ async def main():
print(getattr(block, "text", block))
except Exception as e:
- print(f"Error connecting to SAM Node: {e}")
+ print(f"Error connecting to Agent Mesh Node: {e}")
sys.exit(1)
diff --git a/site/content/docs/use-cases/_index.md b/site/content/docs/use-cases/_index.md
index 102d0c02..f63b9218 100644
--- a/site/content/docs/use-cases/_index.md
+++ b/site/content/docs/use-cases/_index.md
@@ -5,7 +5,7 @@ weight: 5
---
Worked examples of things built on top of the mesh. Each pattern combines
-ordinary `sam-node` features (discovery, remote tool calls, leasing) into
+ordinary `agentmesh-node` features (discovery, remote tool calls, leasing) into
something larger, without changes to the node itself.
None of the examples depends on a specific harness. The orchestrator is any
@@ -13,5 +13,5 @@ MCP client, whether an agent harness (Claude Code, Codex, Antigravity) or a
custom program, talking to the tools that a local node exposes.
The runnable source for every example is under
-[`development/examples/`](https://github.com/google/sam/tree/main/development/examples)
+[`development/examples/`](https://github.com/google/agentmesh/tree/main/development/examples)
in the repository. Each page links to its directory.
diff --git a/site/content/docs/use-cases/chat-a2a.md b/site/content/docs/use-cases/chat-a2a.md
index 11239ad6..14c37a2b 100644
--- a/site/content/docs/use-cases/chat-a2a.md
+++ b/site/content/docs/use-cases/chat-a2a.md
@@ -6,10 +6,10 @@ weight: 30
Hold a multi-turn conversation with an [A2A](https://a2a-protocol.org/)
(Agent2Agent) agent hosted on a remote mesh node, using a stock, unmodified
-`a2a-sdk` client. There is no SAM-specific client code. The mesh regenerates
+`a2a-sdk` client. There is no Agent Mesh-specific client code. The mesh regenerates
the agent card, and that is enough for the standard SDK to work as it is.
-Source: [`development/examples/chat-a2a/`](https://github.com/google/sam/tree/main/development/examples/chat-a2a).
+Source: [`development/examples/chat-a2a/`](https://github.com/google/agentmesh/tree/main/development/examples/chat-a2a).
## The idea
@@ -50,7 +50,7 @@ This example demonstrates both halves:
Python `a2a-sdk`. It serves its agent card, answers messages, and holds
history on the server side, one Gemini chat session per `contextId`. The
node proxies to it through `target_url`. The agent knows nothing about
- SAM.
+ Agent Mesh.
- **REPL client** (`chat.py`): a stock `a2a-sdk` client of about forty lines
that resolves the card through the mesh, then loops `input()` to a message
send, echoing the `contextId` that the server created on the first reply.
@@ -63,7 +63,7 @@ This example demonstrates both halves:
line in the node configuration.
- **Use any stock A2A client.** `chat.py` is the smallest one. Because of the
regenerated card, SDKs, CLIs and other agents resolve and call the service
- without knowing that SAM exists.
+ without knowing that Agent Mesh exists.
- **Let the agent own the conversation.** This is the same pattern as
[Gemini Buddy](../gemini-buddy/), on the standard A2A protocol instead of
a custom MCP tool. State lives with the agent, keyed by `contextId`, and
@@ -83,19 +83,19 @@ Google AI Studio key is enough for the demo.
### 2. Bring the mesh up and deploy the agent
```bash
-make build # builds ./bin/sam-node (once)
-make kind-up # control plane + router (no sam-nodes yet)
+make build # builds ./bin/agentmesh-node (once)
+make kind-up # control plane + router (no agentmesh-nodes yet)
docker build -t chat-a2a:local development/examples/chat-a2a
-kind load docker-image --name sam-kind chat-a2a:local
-helm --kube-context kind-sam-kind -n sam-kind install chat-a2a charts/sam-node \
- -f development/kind/sam-node.values.yaml \
+kind load docker-image --name agentmesh-kind chat-a2a:local
+helm --kube-context kind-agentmesh-kind -n agentmesh-kind install chat-a2a charts/agentmesh-node \
+ -f development/kind/agentmesh-node.values.yaml \
-f development/examples/chat-a2a/values.yaml
```
### 3. Enroll a local caller node
```bash
-make kind-local-node # a local sam-node enrolled in the mesh; leave it running
+make kind-local-node # a local agentmesh-node enrolled in the mesh; leave it running
```
The local node is your entry point. Its API listens on
@@ -117,7 +117,7 @@ Fetch the agent card through the mesh with `curl`:
```bash
curl -s -H 'X-Mesh-Authentication: Bearer devtoken' \
- "http://127.0.0.1:9099/sam/$PEER/a2a/chat/.well-known/agent-card.json" | jq
+ "http://127.0.0.1:9099/mesh/$PEER/a2a/chat/.well-known/agent-card.json" | jq
```
The interface URLs in the response point back at this
@@ -132,7 +132,7 @@ Requires [`uv`](https://docs.astral.sh/uv/).
```bash
cd development/examples/chat-a2a
uv run --with-requirements requirements.txt chat.py \
- "http://127.0.0.1:9099/sam/$PEER/a2a/chat"
+ "http://127.0.0.1:9099/mesh/$PEER/a2a/chat"
```
To check the continuity: introduce yourself in one turn, chat about
@@ -146,7 +146,7 @@ back as `--context-id` and the agent continues the same conversation:
```bash
export A2ACLI_SVC_PARAM='X-Mesh-Authentication=Bearer devtoken'
-CARD="http://127.0.0.1:9099/sam/$PEER/a2a/chat/.well-known/agent-card.json"
+CARD="http://127.0.0.1:9099/mesh/$PEER/a2a/chat/.well-known/agent-card.json"
a2a send -a "$CARD" "hello, I am Ada"
a2a send -a "$CARD" --context-id <contextId from the first reply> "what is my name?"
```
diff --git a/site/content/docs/use-cases/gemini-buddy.md b/site/content/docs/use-cases/gemini-buddy.md
index f2b86ced..aaec14b2 100644
--- a/site/content/docs/use-cases/gemini-buddy.md
+++ b/site/content/docs/use-cases/gemini-buddy.md
@@ -8,7 +8,7 @@ Hold a real multi-turn conversation with a second LLM exposed as an ordinary
mesh service. Your agent never resends the conversation, because the service
remembers its own side.
-Source: [`development/examples/gemini-buddy-mcp/`](https://github.com/google/sam/tree/main/development/examples/gemini-buddy-mcp).
+Source: [`development/examples/gemini-buddy-mcp/`](https://github.com/google/agentmesh/tree/main/development/examples/gemini-buddy-mcp).
## The idea
@@ -22,9 +22,9 @@ This use case shows that you do not have to. A **buddy** is a plain MCP
service backed by the Gemini CLI that owns its own conversation. Your agent
sends one message per turn and gets one reply. The buddy keeps the running
transcript on the server side, keyed by a `session_id`. It is built from an
-ordinary `sam-node` MCP service, and it is the conversational version of the
+ordinary `agentmesh-node` MCP service, and it is the conversational version of the
one-shot
-[`code-reviewer`](https://github.com/google/sam/tree/main/development/examples/code-reviewer-pool/reviewer)
+[`code-reviewer`](https://github.com/google/agentmesh/tree/main/development/examples/code-reviewer-pool/reviewer)
example.
## Two conversations, two places
@@ -84,19 +84,19 @@ free Google AI Studio key is enough for the demo.
### 2. Bring the mesh up and deploy the buddy
```bash
-make build # builds ./bin/sam-node (once)
-make kind-up # control plane + router (no sam-nodes yet)
+make build # builds ./bin/agentmesh-node (once)
+make kind-up # control plane + router (no agentmesh-nodes yet)
docker build -t gemini-buddy-mcp:local development/examples/gemini-buddy-mcp
-kind load docker-image --name sam-kind gemini-buddy-mcp:local
-helm --kube-context kind-sam-kind -n sam-kind install gemini-buddy charts/sam-node \
- -f development/kind/sam-node.values.yaml \
+kind load docker-image --name agentmesh-kind gemini-buddy-mcp:local
+helm --kube-context kind-agentmesh-kind -n agentmesh-kind install gemini-buddy charts/agentmesh-node \
+ -f development/kind/agentmesh-node.values.yaml \
-f development/examples/gemini-buddy-mcp/values.yaml
```
### 3. Start a local orchestrator node
```bash
-make kind-local-node # a local sam-node enrolled in the mesh; leave it running
+make kind-local-node # a local agentmesh-node enrolled in the mesh; leave it running
```
`kind-local-node` runs in the foreground in its own shell and exposes the
@@ -120,7 +120,7 @@ Code, Cursor, and others) would add:
```json
{
"mcpServers": {
- "sam-mesh": {
+ "agentmesh": {
"type": "http",
"url": "http://127.0.0.1:9099/mcp",
"headers": { "X-Mesh-Authentication": "Bearer devtoken" }
diff --git a/site/content/docs/use-cases/multi-tier-guardrails.md b/site/content/docs/use-cases/multi-tier-guardrails.md
index 43b2340d..9b963b97 100644
--- a/site/content/docs/use-cases/multi-tier-guardrails.md
+++ b/site/content/docs/use-cases/multi-tier-guardrails.md
@@ -14,9 +14,9 @@ When every developer and team starts shipping AI agents, organizations hit a gov
2. **Platform & Networking Engineers** want persistent logical service names (`a2a://support.acme`) that survive replica swaps across environments without static proxy limits.
3. **Central Security (CISO)** wants an organization-wide policy floor, automated quality gates before an agent can serve production (`env=staging` $\rightarrow$ `env=prod`), and zero raw API credentials inside agent containers.
4. **Department Leads & Individual End-Users** want to narrow what an agent can do on *their* infrastructure or on *their* behalf—even when the organization's baseline policy allows it.
-5. **Day-2 Operations (SRE)** needs a correlated audit trail across every hop and a 1-command kill-switch (`sam-one admin ban`) if a peer misbehaves.
+5. **Day-2 Operations (SRE)** needs a correlated audit trail across every hop and a 1-command kill-switch (`agentmesh-one admin ban`) if a peer misbehaves.
-The runnable example in [`development/examples/multi-tier-guardrails/`](https://github.com/google/sam/tree/main/development/examples/multi-tier-guardrails) walks through all five personas in four acts using **real backends** and zero changes to SAM's core code:
+The runnable example in [`development/examples/multi-tier-guardrails/`](https://github.com/google/agentmesh/tree/main/development/examples/multi-tier-guardrails) walks through all five personas in four acts using **real backends** and zero changes to Agent Mesh's core code:
- **Real Local LLM (`gemma3:1b` via Ollama):** Powers the Support A2A replicas (`support_agent.py`) over an OpenAI-compatible `/v1/chat/completions` endpoint.
- **Real A2A 1.0 SDK (`a2a-sdk`):** Both `support_agent.py` (server) and `a2a_client.py` (client) use the official [`a2a-sdk`](https://pypi.org/project/a2a-sdk/) with SQLite-backed conversation history keyed by `contextId`.
@@ -27,13 +27,13 @@ The runnable example in [`development/examples/multi-tier-guardrails/`](https://
## The 5 Personas in One Mesh
-| Persona | What They Control in SAM | Mechanism Used in This Example |
+| Persona | What They Control in Agent Mesh | Mechanism Used in This Example |
| :--- | :--- | :--- |
-| **1. Agent Developer (Alice)** | Onboarding & iterating on `a2a://support.acme` (`support_agent.py`) | Enrolls `sam-node` in `env=staging` quarantine; zero code changes to promote to `env=prod` |
+| **1. Agent Developer (Alice)** | Onboarding & iterating on `a2a://support.acme` (`support_agent.py`) | Enrolls `agentmesh-node` in `env=staging` quarantine; zero code changes to promote to `env=prod` |
| **2. Platform / Networking** | Service discovery, outbound floor & replica lifecycle | Input-node `egress.require_labels: {env: prod}`, logical URI `a2a://support.acme`, and `contextId` continuity from Laptop (`v1`) to Cloud Run (`v2`) |
| **3. Central Security (CISO)** | Org-wide baseline RBAC, Quality Gate & Secret Brokering | Control-plane `policy.json` (`allowed_labels`, HTTP method/path rules on `egress://api.github.com`, `secret_ref: github-ro`) |
| **4. Department Lead & End-User** | Local team gate + per-task tool narrowing | Egress-node `attenuation` (`check if label("team", "support");`) + RFC 8693 `/oauth/token` minting a sealed Task Biscuit (`tar_block`) |
-| **5. Day-2 Operations (SRE)** | Real-time audit correlation & incident response | Structured `ALLOW`/`DENY` audit stream (`audit.py`) + instant mesh-wide revocation (`sam-one admin ban`) |
+| **5. Day-2 Operations (SRE)** | Real-time audit correlation & incident response | Structured `ALLOW`/`DENY` audit stream (`audit.py`) + instant mesh-wide revocation (`agentmesh-one admin ban`) |
---
@@ -41,7 +41,7 @@ The runnable example in [`development/examples/multi-tier-guardrails/`](https://
When watching Alice configure `labels:` in `node-v1.yaml` or a caller send `X-Mesh-Required-Labels`, a natural question arises: *"Can a developer or agent just set arbitrary labels to influence security policy?"*
-No. In SAM, labels operate at **three distinct points** with clear separation of authority:
+No. In Agent Mesh, labels operate at **three distinct points** with clear separation of authority:
1. **Mesh Enforcement (Control Plane `policy.json` $\rightarrow$ `allowed_labels`):**
A node's YAML file (`labels:`) is only a **request** at enrollment time. The Control Plane validates every requested label against the role's `allowed_labels` in `policy.json` before cryptographically signing `label("k", "v")` facts into the node's authority Biscuit. If Alice tries to self-assert `env: prod` before passing the Quality Gate, enrollment is rejected (`Label not permitted: label "env=prod" is not permitted by this role's allowed_labels`).
@@ -73,7 +73,7 @@ Pass `--interactive` to step through the four acts one `ENTER` at a time during
### Act 1: Developer Onboarding into Quarantine (`env=staging`) & Quality Gate Promotion
*(Personas: Agent Developer Alice + Central Security / Platform)*
-Alice starts her `sam-node` fronting `a2a://support.acme` (`support_agent.py` backed by `gemma3:1b`) and `mcp://orders-db` (`orders_mcp.py` backed by SQLite). Her node config (`node-v1.yaml`) declares `env: staging`, and the initial control-plane policy (`policy.json`) only permits `env=staging`.
+Alice starts her `agentmesh-node` fronting `a2a://support.acme` (`support_agent.py` backed by `gemma3:1b`) and `mcp://orders-db` (`orders_mcp.py` backed by SQLite). Her node config (`node-v1.yaml`) declares `env: staging`, and the initial control-plane policy (`policy.json`) only permits `env=staging`.
Right here, the demo shows both **Mesh Enforcement** and **Input Node Enforcement**:
- If Alice tries to join with `env: prod` in her YAML before passing the Quality Gate, the Control Plane rejects enrollment:
@@ -81,7 +81,7 @@ Right here, the demo shows both **Mesh Enforcement** and **Input Node Enforcemen
- While Alice's node is in `env=staging`, a plain request through the Input Node (`node-caller.yaml`, which enforces `egress.require_labels: { env: prod }`) is blocked even when the app sends no label headers:
`HTTP 403 — Required labels not attested by provider`
-Next, the automated Quality Gate fetches Alice's Agent Card in `env=staging`, verifies that it conforms to the A2A 1.0 schema and declares the expected skills (`order_lookup`, `refund_triage`), and promotes the policy and node to `env=prod`. Retrying the exact same production request now succeeds with `200 OK` and rewrites `supportedInterfaces[0].url` to point at the caller's local SAM proxy.
+Next, the automated Quality Gate fetches Alice's Agent Card in `env=staging`, verifies that it conforms to the A2A 1.0 schema and declares the expected skills (`order_lookup`, `refund_triage`), and promotes the policy and node to `env=prod`. Retrying the exact same production request now succeeds with `200 OK` and rewrites `supportedInterfaces[0].url` to point at the caller's local Agent Mesh proxy.
---
@@ -99,7 +99,7 @@ Callers address the agent by its logical mesh name (`a2a://support.acme`), never
### Act 3: The 3-Tier Guardrail Hierarchy
*(Personas: Central Security, Department Lead, and Individual End-User)*
-SAM enforces the **strict intersection** of three independent guardrail layers:
+Agent Mesh enforces the **strict intersection** of three independent guardrail layers:
```
Effective Permission = (Layer 1: Central Security Block 0 Policy)
@@ -108,10 +108,10 @@ Effective Permission = (Layer 1: Central Security Block 0 Policy)
```
#### Layer 1 — Central Security (Org Baseline & Secret Broker)
-In `policy.json`, Central Security assigns `egress://api.github.com` (`https://api.github.com`) to nodes labelled `team=support` with `secret_ref: "github-ro"`, and restricts callers to `GET /repos/google/sam/pulls*`:
+In `policy.json`, Central Security assigns `egress://api.github.com` (`https://api.github.com`) to nodes labelled `team=support` with `secret_ref: "github-ro"`, and restricts callers to `GET /repos/google/agentmesh/pulls*`:
-* `GET /repos/google/sam/pulls?state=open&per_page=1` $\rightarrow$ **`200 OK`** (the hosting node injects the read-only GitHub token from `secrets/github-ro`; the caller never holds the credential).
-* `POST /repos/google/sam/pulls` $\rightarrow$ **`403 Forbidden`** (blocked by the Block 0 HTTP rule before GitHub ever receives the request).
+* `GET /repos/google/agentmesh/pulls?state=open&per_page=1` $\rightarrow$ **`200 OK`** (the hosting node injects the read-only GitHub token from `secrets/github-ro`; the caller never holds the credential).
+* `POST /repos/google/agentmesh/pulls` $\rightarrow$ **`403 Forbidden`** (blocked by the Block 0 HTTP rule before GitHub ever receives the request).
#### Layer 2 — Department Lead (Egress-Node Positive Label Enforcement)
Central Security's org-wide policy allows `mesh:role:node` to reach `mcp://orders-db`. However, the Support Department Lead adds a local positive label check in `node-v1.yaml`:
@@ -158,8 +158,8 @@ Every `ALLOW` and `DENY` across all three layers is emitted as a structured JSON
```text
ALLOW mesh:role:node 12D3KooW… GET /.well-known/agent-card.json a2a://support.acme
ALLOW mesh:role:node 12D3KooW… POST / a2a://support.acme
-ALLOW mesh:role:node 12D3KooW… GET /repos/google/sam/pulls egress://api.github.com
-DENY - 12D3KooW… POST /repos/google/sam/pulls egress://api.github.com
+ALLOW mesh:role:node 12D3KooW… GET /repos/google/agentmesh/pulls egress://api.github.com
+DENY - 12D3KooW… POST /repos/google/agentmesh/pulls egress://api.github.com
DENY - 12D3KooW… /mesh/mcp/1.0.0 mcp://orders-db
ALLOW mesh:role:node 12D3KooW… /mesh/mcp/1.0.0 mcp://orders-db
```
@@ -167,5 +167,5 @@ ALLOW mesh:role:node 12D3KooW… /mesh/mcp/1.0.0 mcp://order
Finally, if Day-2 Operations detects repeated policy violations from the contractor peer, a single command revokes that peer's identity across the entire mesh:
```bash
-./bin/sam-one admin ban <contractor-peer-id> --server $CP_URL --data-dir $WORK_DIR/one
+./bin/agentmesh-one admin ban <contractor-peer-id> --server $CP_URL --data-dir $WORK_DIR/one
```
diff --git a/site/content/docs/use-cases/sandboxed-agent.md b/site/content/docs/use-cases/sandboxed-agent.md
index 95f1536d..82c5b4ea 100644
--- a/site/content/docs/use-cases/sandboxed-agent.md
+++ b/site/content/docs/use-cases/sandboxed-agent.md
@@ -14,9 +14,9 @@ watches every decision, and cuts it off when done.
<source src="../../../demo-sandboxed-agent.mp4" type="video/mp4">
</video>
-Source: [`development/examples/sandboxed-agent/`](https://github.com/google/sam/tree/main/development/examples/sandboxed-agent).
+Source: [`development/examples/sandboxed-agent/`](https://github.com/google/agentmesh/tree/main/development/examples/sandboxed-agent).
The scenes, the narration and the recording recipe are in its
-[`SCRIPT.md`](https://github.com/google/sam/blob/main/development/examples/sandboxed-agent/SCRIPT.md).
+[`SCRIPT.md`](https://github.com/google/agentmesh/blob/main/development/examples/sandboxed-agent/SCRIPT.md).
## The idea
@@ -36,20 +36,20 @@ API stays on a node in the office.
## The pieces
-**One policy** ([`policy.json`](https://github.com/google/sam/blob/main/development/examples/sandboxed-agent/policy.json)).
+**One policy** ([`policy.json`](https://github.com/google/agentmesh/blob/main/development/examples/sandboxed-agent/policy.json)).
The role `agent` may call `inference://office-llm`, `mcp://tools` and
`egress://api.github.com`, the last one only with `GET` under
-`/repos/google/sam/`. The destination `api.github.com` is served by nodes
+`/repos/google/agentmesh/`. The destination `api.github.com` is served by nodes
labelled `site=office` with the credential named `github-ro`.
-**One node in the office** ([`pep.yaml`](https://github.com/google/sam/blob/main/development/examples/sandboxed-agent/pep.yaml)).
-A `sam-node` with the label `site=office` fronts Ollama and an MCP server on
+**One node in the office** ([`pep.yaml`](https://github.com/google/agentmesh/blob/main/development/examples/sandboxed-agent/pep.yaml)).
+A `agentmesh-node` with the label `site=office` fronts Ollama and an MCP server on
loopback. The control plane assigns `api.github.com` to it because of the
label; the node reads the token from `<--secrets-dir>/github-ro` on every
request and presents it to GitHub. See
[egress destinations](../../guides/egress-destinations/).
-**One program in the sandbox** ([`agent.py`](https://github.com/google/sam/blob/main/development/examples/sandboxed-agent/agent.py)).
+**One program in the sandbox** ([`agent.py`](https://github.com/google/agentmesh/blob/main/development/examples/sandboxed-agent/agent.py)).
It enrolls once with a single-use token minted for the role `agent`, then
discovers each service by name and calls it: `/v1/models` and a chat
completion, an MCP tool, and three requests to GitHub of which the policy
@@ -62,20 +62,20 @@ On the office machine, from `development/examples/sandboxed-agent/`:
```bash
make ollama # the office model, in Docker
make mcp # the MCP reference server on :3001, in its own terminal
-make mesh # sam-one on a public https URL; copy the API URL from the banner
+make mesh # agentmesh-one on a public https URL; copy the API URL from the banner
make tokens URL=$URL # one token for the node, one for the agent
GITHUB_TOKEN_FILE=~/github-ro make pep URL=$URL 2>&1 | python3 audit.py
```
`GITHUB_TOKEN_FILE` is a fine-grained token with read access to pull
-requests on `google/sam`, and nothing else; the node is the only process
+requests on `google/agentmesh`, and nothing else; the node is the only process
that reads it.
In the sandbox, with the SDK installed (`pip install ./sdk/python`) and the
agent token the admin handed you:
```bash
-export SAM_CONTROL_PLANE_URL=$URL SAM_BOOTSTRAP_TOKEN_PATH=./agent-token
+export AGENTMESH_CONTROL_PLANE_URL=$URL AGENTMESH_BOOTSTRAP_TOKEN_PATH=./agent-token
python agent.py # every step, or one of: models, ask, tool, github GET /user
```
@@ -86,8 +86,8 @@ the mesh and `make ban URL=$URL PEER=<peer id>` cuts the agent off.
- The request GitHub receives carries the office's token and none of the
agent's headers. The sandbox never had a credential to leak.
-- `POST /repos/google/sam/pulls` and `GET /user` are answered `403` with
- `Proxy-Status: sam-node; error=http_request_denied` by the node, before
+- `POST /repos/google/agentmesh/pulls` and `GET /user` are answered `403` with
+ `Proxy-Status: agentmesh-node; error=http_request_denied` by the node, before
GitHub hears of them. Each is one `DENY` line in the node's log with the
peer, the role, the method and the path.
- Removing the `egress` entry from the policy withdraws the destination on
diff --git a/site/content/docs/use-cases/warm-agent-pool.md b/site/content/docs/use-cases/warm-agent-pool.md
index 71ce738b..3bb9a6bb 100644
--- a/site/content/docs/use-cases/warm-agent-pool.md
+++ b/site/content/docs/use-cases/warm-agent-pool.md
@@ -12,7 +12,7 @@ no changes to the node.
<source src="../../../demo-warm-agent-pool.mp4" type="video/mp4">
</video>
-Source: [`development/examples/code-reviewer-pool/`](https://github.com/google/sam/tree/main/development/examples/code-reviewer-pool).
+Source: [`development/examples/code-reviewer-pool/`](https://github.com/google/agentmesh/tree/main/development/examples/code-reviewer-pool).
## The idea
@@ -66,7 +66,7 @@ race and workers come and go:
it busy), so two concurrent `acquire_worker` calls can never receive the
same peer.
- **Grace eviction.** Discovery never drops a leased worker on a transient
- miss, and it drops a free one only after `SAM_GRACE_MISSES` consecutive
+ miss, and it drops a free one only after `AGENTMESH_GRACE_MISSES` consecutive
misses. A slow, busy worker is not evicted and handed out again in the
middle of a review.
- **Fencing tokens.** `acquire_worker` returns a `lease_id`. `release_worker`
@@ -84,8 +84,8 @@ lease expiry. The orchestrator forwards the token in the `review_code`
arguments, and the worker verifies it offline (shared secret, no call back to
the manager). Any `review_code` without a valid, unexpired token gets
`NO_LEASE`. Both sides default to a hardcoded development secret
-(`sam-dev-pool-secret`), so enforcement works out of the box. Set a matching
-`SAM_POOL_SECRET` on the manager and on every worker to override it.
+(`agentmesh-dev-pool-secret`), so enforcement works out of the box. Set a matching
+`AGENTMESH_POOL_SECRET` on the manager and on every worker to override it.
Mismatched or one-sided secrets fail closed, and every call returns
`NO_LEASE`.
@@ -100,7 +100,7 @@ Mismatched or one-sided secrets fail closed, and every call returns
corrupting in-flight leases.
- **A reusable pattern.** Swap `code-reviewer` for any tool that is expensive
to warm up (test runner, sandbox, embedder, browser). The manager is
- generic. It pools whatever `SAM_POOL_SERVICE` names.
+ generic. It pools whatever `AGENTMESH_POOL_SERVICE` names.
## Try it on kind
@@ -116,31 +116,31 @@ building. A free key is enough for the demo.
### 2. Bring the mesh up and deploy the pool
```bash
-make build # builds ./bin/sam-node (once)
-make kind-up # control plane + router (no sam-nodes yet)
+make build # builds ./bin/agentmesh-node (once)
+make kind-up # control plane + router (no agentmesh-nodes yet)
```
-Then build the two images and deploy the pool as `charts/sam-node` releases:
+Then build the two images and deploy the pool as `charts/agentmesh-node` releases:
three reviewer replicas and one manager. Each replica enrolls as its own
mesh node, so the pool is three `code-reviewer` services with the same name.
```bash
docker build -t reviewer:local development/examples/code-reviewer-pool/reviewer
docker build -t pool-manager:local development/examples/code-reviewer-pool/manager
-kind load docker-image --name sam-kind reviewer:local pool-manager:local
+kind load docker-image --name agentmesh-kind reviewer:local pool-manager:local
-helm --kube-context kind-sam-kind -n sam-kind install reviewers charts/sam-node \
- -f development/kind/sam-node.values.yaml \
+helm --kube-context kind-agentmesh-kind -n agentmesh-kind install reviewers charts/agentmesh-node \
+ -f development/kind/agentmesh-node.values.yaml \
-f development/examples/code-reviewer-pool/reviewer/values.yaml --set replicaCount=3
-helm --kube-context kind-sam-kind -n sam-kind install manager charts/sam-node \
- -f development/kind/sam-node.values.yaml \
+helm --kube-context kind-agentmesh-kind -n agentmesh-kind install manager charts/agentmesh-node \
+ -f development/kind/agentmesh-node.values.yaml \
-f development/examples/code-reviewer-pool/manager/values.yaml
```
### 3. Start a local orchestrator node
```bash
-make kind-local-node # a local sam-node enrolled in the mesh; leave it running
+make kind-local-node # a local agentmesh-node enrolled in the mesh; leave it running
```
`kind-local-node` runs in the foreground in its own shell and exposes the
@@ -164,7 +164,7 @@ Cursor, and others) would add:
```json
{
"mcpServers": {
- "sam-mesh": {
+ "agentmesh": {
"type": "http",
"url": "http://127.0.0.1:9099/mcp",
"headers": { "X-Mesh-Authentication": "Bearer devtoken" }
@@ -190,7 +190,7 @@ Have your orchestrator run these steps per file, in parallel:
A natural prompt for an agent harness:
-> Using the `sam-mesh` tools: for each file in
+> Using the `agentmesh-p2p` tools: for each file in
> `development/examples/code-reviewer-pool/samples/`, acquire a worker, call its
> `review_code` with the file contents (forwarding the token), and release it
> (pass the `lease_id` back). Run them in parallel.
@@ -205,19 +205,19 @@ manager picks up the new worker on its next discovery pass and starts
leasing it:
```bash
-kubectl --context kind-sam-kind -n sam-kind scale deploy/reviewers-sam-node --replicas=2
+kubectl --context kind-agentmesh-kind -n agentmesh-kind scale deploy/reviewers-agentmesh-node --replicas=2
# start a big job, then:
-kubectl --context kind-sam-kind -n sam-kind scale deploy/reviewers-sam-node --replicas=3
+kubectl --context kind-agentmesh-kind -n agentmesh-kind scale deploy/reviewers-agentmesh-node --replicas=3
```
## Configuration
| var | default | used by |
|-----|---------|---------|
-| `SAM_NODE_URL` | `http://127.0.0.1:8080/mcp` | manager |
-| `SAM_API_TOKEN` | `devtoken` | manager |
-| `SAM_POOL_SERVICE` | `code-reviewer` | manager |
-| `SAM_DISCOVERY_MS` | `3000` | manager |
-| `SAM_LEASE_MS` | `60000` | manager |
-| `SAM_GRACE_MISSES` | `2` | manager |
-| `SAM_POOL_SECRET` | `sam-dev-pool-secret` (enforcement always on) | manager + reviewer |
+| `AGENTMESH_NODE_URL` | `http://127.0.0.1:8080/mcp` | manager |
+| `AGENTMESH_API_TOKEN` | `devtoken` | manager |
+| `AGENTMESH_POOL_SERVICE` | `code-reviewer` | manager |
+| `AGENTMESH_DISCOVERY_MS` | `3000` | manager |
+| `AGENTMESH_LEASE_MS` | `60000` | manager |
+| `AGENTMESH_GRACE_MISSES` | `2` | manager |
+| `AGENTMESH_POOL_SECRET` | `agentmesh-dev-pool-secret` (enforcement always on) | manager + reviewer |
diff --git a/site/hugo.toml b/site/hugo.toml
index 073905db..ed9f7d23 100644
--- a/site/hugo.toml
+++ b/site/hugo.toml
@@ -1,5 +1,5 @@
-title = "Agent Mesh (SAM)"
-baseURL = "https://sam-mesh.dev"
+title = "Agent Mesh"
+baseURL = "https://__PROTECT_Agent Mesh_MESH_DEV__"
languageCode = "en-us"
enableRobotsTXT = true
diff --git a/site/layouts/index.html b/site/layouts/index.html
index 90bb9a0d..ff932b82 100644
--- a/site/layouts/index.html
+++ b/site/layouts/index.html
@@ -14,7 +14,7 @@
<!-- Hero Branding -->
<div class="hero-brand-col" style="align-items: center;">
<h1 class="landing-title">Agent Mesh</h1>
- <p class="landing-subtitle">OSS Agent Mesh (SAM)</p>
+ <p class="landing-subtitle">OSS Agent Mesh</p>
<p class="landing-description" style="text-align: center; max-width: 600px; margin-left: auto; margin-right: auto;">
A private network for AI agents: publish tools and models, find and call them across machines, with every call authenticated and authorized by name.
</p>
diff --git a/site/layouts/partials/hooks/head-end.html b/site/layouts/partials/hooks/head-end.html
index 9c88cb37..7792a4ad 100644
--- a/site/layouts/partials/hooks/head-end.html
+++ b/site/layouts/partials/hooks/head-end.html
@@ -5,7 +5,7 @@
}
</script>
-<!-- SAM Custom Favicons -->
+<!-- Agent Mesh Custom Favicons -->
<link rel="icon" type="image/png" href="/favicon.png?v=2">
<link rel="shortcut icon" href="/favicon.ico?v=2">
<link rel="manifest" href="{{ "manifest.json" | relURL }}">
diff --git a/site/static/sam_logo.png b/site/static/agentmesh_logo.png
similarity index 100%
rename from site/static/sam_logo.png
rename to site/static/agentmesh_logo.png
diff --git a/site/static/install.sh b/site/static/install.sh
index ea57fff3..8e00edc9 100755
--- a/site/static/install.sh
+++ b/site/static/install.sh
@@ -1,10 +1,10 @@
#!/usr/bin/env bash
set -euo pipefail
-REPO="google/sam"
+REPO="google/agentmesh"
INSTALL_DIR="/usr/local/bin"
-echo "Installing SAM from $REPO..."
+echo "Installing Agent Mesh from $REPO..."
# Get OS and Arch
OS="$(uname -s)"
@@ -37,7 +37,7 @@ fi
echo "Found latest version: ${VERSION}"
# Construct download URL (matches goreleaser name template)
-TAR_NAME="sam_${OS_NAME}_${ARCH_NAME}.tar.gz"
+TAR_NAME="agentmesh_${OS_NAME}_${ARCH_NAME}.tar.gz"
DOWNLOAD_URL="https://github.com/${REPO}/releases/download/${VERSION}/${TAR_NAME}"
CHECKSUMS_URL="https://github.com/${REPO}/releases/download/${VERSION}/checksums.txt"
@@ -82,14 +82,14 @@ tar -xzf "${TAR_NAME}"
echo "Installing to ${INSTALL_DIR} (may require sudo)..."
INSTALLED_BINS=()
-for b in sam-one sam-node sam-control-plane sam-router mcp-client sam-console; do
+for b in agentmesh-one agentmesh-node agentmesh-control-plane agentmesh-router mcp-client agentmesh-console; do
if [ -f "$b" ]; then
INSTALLED_BINS+=("$b")
fi
done
if [ ${#INSTALLED_BINS[@]} -eq 0 ]; then
- echo "Error: No SAM binaries found in release archive."
+ echo "Error: No Agent Mesh binaries found in release archive."
exit 1
fi
@@ -103,5 +103,5 @@ fi
cd - > /dev/null
rm -rf "$TMP_DIR"
-echo "Successfully installed SAM (${VERSION}) to ${INSTALL_DIR}"
-echo "Run 'sam-node --help' to get started."
+echo "Successfully installed Agent Mesh (${VERSION}) to ${INSTALL_DIR}"
+echo "Run 'agentmesh-node --help' to get started."
diff --git a/site/static/manifest.json b/site/static/manifest.json
index 64e8ad05..2cceaa29 100644
--- a/site/static/manifest.json
+++ b/site/static/manifest.json
@@ -1,6 +1,6 @@
{
- "name": "SAM",
- "short_name": "SAM",
+ "name": "Agent Mesh",
+ "short_name": "Agent Mesh",
"icons": [
{
"src": "/favicons/android-36x36.png",