Skip to main content
Glama

Sato Hub: Build Onchain & Crypto Agents

Join Sato Hub: a free passport, signed with the agent's wallets

onchain_agent_join_passport

USE WHEN an agent, or the person building it, wants a public Sato Passport by signing with the agent's own wallets: one free step, EVM and Solana wallets, no account and no review queue. This WRITES a public passport. NOT FOR changing a passport that already exists (use onchain_agent_passport_action), the older form-style registration that also takes a profile (use onchain_agent_register_agent) or reading a passport (use onchain_agent_get_agent_passport).

TWO CALLS. First send wallets (the addresses: up to 4 EVM and 4 Solana, one entry each) and primary (an EVM wallet, when there is one) with NO signatures. The answer is the exact message each wallet must sign and the issued_at to send back; nothing is written. Sign each message with that wallet's own key (EVM: EIP-191 personal_sign; Solana: ed25519 over the UTF-8 bytes, base58). Then call again with the same fields, each signature and that issued_at (valid for ten minutes). The agent's wallet signs; this tool never asks for a key.

WHAT SIGNING PROVES: that the signer controlled that wallet's key at that moment and agreed to a message that says it moves no funds. It proves nothing about the agent, its code or its owner. The passport is public from the moment it is created and stays Self-Reported. Joining is free and earns no points. One wallet belongs to one passport.

OPTIONAL: name (3-80 characters, exactly as it will be shown; with none the passport gets a friendly one like sunny-otter-agent) and claim_sha256, the digest of an owner claim code the agent generated itself (the server never sees the code), so its owner can link the passport to a Sato Hub account later.

LIMIT: 5 write calls an hour per caller; the first, unsigned call does not count.

RETURNS (json): first call { ok, step: "sign", messages: [{ wallet, message }], issued_at, valid_until, next }; a join { ok, passport_id, slug, name, lookup_url, profile_url, wallets, claim, next, note? }. A wallet an older passport merely lists, without proof, does not stop a join: the answer carries a note. A refusal names a stable code, for example wallet_taken, bad_signature, stale or ip_quota (too many new passports from one address this hour; the answer says when to retry).

Example: { wallets: [{ address: "0x…" }], primary: "0x…", name: "Example Agent" } then the same with { wallets: [{ address: "0x…", signature: "0x…" }], issued_at: "" }

Input Schema

NameRequiredDescriptionDefault
nameNoThe passport's display name, 3-80 characters, exactly as it will be shown (it is part of what is signed). Leave it out for a friendly default like sunny-otter-agent.
primaryNoThe primary EVM wallet (one of `wallets`; it receives the onchain records). Required when any wallet is EVM; leave it out for a Solana-only passport.
walletsYesThe wallets that join, each { address, signature? }: up to 4 EVM and 4 Solana, one entry per wallet, each signing its own message. One wallet belongs to one passport.
issued_atNoISO 8601 UTC with milliseconds, like 2026-10-21T18:04:05.123Z; valid for ten minutes. Leave it out on the first (unsigned) call: the answer gives the one to sign with, and you send it back unchanged.
claim_sha256NoOptional: the SHA-256 digest of an owner claim code the agent generated itself (claimCodeDigest in the kit), so the owner can link the passport to a Sato Hub account later. The code itself never reaches the server.
response_formatNoText format; structuredContent is JSON either way.markdown

Schema Changelog

Changes observed during successful MCP inspections.

  1. Added

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations only declare the generic safety profile; the description goes far beyond it with the two-call sign-then-submit protocol, ten-minute issued_at validity, a 5-write-per-hour limit that exempts the first call, free/no-points economics, public-from-creation and Self-Reported status, one-wallet-one-passport constraint, and named refusal codes including ip_quota. It also states what the signature does and does not prove, which is materially useful for an agent deciding whether to proceed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Despite its length, it is front-loaded with the trigger, then the exclusions, then the protocol, then limits and returns, each under a capitalised header. Dense rather than padded, though the WHAT SIGNING PROVES paragraph is slightly editorial for a tool definition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

There is no output schema, so the description carries the return burden and does so precisely, giving both the first-call shape ({ok, step, messages, issued_at, valid_until, next}) and the join shape (passport_id, slug, lookup_url, claim, note?). It also covers the edge case where an older passport merely lists a wallet, which an agent would otherwise mishandle.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is already 100%, so the baseline is 3; the description earns extra by explaining the cross-call semantics the schema cannot: that the first call takes no signatures and returns the exact messages plus issued_at to echo back, and that claim_sha256 lets an owner link the passport later without the code reaching the server. It stops short of detailing the response_format parameter, but that is minor.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (join) and resource (Sato Hub passport) plus the mechanism (signing with the agent's own wallets, free, one step). It explicitly distinguishes itself from three sibling tools by name, so an agent can route without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The 'USE WHEN' / 'NOT FOR' structure names each alternative and the exact condition that selects it: onchain_agent_passport_action for changing an existing passport, onchain_agent_register_agent for the older form-style registration, onchain_agent_get_agent_passport for reading. Exclusions are as explicit as the inclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.