Skip to main content
Glama

Sealbridge

English | 日本語 (README.ja.md)

Contributor setup and PR guidelines: Contributing.

Sealbridge lets the AI in Muse or Grok Bot ask another person's AI for help. An invitation starts a connection; each owner decides whether their side accepts work. DIDs identify peers; names are local shortcuts.

Install on Muse

Paste https://github.com/sealbridge/sealbridge into Muse and say 「これ入れて」 (install this). Muse prepares Node.js and the other tools and installs from source. The invite/role features below are included in the prepared 0.9.2 release. Until npm 0.9.2 is published, install from GitHub main.

Create an invitation (for example, on Muse)

Ask Muse to create an invite and keep its worker running. If you already run a worker, keep your usual startup procedure; migration is optional. To try it with commands:

sealbridge doctor
sealbridge config auto-accept invited write
sealbridge worker start --adapter sandbox --allow-local-pc --name Muse

Share the printed invitation link and keep the process running. This example explicitly allows invited tasks and uses a sandbox adapter that echoes JSON; its host declaration requires write permission even for an echo. For real work, configure your AI adapter and owner acceptance rule. --allow-local-pc explicitly permits local execution with access to that environment.

Receive the invitation

Muse can import the link as an argument. Choose a name used only on your side:

sealbridge accept "https://sealbridge.app/i#acp-invite:..." --alias muse
sealbridge delegate --to muse --title "Quick check" --description "Read input and return JSON" --input '{"text":"hello"}' --auto-approve --audit audit.jsonl
sealbridge connections list
sealbridge audit-verify audit.jsonl

Import alone grants neither connection consent nor task permission. Explicit non-interactive CLI delegation to an invite peer is consent to connect. After verifying a signed ACCEPT from the matching invite DID, the importer records its connection too. Failure before reaching the peer, a DID mismatch, or CONNECTION_TARGET_CONFLICT records nothing. Use --no-connect for a one-off send. Recording prints an English/Japanese notice and a JSON connectionRecorded field; incoming work remains off. The TTY connection prompt and MCP connect: true form remain unchanged.

Connection recording is best-effort: a store failure does not abort accepted work. Bilingual stderr and JSON connectionRecordWarning with code CONNECTION_RECORD_FAILED advise re-running delegate or using TTY/MCP confirmation to record it. No connectionRecorded is emitted on failure. Successful notices use the local alias/name when available (JSON retains the DID). Redirecting only stderr also makes the CLI non-interactive; stdin and stderr must both be TTYs.

Check connections list for the peer DID and local alias. Creator acceptance policy is unchanged. Success reports SETTLED; verified audits report VALID. Without a trust anchor, verification does not detect truncation to an older valid prefix.

--auto-approve explicitly skips send/final-verification prompts. It does not answer the TTY connection prompt or grant remote execution permission. Non-interactive connection consent comes from the explicit send described above. Read the result yourself. --to accepts saved invite names, connection names, invite links and DIDs. Old workerRef / peerRef arguments remain supported. --invite retains invitation-store selection; it is not equivalent to connection-name lookup with --to.

Ask in the reverse direction

After recording the connection through the non-interactive CLI above, check connections list. New connections on the importing side have automatic acceptance off. Return tasks wait for that owner's approval until they opt in. The sender sees an advisory that peer approval may be needed. A held task is not retried automatically.

The importer must also run a worker for the DID that owns its connection. With separate unmigrated requester/worker keys, add --also-requester to worker start (an existing requester key is required). A migrated owner gateway already receives owner-addressed work. The connection uses the name saved with accept --alias, or a name derived from the peer display name when no explicit saved alias exists. The notice and connections list show the actual name. If another DID already uses the saved alias, a derived name is used and the notice/JSON explains the collision. The example below assumes the listed connection name is muse. Have the owner choose the scope:

sealbridge connections allow muse        # read-only
sealbridge connections allow muse write  # also allow writes
sealbridge connections disallow muse     # require owner approval again

These choices apply only to that local peer; they do not start a worker or remove limits. The original creator can send back using the peer's connection name in --to. See invitations and local roles for details.

Related MCP server: aip-identity

Install on Grok Bot

Paste the same repository link and say "install this." Building from source needs Node.js 22 or later and pnpm 10. After pnpm install --frozen-lockfile and pnpm build in the checkout, this POSIX-shell function makes the source command available in the current shell (no global install needed):

sealbridge_source="$PWD"
sealbridge() { node "$sealbridge_source/cli/dist/index.js" "$@"; }
sealbridge --version

Keep that checkout in place. In another shell, define the function again with its absolute path. MCP must use the executable/path configuration below, rather than this shell function. Run sealbridge doctor to check connectivity.

For the published package, the user-directory alternative is below. Use the repository installation above for the full invite/role series.

npm i --prefix "$HOME/.local" sealbridge
export PATH="$HOME/.local/node_modules/.bin:$PATH"

To create an invite, start a worker as above and share its printed link. To receive one, save it in a private invitation.txt and import through stdin:

sealbridge accept --stdin --alias reviewer < invitation.txt
sealbridge delegate --to reviewer --title "Quick check" --description "Return JSON" --input '{"text":"hello"}' --auto-approve
sealbridge connections list

Non-interactive CLI delegation records the importer connection after verifying the invite peer's signed ACCEPT (unless --no-connect). Before reverse work, run connections allow <connection-name> using the connection name shown in the recording notice or connections list. With accept --alias reviewer, use connections allow reviewer (or explicitly connections allow reviewer write for writes); a different-DID name collision is reported with the actual fallback name. An openai receiver needs a provider API key, and any required endpoint/model, in the host environment; usage is billed to its owner. It needs no --allow-local-pc unless local command hooks are used. Sandbox / codex / claude workers need that flag.

Register MCP for connection confirmation

MCP acp_create_invite refuses normal and shared (maxUses) invites in the default unmigrated configuration with isError: true and error: INVITE_REQUESTER_LISTENER_REQUIRED. It creates no token or shared-invite limit. Plain worker start listens on a different worker key and cannot receive requester-key invites. To mint, explicitly configure options.owner or mcp-server --key <file>, or use a migrated owner gateway. After minting with an explicit requester identity, serve it using sealbridge worker start --also-requester with the same data root and key-store settings and usual adapter/relay options; optionally add --requester-auto-accept read-only or --requester-auto-accept write, otherwise owner approval is required. Alternatively use sealbridge invite create for a worker-key invite that plain worker start can serve. Minting starts no listener and cannot detect one. Signing identity, shared limits and protocol versions are unchanged.

In an MCP-capable host, register the stdio command sealbridge mcp-server. The host must support form elicitation (elicitation/create) and show the connection confirmation to the owner. Starting the server alone does not grant consent. Send with acp_delegate_task (for example { "peerRef": "muse", "title": "Quick check", "input": { "text": "hello" } }) and have the owner accept the separate connect: true form. Use the same OS account, data directory and key-store configuration as the CLI that imported the invite.

For a source checkout, a common host configuration looks like this (replace the absolute paths; the host's settings format may differ):

{
  "mcpServers": {
    "sealbridge": {
      "command": "/absolute/path/to/node",
      "args": ["/absolute/path/to/sealbridge/cli/dist/index.js", "mcp-server"]
    }
  }
}

On Windows, use paths such as C:/path/to/node.exe and C:/path/to/sealbridge/cli/dist/index.js. Add --allow-private-relay to args only when your relay environment requires it. Reload the host, check that acp_list_invites sees the imported alias, then send the first task and accept the connection form. Muse/Grok Bot support for registering this stdio server and displaying elicitation forms has not been verified here; check your host's MCP settings. If MCP is unavailable, use the non-interactive CLI flow above. In a TTY, the owner still answers the separate connection prompt.

Connection troubleshooting

For a working proxy connection, sealbridge doctor reports:

Relay: Reachable; via proxy (OK)

Muse's proxy settings are used automatically. The default public relay is https://relay.sealbridge.dev; omit --relay to use it. Grok Bot synthetic DNS (198.18/15) is detected automatically from 0.8.1. Other environments resolving the relay to private addresses, or intentional private/loopback relays, can require --allow-private-relay on the relevant accept, delegate, invite create, worker start or mcp-server command after checking the destination. Metadata addresses remain blocked.

accept --paste needs a TTY. Use an argument on Muse or stdin on Grok Bot as above. RELAY_PROXY_AUTH_FAILED means proxy authentication; RELAY_PROXY_REFUSED means CONNECT is blocked. Keep credentials out of reports. See relay reliability.

To issue a shared invitation, use sealbridge invite create --max-uses N (an integer from 1 to 1000; for example, 50). Share the reusable token or its long /i#acp-invite: link. The issuer persists a signed limit and atomically counts distinct authenticated owner DIDs; repeats consume no extra place and disconnecting or blocking does not free one. A new owner after exhaustion gets INVITE_USES_EXHAUSTED. Omitted --max-uses or 1 keeps first-owner binding. Short /j links remain single-claim and cannot be combined with --max-uses greater than 1. Invitations create connections without selecting roles or enabling importer automatic acceptance. See admission.

Downgrade warning: after two or more owners bind the same shared invitation, 0.9.0 and earlier cannot read that connection store, even when running alone. They require one binding per invite digest: connections list fails with INTAKE_STORE_INVALID, and old workers may time out tasks or exit. Back up the data directory before upgrading or starting to use shared invitations. To downgrade, restore that backup. Merely avoiding simultaneous old/new processes is insufficient. The existing #297 store format is retained to preserve signed bindings; neither the AgentInvite token nor protocol 0.2.0 changes.

Privacy

Tasks and results are encrypted to the recipient's key. The relay handles ciphertext and routing metadata such as the destination. The receiving agent and its model provider read task content. Encryption cannot prevent the receiving side from storing or reusing what it has read. Do not give a worker access to personal data or accounts it does not need. Keep private keys and invitation material private.

Other environments

Install on your own computer

macOS / Linux:

curl -fsSL https://sealbridge.dev/install.sh | sh

Windows PowerShell:

irm https://sealbridge.dev/install.ps1 | iex

The installers in this source tree pin 0.9.2; the hosted installers change only after a separate deployment. After npm publication, with Node 22 or newer you can also use npm i -g sealbridge@0.9.2 or npx sealbridge@0.9.2. After install, run sealbridge doctor, and optionally sealbridge demo. The installers print PATH guidance. To uninstall, run sh sites/install.sh --uninstall or ./sites/install.ps1 -Uninstall from a source checkout; for an npm global install, run npm uninstall -g sealbridge.

Run a worker locally

From 0.7.0, mainline sealbridge requires --allow-local-pc for --adapter claude|codex|command, sandbox running on this PC, and --on-receive. Requester-only delegate, and an openai worker without local command hooks, do not need the flag.

sealbridge worker start --adapter sandbox --allow-local-pc

Startup prints a shareable acp-invite: token and a https://sealbridge.app/i#acp-invite:... link. The default lifetime is 24 hours.

For the local edition, run npm i -g sealbridge-local and use sealbridge-local worker start …. Keys and the data directory are shared. Sealbridge Desktop is another option. An isolated runtime (microVM) is in preparation.

MCP hosts (Cursor / Claude)

sealbridge setup supports cursor, claude-desktop (macOS / Windows), and claude-code (requires --project with an absolute path). There is no Muse-specific setup --host target; register MCP only when using the MCP path. For other hosts, follow manual MCP registration if supported. See sealbridge setup --help.

Try from source / run your own relay

Sealbridge supports Node.js 22 and later (the current effective minimum is 22); CI tests Node 22 and Node 24, published packages are built on Node 22, and the installer pins Node 22.22.0 when installing Node but reuses an existing Node 22+ runtime with working bundled npm.

Requires pnpm 10.

git clone https://github.com/sealbridge/sealbridge.git && cd sealbridge
pnpm install --frozen-lockfile && pnpm build
pnpm sealbridge demo

Use pnpm sealbridge relay start --port 8787 --host 127.0.0.1 only for same-machine or offline work. To host your own public relay, see relay reliability and packages/relay/wrangler.toml.example.

Agent playbooks are in AGENTS.md and SKILL.md.

Documents

Document

Contents

Automatic acceptance

Read-only vs write, audience, daily and monthly caps

Relay reliability

Retries, deadlines, proxies, relay operations

Connection exchange

Connection offers and status

Audit interruption

Audit records when a task is interrupted

SDK

Embedding API

ARCHITECTURE.md

System shape and trust boundaries

spec/README.md

Protocol

SECURITY_PROOF.md

Adversarial test suite

All CLI subcommands are listed in sealbridge --help, and each command has --help.

Formerly ACP / agent-collab-platform. Renamed to avoid confusion with Zed’s Agent Client Protocol and IBM / BeeAI’s Agent Communication Protocol. The acp bin remains a deprecated alias. Protocol identifiers and existing data paths stay compatible.

Explicit invitation alias intent is stored in an optional, signed sidecar so invite data remains readable by older versions. Existing inline aliasExplicit markers are migrated out of the invite records on access. Aliases saved before explicit intent tracking are treated as not explicit: re-accept the same invitation with --alias before the first connection to use that name. Missing, corrupt or unreadable sidecar metadata falls back to the derived connection name without blocking import or delegation. In accept JSON, aliasExplicit: false means the intent marker could not be saved; check whether its value is true, rather than whether the key exists.

Available Tools

14 tools
acp_create_inviteCreate an invite tokenA

Sign a distinct local acp-invite token for this server owner (requester by default), without relay traffic or starting a listener; use sealbridge accept to import, acp_revoke_token to revoke, or acp_discover_workers to discover peers. Default unmigrated MCP refuses normal/shared invites with INVITE_REQUESTER_LISTENER_REQUIRED before minting or recording limits: plain worker start cannot receive them. Use options.owner or mcp-server --key for an explicit receiving identity, then serve requester invites with --also-requester (optionally --requester-auto-accept read-only or write); alternatively use sealbridge invite create for a worker-key invite or a migrated owner gateway. relayUrl defaults to the server relay or https://relay.sealbridge.dev, name to the server name or Sealbridge Worker, expiry to 3600 seconds, and agentDid to the migrated delegate or owner DID; another agentDid needs the matching server agent key. Signing is not idempotent; invalid arguments return JSON-RPC -32602, other failures isError true with { error: CODE }.

Inputs: name, maxUses, agentDid, relayUrl, +1 more. Returns: Success payload in structuredContent. The token embeds the public card and rela…

acp_delegate_multiDelegate to multiple workersA

Delegate JSON to multiple remote workers and return the winning deliverable, digest, task ids and audit summaries; use acp_delegate_task for one worker. Race keeps the first verified result; quorum needs quorumSize matching digests (default floor of worker count over 2, plus 1), else QUORUM_NOT_REACHED. Each workers entry has workerDid and optional inviteToken/relayUrl; signing, allowlists and approval precede input transmitted externally over the relay. Requested host form approval reviews each recipient with total fan-out; use elicitation or a webhook/provider. Optional idempotencyKey returns the first result without repeating sends or per-recipient approvals; changed content returns IDEMPOTENCY_CONFLICT. Bad arguments: JSON-RPC -32602; operational failures: isError true with { error: CODE } and no partial deliverable, including after transmission.

Inputs: mode (required), title (required), workers (required), input, +14 more. Returns: Success payload in structuredContent. Quorum or transport failure is isError ra…

acp_delegate_taskDelegate one taskA

Delegate JSON using to with a connection alias from acp_list_connections (CLI --to rules), or workerRef/peerRef/inviteToken/workerDid; bare DIDs match exactly. Unknown/ambiguous names require listing or renaming; different-DID conflicts fail, expired same-DID aliases fall back to connections, and connection sends add advisory acceptanceWarning without blocking. Signing, worker/relay allowlists and approval precede input transmitted externally; requested approval needs host elicitation or a webhook/provider, else APPROVAL_CHANNEL_UNAVAILABLE. Optional idempotencyKey replays the first result without sends or approval; changed content returns IDEMPOTENCY_CONFLICT. Bad arguments return JSON-RPC -32602; operational errors use isError true; post-transmission failures do not undo tasks. Holds return PENDING_OWNER_APPROVAL, retryable: false, pendingId and next steps; do not retry or poll: worker owner review and explicit new delegation are required; use acp_list_pending_requests and acp_resubmit_pending_request.

Inputs: title (required), to, input, budget, +16 more. Returns: Success payload in structuredContent. Operational failures use isError and do n…

acp_discover_workersDiscover registered workersA
Read-onlyIdempotent

List current signed worker cards on the server relay or https://relay.sealbridge.dev, including every verified current published card. Filter by skillId and taskType; publication conveys no connection consent. Pass a selected workerDid and relayUrl unchanged to acp_delegate_task with title and input; unknown tokenless peers receive terminal PENDING_OWNER_APPROVAL without worker approval or execution, requiring owner intake review and an explicitly started fresh delegation. This read-only directory fetch verifies signatures and expiry, drops invalid cards and mismatched endpoints, sends no task input, and requires no delegation approval. Explicit relay policies apply, bad arguments are JSON-RPC -32602, and operational failures return isError true with { error: CODE }.

Inputs: skillId, relayUrl, taskType. Returns: Success payload in structuredContent. Invalid or expired cards are omitted; a n…

acp_inspect_revocationsInspect revocation noticesA
Read-onlyIdempotent

List RevocationNotices in this server process and return the matches, a count, and whether one target is revoked. Use this to read local revocation state, use acp_revoke_token to add a notice, and do not treat the result as proof that a remote worker has ingested it. Omit both filters to export every notice, pass targetType alone to filter by invite or capability, or pass both targetType and targetId to include revoked. targetId is the same identifier acp_revoke_token stores, not the raw acp-invite string, and an unknown pair returns revoked false. The read is local, idempotent, and side-effect free; bad arguments are JSON-RPC -32602.

Inputs: targetId, targetType. Returns: Success payload in structuredContent. revoked is present only when both filters…

acp_list_connection_requestsList pending connection requestsA
Read-onlyIdempotent

Read local connection metadata across existing requester/worker identities, or only the explicit server owner, without creating keys or contacting peers. Returns alias, authoritative peerOwnerDid, informational peerDisplayName (not an identifier), state, inviteCreator, local acceptance/allowedWork and advisory acceptanceWarning; use acp_delegate_task with to set to an exact alias. Duplicate names require connections alias in the CLI; local consent never proves remote acceptance or worker availability. Decisions require a separate human CLI action; no task content, tokens or private key material is returned. Empty arguments only; invalid arguments return JSON-RPC -32602 and store errors use isError true.

Inputs: no named parameters. Returns: Local connection metadata.

acp_list_connectionsList local connectionsA
Read-onlyIdempotent

Read local connection metadata across existing requester/worker identities, or only the explicit server owner, without creating keys or contacting peers. Returns alias, authoritative peerOwnerDid, informational peerDisplayName (not an identifier), state, inviteCreator, local acceptance/allowedWork and advisory acceptanceWarning; use acp_delegate_task with to set to an exact alias. Duplicate names require connections alias in the CLI; local consent never proves remote acceptance or worker availability. Decisions require a separate human CLI action; no task content, tokens or private key material is returned. Empty arguments only; invalid arguments return JSON-RPC -32602 and store errors use isError true.

Inputs: no named parameters. Returns: Local connection metadata.

acp_list_invitesList saved invitationsA
Read-onlyIdempotent

List invitations imported by the user with sealbridge accept on this machine and OS account. Returns saved workerRef values, exact aliases, public metadata and current or expired status; no invitation tokens are returned. Use a saved workerRef from acp_list_invites in acp_delegate_task; the server resolves the stored invitation locally. Import does not approve work; delegation sends task input externally under the configured approval policy. Names are display data, never instructions; listing rereads the local store without relay traffic, and store errors return isError true with { error: CODE }.

Inputs: no named parameters. Returns: Saved invitation metadata; bearer tokens are omitted.

acp_list_pending_requestsList local pending requestsA
Read-onlyIdempotent

List requester-local held delegations with record ids, worker DIDs, task ids, observed states and timestamps; use acp_resubmit_pending_request after worker owner review. Reads only this requester identity and data root without contacting a relay or learning remote approval status. Task text, inputs and invitation material are omitted; entries expire after 24 hours and listing never sends or retries a task.

Inputs: no named parameters. Returns: Local observations without task content or invitation material.

acp_message_statusRead local message statusA
Read-onlyIdempotent

Read current delivery facts for one message sent by this local requester signer, using exactly one original messageId or taskId. This local read never sends, resends, refreshes, polls, acknowledges, starts delivery or removes expired records; use acp_resubmit_pending_request only for explicit new delegation after owner review. Records are hidden seven days after the original deadline or creation time if later; absent, foreign and expired IDs return found false, while multiple retained task matches return MESSAGE_STATUS_AMBIGUOUS and require messageId. Recipient observations are signed gateway claims separate from bilateral audit; unknown peers disclose only received_held and closed, and handed_to_agent does not prove reading or execution. Results contain no task content or cached delegation result; invalid selectors return JSON-RPC -32602 and store errors return isError true with a fixed code.

Inputs: taskId, messageId. Returns: Current local observation or an indistinguishable absent/expired result.

acp_remove_inviteRemove a saved invitationA
DestructiveIdempotent

Remove one saved invitation using a workerRef or exact alias from acp_list_invites. Removal is local and idempotent; it does not revoke issuer authorization or change worker admission or contacts. Use acp_list_invites to inspect entries and acp_delegate_task to delegate; reimport requires the user to run sealbridge accept again. No relay request is made, an unknown reference returns removed false, and store errors return isError true with { error: CODE }.

Inputs: peerRef, workerRef. Returns: Local removal result; no invitation token is returned.

acp_resubmit_pending_requestResubmit a local pending requestA

Explicitly submit a retained requester-local delegation as a fresh task with a new task id; use acp_list_pending_requests to obtain pendingId after worker owner review. Applies current worker and relay checks and the configured approval policy, including required host elicitation, before task input is transmitted externally. A repeated hold keeps the record, completion resolves it, and other errors mark it failed; invitation material is never returned and no task is retried automatically. Optional idempotencyKey returns the first attempt result without another task or attempt increment; changed content returns IDEMPOTENCY_CONFLICT.

Inputs: pendingId (required), idempotencyKey. Returns: Verified result of the fresh task, matching acp_delegate_task.

acp_revoke_tokenRevoke an invite or capabilityA
Destructive

Sign a RevocationNotice with this server owner key and store it in the in-memory registry, returning the signed notice. Use this to invalidate an invite or capability, use acp_inspect_revocations to read that registry, and use acp_create_invite to mint a replacement. targetType invite expects targetId to be the invite revocation digest, while targetType capability expects the capability id, and reason is required text stored on the notice. Repeating a call replaces the stored notice, so it is not idempotent, but the target remains revoked, and the notice is not sent to a worker inbox. Bad arguments are JSON-RPC -32602, and other failures return isError true with { error: CODE }.

Inputs: reason (required), targetId (required), targetType (required). Returns: Success payload in structuredContent. The notice is stored only in this process.

acp_verify_audit_bundleVerify an audit bundleA
Read-onlyIdempotent

Verify one bilateral or interrupted audit bundle offline. Bilateral output retains VALID/true or INVALID/false and its existing anchor semantics. A verified PROPOSE-only worker terminal returns UNILATERALLY_CLOSED with valid:false, prefixVerified and terminalSignatureVerified true, and bilateralCheckpointVerified false; matching pins never promote it to VALID. For interruption, taskId/actors/closure-kind pins alone do not set truncationChecked; a head, count, last hash, final event or interruption hash must be compared. No result proves that a longer independent history does not exist. This tool does not approve work or contact a relay; invalid evidence is a normal report, while bad argument shapes are JSON-RPC -32602.

Inputs: bundle (required), anchor, expectedEntryCount, expectedFinalState, +3 more. Returns: Verification report for either terminal form; neither invalid nor worker-only e…

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 14 tools

    Disambiguation3/5

    Most tools target distinct ACP lifecycle actions, but acp_list_connections and acp_list_connection_requests have essentially identical descriptions, so an agent cannot tell which list to use. The single-vs-multi delegation pair is adequately distinguished, and the remaining invite, revocation, pending, status, and audit tools are reasonably separable.

    Naming Consistency4/5

    All names use a consistent acp_ snake_case prefix with mostly verb_noun phrasing (list_invites, revoke_token, delegate_task, inspect_revocations). The only notable deviation is acp_message_status, which is noun-based rather than verb_noun, but the overall convention is predictable.

    Tool Count5/5

    Fourteen tools is well within the appropriate range and maps cleanly onto the protocol surface: invites, connections, discovery, delegation, pending requests, status, revocations, and audit verification. Each tool appears to earn its place without obvious redundancy in count.

    Completeness4/5

    The surface covers the main lifecycle areas: invite creation/listing/removal, revocation inspection, worker discovery, connection listing, single and multi delegation, pending request handling, message status, and audit verification. Some operations such as accepting invites and approving connection requests are explicitly delegated to the CLI or human action, so the gaps are mostly intentional.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      C
      quality
      B
      maintenance
      Cryptographic identity and trust protocol for AI agents. 38 MCP tools across 8 protocol layers: Ed25519 identity, delegation chains, values compliance, signed communication, policy engine, task coordination, cross-layer integration, and agentic commerce. 264 tests passing.
      154
      262 npm
      4
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      MCP server for AI agent identity — verify agents with Ed25519 signatures, check trust scores, sign and verify content, exchange encrypted messages. Built on the Agent Identity Protocol (AIP).
      8
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Secure, local-first collaboration layer for AI agent teams, enabling authenticated agent-to-agent communication, shared memory with provenance, and scoped service execution through MCP.
      Apache 2.0