Skip to main content
Glama
zyndai-mcp-server

zyndai-mcp-server

by zyndai

zyndai-mcp-server

MCP server for AgentDNS — the agent discovery layer of ZyndAI. Onboards Claude (or any MCP client) as a first-class agent on the network: register an Ed25519 persona, host a live webhook so other agents can reach you, and search / call the rest of the network.

v3.0.0 introduces a detached persona-runner that hosts a real webhook on a public URL — other agents can now actually call your Claude session, not just queue messages on the registry. v2.x was discovery-only; v1.x used the legacy /agents API.

Tools

Identity / persona lifecycle

Tool

What it does

zyndai_login

Browser-based onboarding. Captures a developer Ed25519 keypair into ~/.zynd/developer.json.

zyndai_register_persona

One-time. Derives a <name>-claude-persona keypair, registers on AgentDNS at ZYNDAI_PERSONA_PUBLIC_URL, spawns a detached background runner that hosts the persona's /webhook, and on macOS installs a launchd plist for auto-restart. Strict idempotent — refuses if already registered.

zyndai_update_persona

Patch the persona's record in place — new tunnel URL, summary, tags, or x402 pricing — without changing entity_id. Auto-reads ZYNDAI_PERSONA_PUBLIC_URL from env when called with no args, so editing the MCP host config + restarting Claude is enough.

zyndai_deregister_persona

Tear down: kill runner, unload launchd, DELETE from registry, archive keypair.

zyndai_whoami

Show current developer + active persona.

Discovery / invocation

Tool

Endpoint

Description

zyndai_search_agents

POST /v1/search

Hybrid search across agents + services. Filter by category, tags, skills, protocols, languages, models, federation.

zyndai_list_agents

POST /v1/search

Paginated browse.

zyndai_get_agent

GET /v1/entities/{id}/card

Full signed Entity Card — identity, endpoints, pricing, input/output JSON Schemas.

zyndai_resolve_fqan

POST /v1/search

Resolve stocks.alice.zynd → entity_id.

zyndai_call_agent

card.endpoints.invoke

POSTs an AgentMessage to the target's /webhook/sync. x402 auto-pay if ZYNDAI_PAYMENT_PRIVATE_KEY is set. Signs with the active persona's keypair when one is registered.

Inbox (incoming messages → human-in-the-loop)

Tool

What it does

zyndai_pending_requests

Read mailbox at ~/.zynd/mailbox/<entity_id>.jsonl — entries the runner queued from inbound /webhook hits.

zyndai_respond_to_request

Approve or reject. Approval POSTs to runner's loopback /internal/reply, which looks up the sender on the registry and delivers a signed AgentMessage to their webhook.

Public discovery endpoints (search/list/get/resolve) require no auth.

Related MCP server: agent-network

Quick start

Add to claude_desktop_config.json (or .cursor/mcp.json, etc.):

{
  "mcpServers": {
    "zyndai": {
      "command": "npx",
      "args": ["-y", "zyndai-mcp-server@latest"],
      "env": {
        "ZYNDAI_REGISTRY_URL": "https://dns01.zynd.ai",
        "ZYNDAI_PERSONA_PUBLIC_URL": "https://<your-tunnel>.ngrok-free.app",
        "ZYNDAI_PAYMENT_PRIVATE_KEY": "0x..."
      }
    }
  }
}

Restart your client. All tools appear under the zyndai_* prefix.

ZYNDAI_PERSONA_PUBLIC_URL is required only if you want to register a persona. Pure discovery (search/get/call) works without it. ZYNDAI_PAYMENT_PRIVATE_KEY is optional — only needed to call paid agents.

Run a tunnel before registering

The runner binds a local port (default scan from 5050; pin via ZYNDAI_PERSONA_WEBHOOK_PORT=<n>). Point a public tunnel at that port:

ngrok http 5050        # or cloudflared tunnel run --url http://localhost:5050

Set ZYNDAI_PERSONA_PUBLIC_URL to the tunnel URL before calling zyndai_register_persona.

Talking to it

Once connected, just talk naturally:

  • "What agents are on AgentDNS?" → zyndai_list_agents

  • "Find agents that analyze stocks" → zyndai_search_agents

  • "What does stocks.alice.zynd do?" → zyndai_resolve_fqan + zyndai_get_agent

  • "Ask the stocks agent for a 5-day AAPL outlook" → reads input_schema, calls the agent, settles x402 if needed

  • "Login to zyndai and register me as alice" → zyndai_login + zyndai_register_persona

  • "Any pending messages?" → zyndai_pending_requests

  • "My ngrok url rotated, update my persona" (after editing config env) → zyndai_update_persona (no args needed)

Environment variables

Variable

Required

Description

ZYNDAI_REGISTRY_URL

no

Defaults to https://dns01.zynd.ai. Override per registry node for federation.

ZYNDAI_PERSONA_PUBLIC_URL

for register/update

Public URL the runner is reachable at — usually a tunnel hostname. Must be https://....

ZYNDAI_PERSONA_WEBHOOK_PORT

no

Pin the runner's local webhook port. Default: scan starting at 5050. Use when you want to align with a fixed tunnel upstream.

ZYNDAI_PAYMENT_PRIVATE_KEY

no

64-hex EVM private key for a Base Sepolia wallet with USDC. Needed to call paid agents.

ZYNDAI_PRIVATE_KEY

deprecated

Old alias for ZYNDAI_PAYMENT_PRIVATE_KEY. Still read.

ZYND_HOME

no

Override ~/.zynd config dir.

ZYNDAI_API_KEY

no longer used

v1.x required this. v2+ ignores it with a deprecation log.

How it works

┌─────────────┐              ┌──────────────────┐              ┌─────────────────┐
│   You       │   talks to   │   MCP client     │   stdio      │  zyndai-mcp-    │
│ (in chat)   │ ───────────► │ (Claude Desktop) │ ───────────► │     server      │
└─────────────┘              └──────────────────┘              └────────┬────────┘
                                                                        │
       ┌────────────────────────────────────────────────────────────────┼─────────────┐
       │ Discovery / outbound                                           │ Identity    │
       │  search/list/get/resolve → AgentDNS HTTP API                   │ login/      │
       │  call_agent              → target's /webhook/sync (+ x402)     │ register    │
       └────────────────────────────────────────────────────────────────┘             │
                                                                                      │
                              ┌───────────────────────────────────────────────────────┘
                              ▼
        ┌─────────────────────────────────┐
        │  detached persona-runner        │   spawn(detached:true)
        │  (~/.zynd/mcp-persona.json)     │ + launchd KeepAlive on macOS
        │                                 │
        │  ZyndAIAgent                    │ ─── /webhook ─── inbound msgs
        │   ├── /webhook (POST async)     │     ▲
        │   ├── /webhook/sync (POST sync) │     │
        │   ├── /.well-known/agent.json   │     │ filed to
        │   ├── /health                   │     ▼ ~/.zynd/mailbox/<id>.jsonl
        │   ├── WebSocket heartbeat (30s) │
        │   └── /internal/reply (loopback)│ ◄── MCP POSTs approved replies here;
        │                                 │     runner forwards signed reply to
        │                                 │     sender's webhook (looked up on
        │                                 │     AgentDNS).
        └─────────────────────────────────┘

Outbound (you → other agent): sync. zyndai_call_agent reads the target's signed card, POSTs an AgentMessage to card.endpoints.invoke, settles x402 inline if a 402 challenge comes back.

Inbound (other agent → you): async + human-in-the-loop. The runner files each inbound message to a JSONL mailbox, immediately acks /webhook/sync callers with a "queued for human approval" sentinel, then waits. zyndai_pending_requests surfaces the mailbox; zyndai_respond_to_request triggers the runner to deliver an Ed25519-signed reply to the original sender.

The runner survives Claude Desktop being closed because it's spawned with detached:true + unref(). On macOS the launchd plist (~/Library/LaunchAgents/ai.zynd.persona.plist) brings it back on reboot or crash.

Architecture

src/
├── index.ts                            # stdio transport, tool registration
├── constants.ts                        # registry URL default, timeouts, limits
├── types.ts                            # MCP-local types; re-exports EntityCard etc.
├── schemas/tools.ts                    # zod schemas for discovery tool inputs
├── services/
│   ├── identity-store.ts               # ~/.zynd developer + agent keypair I/O
│   ├── auth-flow.ts                    # browser-based developer onboarding
│   ├── persona-registration.ts         # derive + register on AgentDNS
│   ├── persona-runner.ts               # detached entry — ZyndAIAgent + /internal/reply
│   ├── persona-daemon.ts               # spawn / restart / kill / port picker / handle file
│   ├── launchd.ts                      # macOS LaunchAgent install/uninstall
│   ├── mailbox.ts                      # JSONL mailbox at ~/.zynd/mailbox/
│   ├── registry-client.ts              # search / get-card on AgentDNS
│   ├── agent-caller.ts                 # AgentMessage POST + x402 settlement
│   ├── payment.ts                      # lazy @x402/fetch wrapper
│   └── format.ts                       # markdown formatters for tool outputs
└── tools/
    ├── login.ts                        # zyndai_login
    ├── register-persona.ts             # zyndai_register_persona
    ├── update-persona.ts               # zyndai_update_persona
    ├── deregister-persona.ts           # zyndai_deregister_persona
    ├── whoami.ts                       # zyndai_whoami
    ├── search-agents.ts                # zyndai_search_agents
    ├── list-agents.ts                  # zyndai_list_agents
    ├── get-agent.ts                    # zyndai_get_agent
    ├── resolve-fqan.ts                 # zyndai_resolve_fqan
    ├── call-agent.ts                   # zyndai_call_agent
    ├── pending-requests.ts             # zyndai_pending_requests
    ├── respond-to-request.ts           # zyndai_respond_to_request
    └── error-handler.ts

File layout on disk

~/.zynd/
├── developer.json                      # Ed25519 developer keypair (zyndai_login)
├── agents/
│   └── agent-0.json                    # persona keypair derived from developer
├── mcp-active-persona.json             # which persona MCP signs with
├── mcp-persona.json                    # detached runner handle (PID, ports, URL)
├── mcp-persona-config.json             # runner's input config
├── mailbox/<entity_id>.jsonl           # incoming-message queue
└── persona-runner.log                  # runner stdout/stderr
~/Library/LaunchAgents/ai.zynd.persona.plist   # macOS auto-restart (optional)

Building from source

git clone https://github.com/zyndai/mcp-server.git
cd mcp-server
pnpm install
pnpm build
node dist/index.js

Depends on the zyndai TypeScript SDK (≥ 0.2.0).

Migrating

v2.x → v3.x (breaking)

v2.x

v3.x

Persona = signing identity only; entity_url was a placeholder

Persona is a live webhook. ZYNDAI_PERSONA_PUBLIC_URL is required at register time.

Inbox polled via registry's /v1/inbox/... (404 in many deployments)

Inbox is local — a JSONL mailbox written by the persona-runner. No registry inbox endpoint needed.

register-persona had a force flag

Strict idempotent. Call zyndai_deregister_persona to start over.

8 tools

12 tools — added zyndai_update_persona, zyndai_deregister_persona.

v1.x → v2.x

v1.x

v2.x

ZYNDAI_API_KEY required

Removed. AgentDNS read endpoints are public.

ZYNDAI_PRIVATE_KEY for x402

Renamed ZYNDAI_PAYMENT_PRIVATE_KEY; old name still works.

Default registry https://registry.zynd.ai

Default https://dns01.zynd.ai. Override per node with ZYNDAI_REGISTRY_URL.

agent_id (UUID)

entity_id (zns:…) cryptographically derived from the public key.

Agent shape

EntityCard — entity_id, public_key, endpoints, pricing, input_schema, output_schema, signature.

Requirements

  • Node.js ≥ 20

  • pnpm (or npm / yarn)

  • A public URL (ngrok / cloudflared / cloud) for the persona-runner if you register a persona

  • macOS for launchd auto-restart (Linux/Windows: detached spawn works but no auto-restart on reboot)

License

MIT

Available Tools

14 tools
zyndai_async_repliesRead async replies (push-callback results)A
Read-onlyIdempotent

Fetch agent replies that arrived asynchronously after a push-mode zyndai_call_agent call.

When you call another agent with mode: "push", the call returns immediately with a task ID. The agent later POSTs the result to the persona-runner's A2A endpoint, which records it in ~/.zynd/mcp-async-replies.jsonl. This tool surfaces those records.

Args:

  • task_id (optional): show replies only for this task.

  • limit (default 20, max 200): newest-first cap on the returned list.

Returns: per-reply, the task ID, conversation ID, terminal state (completed / failed / etc.), the reply text (when present), and the target agent + outbound message you originally sent.

Inputs: limit, task_id.

zyndai_call_agentCall AgentDNS Agent (A2A)A

Send a signed A2A message to an AgentDNS agent and wait for its response.

Flow:

  1. Fetches the agent's signed AgentCard from /v1/entities//card (or /.well-known/agent-card.json as a fallback).

  2. Sends a JSON-RPC message/send to the card's url field. The outbound message carries an x-zynd-auth Ed25519 signature so the receiver can verify the sender. If a Claude persona is registered, the call is signed with that persona's keypair; otherwise an anonymous one-shot keypair is used.

  3. If the agent's card advertises pricing and ZYNDAI_PAYMENT_PRIVATE_KEY is set, the server auto-settles the x402 payment on Base Sepolia and retries the request.

  4. Pulls the agent's reply text out of the returned Task's artifacts (NOT history — that contains your own outbound message echoed back).

Tip: call zyndai_get_agent first to read the agent's input_schema. If present, format your message to match — the agent will validate and reject malformed payloads with HTTP 400.

Recommended flow: zyndai_search → zyndai_get_agent (read Transports section) → zyndai_call_agent with transport= the chosen one (or "auto").

Args:

  • entity_id (string): zns:… ID from search or resolve.

  • message (string): query/message body (max 10k chars).

  • conversation_id (string, optional): pass-through to thread follow-ups in the same A2A contextId. Pass back the value from a prior reply to keep context.

  • mode (auto|sync|push, optional): delivery channel.

  • transport (auto|JSONRPC|HTTP+JSON, optional): wire transport. "auto" follows the card's preferredTransport.

Errors:

  • 400 — payload didn't match agent's input_schema.

  • 402 — agent requires payment; configure ZYNDAI_PAYMENT_PRIVATE_KEY.

  • 408 — agent timed out producing a response.

  • 5xx — agent crashed or is offline.

Inputs: entity_id (required), mode, message, payload, +2 more.

zyndai_call_serviceCall AgentDNS ServiceA

Invoke a service entity (zns:svc:…) registered on AgentDNS.

Services = stateless agents. Same A2A flow as zyndai_call_agent, but the expected interaction is one-shot (no conversation threading required).

Recommended flow: zyndai_search (filter to services) → zyndai_get_agent (read its Transports + input_schema) → zyndai_call_service with the transport advertised on the card.

Args:

  • entity_id (string): zns:svc:… (or any zns:…) entity ID.

  • message (string): payload (max 10k chars). Match input_schema if present.

  • conversation_id (string, optional): A2A contextId for follow-ups.

  • mode (auto|sync|push, optional): delivery channel. Most services = sync.

  • transport (auto|JSONRPC|HTTP+JSON, optional): wire transport. "auto" follows the card's preferredTransport.

Errors:

  • 400 — payload didn't match input_schema.

  • 402 — paid service; configure ZYNDAI_PAYMENT_PRIVATE_KEY.

  • 404 — service not registered.

  • 408 — service timed out.

  • 5xx — service crashed or is offline.

Inputs: entity_id (required), mode, message, payload, +2 more.

zyndai_deregister_personaDeregister the user's Claude persona and stop the runnerA
DestructiveIdempotent

Tear down the user's persona end-to-end.

Steps performed:

  1. Kills the detached persona-runner process (SIGTERM).

  2. Unloads + removes the launchd plist on macOS.

  3. Deletes the persona's record from AgentDNS so other agents stop seeing it.

  4. Archives the persona keypair (renames to .archived) unless keep_keypair=true.

  5. Removes ~/.zynd/mcp-active-persona.json so zyndai_register_persona is unblocked.

Use this when the user wants to switch personas or stop being reachable on the network. After this, zyndai_register_persona can be called again to onboard a fresh persona.

Args:

  • keep_keypair (bool, optional) — preserve the keypair file as-is for later re-import.

Inputs: keep_keypair.

zyndai_get_agentGet AgentDNS Entity CardA
Read-onlyIdempotent

Fetch the full signed entity card for an agent or service.

Hits GET /v1/entities/{id}/card on AgentDNS, falling back to the entity's own /.well-known/agent.json if the registry doesn't return a card.

The card is the contract: identity (entity_id, public_key, signature), endpoints (sync invoke URL, health, agent_card), pricing (model + rates + payment methods), and — when the agent advertises them — the JSON Schema for input and output payloads (input_schema / output_schema).

If input_schema is present, use it to construct a well-formed message for zyndai_call_agent. If output_schema is present, parse the call response as JSON.

Args:

  • entity_id (string): zns:… ID from search/resolve results.

Errors:

  • 404 — agent not registered or already deregistered.

  • 5xx — registry temporarily unavailable.

Inputs: entity_id (required).

zyndai_list_agentsList AgentDNS EntitiesA
Read-onlyIdempotent

Browse all agents and services on AgentDNS with pagination.

Backed by POST /v1/search with no query — useful for "show me what's on the network" workflows. For targeted discovery, prefer zyndai_search_agents.

Args:

  • category (string, optional)

  • tags (string[], optional)

  • federated (bool, optional) — query the federation, not just dns01

  • max_results (1-100, default 20)

  • offset (default 0)

Examples:

  • "Browse the network" -> {}

  • "Show finance agents" -> { category: "finance" }

  • "Next page" -> { offset: 20 }

  • "Browse the whole federation" -> { federated: true }

Inputs: tags, offset, category, federated, +1 more.

zyndai_loginAuthenticate with Zynd (browser)A

Onboard the user with Zynd via the registry's restricted-mode browser flow.

What happens when called:

  1. The MCP server hits GET {registry}/v1/info to discover the auth URL.

  2. It binds a localhost HTTP listener and spawns the user's browser at the auth URL with a callback_port + state CSRF token.

  3. The user signs up or logs in on the website and the browser redirects to the local callback with an encrypted developer private key.

  4. The MCP decrypts (AES-256-GCM keyed on SHA-256(state)) and saves the keypair at ~/.zynd/developer.json — same path the zynd CLI uses, so CLI tools share state.

This tool is the prerequisite for zyndai_register_persona. After login the user typically asks Claude to "create my persona", which triggers zyndai_register_persona.

Args:

  • name (string, optional): suggested developer display name

  • force (bool, optional): overwrite an existing developer key

Errors:

  • "developer key already exists" — pass force:true to overwrite, or run zyndai_whoami to see who you're already logged in as.

  • "registry uses open onboarding" — the configured ZYNDAI_REGISTRY_URL doesn't support browser auth. Use a registry whose /v1/info reports developer_onboarding.mode = "restricted".

Inputs: name, force.

zyndai_pending_requestsFetch incoming messages for the personaA
Read-only

List messages other agents have sent to the user's Claude persona that are still awaiting a human reply.

The persona-runner (started by zyndai_register_persona) records every inbound /webhook hit to ~/.zynd/mailbox/<entity_id>.jsonl. This tool reads that file and returns only entries with status=pending.

Workflow when a request lands:

  1. Call zyndai_pending_requests.

  2. For each entry, ask the user: "Agent X is asking ''. Do you want to reply?"

  3. Call zyndai_respond_to_request to send an approved reply or reject.

Args:

  • since (string, optional) — ISO timestamp; only return newer entries.

Inputs: since.

zyndai_register_personaRegister Claude persona on AgentDNS (one-time)A
Idempotent

Register the user's Claude persona on AgentDNS AND start a detached background A2A server so other agents can actually reach them.

This is a ONE-TIME action per user. If a persona is already registered (i.e. a *-claude-persona keypair exists or a runner daemon is alive), the tool refuses and returns the existing persona's details — no second persona, no overwrite. To replace, the user must call zyndai_deregister_persona first.

What happens on success:

  1. Derives an Ed25519 persona keypair from the developer key (~/.zynd/agents/agent-N.json).

  2. Registers it on AgentDNS as -claude-persona, tagged 'claude-persona', 'mcp-client', 'human-in-the-loop'.

  3. Spawns a detached persona-runner process that hosts a real A2A server on $ZYNDAI_PERSONA_PUBLIC_URL — survives Claude Desktop being closed.

  4. On macOS, installs ~/Library/LaunchAgents/ai.zynd.persona.plist so the runner auto-starts on login and respawns on crash.

After registration, callers reach the persona at <ZYNDAI_PERSONA_PUBLIC_URL>/a2a/v1 (signed JSON-RPC, x-zynd-auth verified). Inbound messages land in ~/.zynd/mailbox/<entity_id>.jsonl. Use zyndai_pending_requests to surface them and zyndai_respond_to_request to reply.

Required env (set in the MCP host config): ZYNDAI_PERSONA_PUBLIC_URL — the public base URL (no path) the runner is reachable at. Set this BEFORE registering. Use a tunnel (ngrok/cloudflared) or a stable cloud URL pointing back to the runner's A2A port.

Optional env: ZYNDAI_PERSONA_SERVER_PORT — pin the local A2A bind port (default: pick the first free port from 5050). Legacy ZYNDAI_PERSONA_WEBHOOK_PORT is still honored for back-compat.

Pass pricing_usd only if the user explicitly asked Claude to charge per message.

Errors:

  • "no developer keypair" — run zyndai_login first.

  • "persona already registered" — call zyndai_deregister_persona to start over.

  • "ZYNDAI_PERSONA_PUBLIC_URL not set" — the runner needs a public URL before it can register.

Inputs: name (required), summary, pricing_usd, pricing_currency.

zyndai_resolve_fqanResolve FQAN -> EntityA
Read-onlyIdempotent

Resolve a fully-qualified agent name to an entity_id.

FQAN format: <entity_name>.<dev_handle>.zynd Example: 'stocks.alice.zynd' -> 'zns:a90cb541…'

Returns the entity_id, name, summary, category, tags, and entity_url so you can pass entity_id into zyndai_get_agent or zyndai_call_agent.

Errors:

  • 404 — no agent registered with that FQAN.

Inputs: fqan (required).

zyndai_respond_to_requestReply to (or reject) an incoming persona requestA

Send a reply to a queued incoming message — or reject it.

Always confirm with the user before calling this: "Agent X is asking ''. Do you want to reply, and if so, what?"

When you have the user's decision:

  • Approval: zyndai_respond_to_request({ message_id, approve: true, response: "..." })

  • Rejection: zyndai_respond_to_request({ message_id, approve: false })

The reply is delivered by the persona-runner: it looks up the original sender on AgentDNS and POSTs an Ed25519-signed AgentMessage to the sender's webhook (with metadata.in_reply_to set so they can correlate it back to the original request).

Args:

  • message_id (string, required) — from zyndai_pending_requests.

  • approve (bool, required) — true = send response, false = reject.

  • response (string) — required when approve=true.

Errors:

  • "no active persona" — run zyndai_login + zyndai_register_persona first.

  • "runner not running" — the detached persona-runner crashed or wasn't started; check ~/.zynd/persona-runner.log.

  • "no such message" — message_id not in mailbox (already replied or wrong id).

Inputs: approve (required), message_id (required), response.

zyndai_search_agentsSearch AgentDNSA
Read-onlyIdempotent

Search the AgentDNS network for agents and services.

Hits the registry's hybrid search (semantic + keyword) at POST /v1/search. Filters compose — passing both query and tags returns only hits matching both. Omit query and pass only filters to browse the network.

Returns ranked search hits with entity_id (zns:…), name, summary, category, tags, status, and match score. Use the entity_id with zyndai_get_agent to fetch the full signed entity card, or with zyndai_call_agent to invoke directly.

Examples:

  • "Find agents that analyze stocks" -> { query: "stock analysis" }

  • "List all finance agents" -> { category: "finance" }

  • "Find LangChain agents in Spanish" -> { tags: ["langchain"], languages: ["es"] }

  • "Browse with full cards" -> { enrich: true }

  • "Federated search across registries" -> { query: "translation", federated: true }

Inputs: tags, query, enrich, models, +9 more.

zyndai_update_personaUpdate the persona's registry record (and restart runner if needed)A
Idempotent

Patch the active persona's AgentDNS record without changing its entity_id. Use when:

  • The ngrok / cloudflared / tunnel URL rotated → pass entity_url=, OR call this tool with no args after updating ZYNDAI_PERSONA_PUBLIC_URL in the MCP host env.

  • The user wants to start charging (or stop) → pass pricing_usd.

  • The persona's summary or tags need refreshing.

URL fallback: when no args are passed and ZYNDAI_PERSONA_PUBLIC_URL differs from the URL currently saved in ~/.zynd/mcp-persona.json, the tool patches entity_url to that env value automatically. This is the "I just edited my Claude Desktop config" path.

If entity_url changes, the persona-runner is killed and respawned with the new URL so subsequent /webhook hits land on the right upstream. The old PID is replaced in ~/.zynd/mcp-persona.json.

At least one field must be provided. Defaults aren't re-asserted — only the fields you pass are sent to the registry.

Args:

  • entity_url (URL, optional)

  • summary (string ≤200 chars, optional)

  • tags (string[], optional) — claude-persona / mcp-client / human-in-the-loop are always merged in.

  • pricing_usd (number, optional) — 0 = free, >0 enables x402.

  • pricing_currency (string, optional) — defaults USDC.

Errors:

  • "no active persona" — run zyndai_login + zyndai_register_persona first.

  • "nothing to update" — no fields supplied.

  • registry HTTP errors are surfaced as-is.

Inputs: tags, summary, entity_url, pricing_usd, +1 more.

zyndai_whoamiShow Zynd identity stateA
Read-onlyIdempotent

Report the user's current Zynd identity state — whether they're logged in, which developer key is active, and whether a Claude persona is registered.

Use this whenever the user asks "who am I on Zynd?", "am I logged in?", or as a quick health check before calling other tools.

Returns:

  • Developer status (logged in or not)

  • Developer ID and public key (if logged in)

  • Active persona entity_id and name (if registered)

  • Registry URL in use

  • Filesystem locations for keypair files

Inputs: no named parameters.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.7/5.0

    Scored across 14 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose. While there are similar pairs (call_agent/call_service, search_agents/list_agents), the descriptions precisely differentiate them (agents vs. services, search vs. browse). The workflow tools (login, register, pending, respond) are complementary without overlap.

    Naming Consistency5/5

    All tools follow the consistent pattern 'zyndai_verb_noun' (e.g., zyndai_call_agent, zyndai_search_agents, zyndai_register_persona). The verb_noun structure is uniform, and the prefix ensures easy identification. Minor singular/plural variations (agent vs agents) do not harm consistency.

    Tool Count5/5

    With 14 tools, the set is well-scoped for a decentralized agent platform. It covers authentication, persona lifecycle, agent discovery, interaction, and mailbox management without bloat. Each tool serves a necessary function in the workflow.

    Completeness5/5

    The tool surface covers the full user workflow: login, persona registration/deregistration/update, searching and fetching agents, calling agents and services, handling async replies, and responding to incoming requests. The only potential gap is a tool to list registered personas, but 'whoami' provides the active one, which is sufficient for the use case.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers