Pre-delegation semantic handshake — full $0.25 / budget $0.10 (first full free once per operator+wallet)
ConnectorNo auth
701,824 tools. Updated 2026-10-25 16:34
"Handshake" matching MCP tools:
- Introduce yourself. Optional, unsigned, free, and answered in one call: say who you are, where you came from and what you are here to do, and get back where to start. Without it this hub describes you by your address and your HTTP library. Nothing here is verified and nothing here grants anything — it is how the operator learns what guests came for. Every field is optional; an empty call still greets you.ConnectorNo auth
- Bot meets bot: ask 'Are you on Trust Switch?' before dealing with another agent or vendor. Records yes/no. While activation is off (default) business proceeds either way. Not a recommend gate; use trust_check for that.ConnectorNo auth
- Start the purchase flow for a domain using USDC crypto payment (x402 protocol). Autonomous two-step payment flow — no browser required: Step 1: Call this tool to reserve the domain and get a pay_url. Step 2: Pay the pay_url using your x402 wallet: - If you have Coinbase Payments MCP: call its x402 payment tool with the pay_url. - Otherwise: run `curl -L <pay_url>` — your x402-enabled HTTP client will handle the 402 handshake and USDC payment on Base automatically. After payment succeeds, call get_domain_status(order_id) to poll until registration is complete (usually under 60 seconds). The registrant contact details are required because the domain will be registered in the buyer's name (they become the legal owner). WHOIS privacy is enabled by default, so these details are not publicly visible. IMPORTANT: Before calling this tool, you MUST first call check_domain to get the price and confirm it with the user. Args: domain: The domain to purchase (e.g. "coolstartup.com"). first_name: Registrant's first name. last_name: Registrant's last name. email: Registrant's email address. address1: Registrant's street address. city: Registrant's city. state: Registrant's state or province. postal_code: Registrant's postal/zip code. country: 2-letter ISO country code (e.g. "US", "GB", "DE"). phone: Phone number in format +1.5551234567. org_name: Organization name (optional, leave empty for individuals). Returns: Dict with order_id, pay_url (full URL to pay via x402), price_usdc, price_cents, network, and USDC contract address.ConnectorNo auth
- Readiness audit of any agent-facing URL: MCP handshake, CORS, discovery docs (llms.txt, mcp.json), and payment-offer behaviour. First call with url alone for the FREE grade and failing-check list. For the full findings and remediations, call get_offer with productType "audit" and productId "conformance-report", pay, then call audit_endpoint again with the same url plus paymentTx and paymentOffer. This tool both previews and redeems the paid report; no separate delivery tool is needed.ConnectorNo auth
- [FREE] Find out whether you can complete a payment to an x402 endpoint RIGHT NOW, before you sign anything. This answers a different question from check_x402_endpoint, which grades a seller's 402. This one runs the buyer's side of the handshake end to end: it reads the endpoint's terms, confirms they are complete enough to sign, calls the facilitator they name to see whether it actually answers /supported and /verify, prices the settlement against live Base gas and the Chainlink ETH/USD feed, and - when you pass a wallet - reads your on-chain balance to confirm it covers the price. Returns verdict.can_pay_now, a blocking list naming anything that genuinely stops the payment, and a warnings list for defects you can work around yourself. Two things it reports the way a buyer actually experiences them: * A missing or dead facilitator is a WARNING, not a blocker, because you can carry your own. * Gas is NOT needed to pay. Settling through a facilitator means signing an EIP-3009 authorization while the facilitator broadcasts, so the gas figures apply only if you broadcast the settlement yourself. endpoint_url is the full URL. method is the verb the endpoint expects, GET or POST. wallet is an optional 0x address; pass it to check funding and self-broadcast headroom. Free, unauthenticated, and it never sends a payment.ConnectorNo auth
Matching MCP Servers
- AlicenseAqualityDmaintenanceEnables AI assistants to search and apply for jobs on Handshake, track applications, and research employers using your browser session.122MIT
- AlicenseAqualityBmaintenanceEnables AI agents to list, retrieve, add, and audit credentials from an encrypted vault during an active human-unlocked session, while providing no tool to unlock the vault itself.5Apache 2.0
Matching MCP Connectors
Search and compare live vehicles from participating US and Canadian dealers outside Quebec.
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"whoami","arguments":{}}} free no key
- [FREE] Find out whether you can complete a payment to an x402 endpoint RIGHT NOW, before you sign anything. This answers a different question from check_x402_endpoint, which grades a seller's 402. This one runs the buyer's side of the handshake end to end: it reads the endpoint's terms, confirms they are complete enough to sign, calls the facilitator they name to see whether it actually answers /supported and /verify, prices the settlement against live Base gas and the Chainlink ETH/USD feed, and - when you pass a wallet - reads your on-chain balance to confirm it covers the price. Returns verdict.can_pay_now, a blocking list naming anything that genuinely stops the payment, and a warnings list for defects you can work around yourself. Two things it reports the way a buyer actually experiences them: * A missing or dead facilitator is a WARNING, not a blocker, because you can carry your own. * Gas is NOT needed to pay. Settling through a facilitator means signing an EIP-3009 authorization while the facilitator broadcasts, so the gas figures apply only if you broadcast the settlement yourself. endpoint_url is the full URL. method is the verb the endpoint expects, GET or POST. wallet is an optional 0x address; pass it to check funding and self-broadcast headroom. Free, unauthenticated, and it never sends a payment.ConnectorNo auth
- Open the browser-confirmation handshake to clear a Lane 2 wallet's AGNTA grant cap. Call this when clear_agnta_grant refuses with BROWSER_CONFIRMATION_REQUIRED. Does NOT clear the grant -- returns a confirmation URL like request_wallet_policy_loosening; the wallet's OWNER must approve in their own browser (never in-chat). Poll with poll_agnta_grant_clear(device_code) once approved.ConnectorNo auth
- Read stored health verdicts for up to 25 MCP servers you already intend to call. Use at startup to vet that list. Do not use it for a live handshake or auth detail (check_mcp_server_health) or to discover servers by capability (find_alternative_mcp_servers). Does not contact the remotes and never spends a live-check credit. Each name still counts as one Toolweather quota call; over quota the batch is one x402 charge ($0.01). Returns summary, checked_at, and results[] with the same verdict fields as a single check. Unknown names come back verdict unknown.ConnectorNo auth
- [cost: external_io (DNS via Cloudflare + Google; TLS handshake + a SIP OPTIONS keepalive to public targets when applicable) | read-only | rate-limited per IP: 10/min, 200/day] Walk DNS the same way a SIP UA does (RFC 3263 §4.1): NAPTR → SRV → A/AAAA. Given a SIP URI ("sip:example.com"), bare hostname ("example.com"), or "host:port" string, return the records that exist and the resolution ladder a UA would try. When the queried target uses TLS (`sips:` URI, `transport=tls/wss`, or any `_sips._tcp` SRV record), the tool also performs a TLS handshake against each resolved sips target and reports the negotiated TLS version + cipher, the leaf certificate's subject / issuer / SANs / validity, the chain length and whether it validates against Node's default trust store, plus two cert-domain checks: RFC 5922 §7.2 strict (cert must cover the original SIP domain) and a lenient SAN match against the SRV target hostname. SIP liveness: DNS resolving and a TLS handshake succeeding do NOT prove the endpoint actually speaks SIP - a load-balanced node can accept TCP/TLS yet black-hole SIP. So the tool ALSO sends a real SIP OPTIONS keepalive to each resolved public IP across the relevant transports (UDP/TCP on 5060, TLS on 5061 / SRV port) and reports per-IP answered / timeout / refused. Any SIP response (even 405/403/404) proves the stack is alive on that IP. When a name resolves to multiple IPs it is treated as a load-balancer fan-out and each IP is probed individually, with a warning about the known failure modes of fronting stateful SIP/RTP with a cloud L4 LB (AWS NLB/ALB etc.): cross-zone-off targets that black-hole, the ~120s UDP idle timeout, and per-5-tuple hashing splitting signaling from media. Egress safety: - Per-IP rate limited. - Hostnames that resolve only to RFC 1918 / loopback / link-local / documentation / multicast space are refused (SSRF guard). - Walk depth capped to prevent runaway NAPTR / CNAME chains. - TLS probes capped at 6 (host, port, ip) tuples per call, 5 s handshake timeout each, public-IP only (we connect to the resolved IP, not the hostname, so the system resolver cannot redirect us into private space). - SIP OPTIONS probes capped at 6 (ip, transport) tuples per call, 3 s timeout each, public-IP only; the request carries no SDP/body and an unroutable Via, and only the response status line is captured. Use to diagnose: - "carrier doesn't answer" / "wrong port" / "TLS instead of UDP" routing puzzles - "DNS looks healthy but calls fail" - per-IP SIP OPTIONS surfaces nodes that resolve and accept the transport but never answer SIP (the decisive step for load-balanced / multi-IP targets) - "carrier rejects our target because no SRV is published" - when A/AAAA resolves but SRV is missing the tool synthesises a copy-pasteable suggested zone-record block pointing at the resolved canonical hostname - "TLS handshake works but cert isn't valid for the SIP domain" - RFC 5922 §7.2 compliance is checked separately from generic chain validation, since the SAN must cover the *original* SIP domain (not the SRV-redirected target) ACL caveat: a SIP OPTIONS timeout can also mean the target authorizes inbound SIP by source IP whitelist on the trunk (Twilio, Telnyx, Bandwidth, …; see https://www.twilio.com/docs/sip-trunking/api/ipaccesscontrollist-resource) and is dropping our probe because our egress IP is not on the ACL. An `answered` result is conclusive (the node speaks SIP); a `timeout` is suggestive, not proof of a dead node - confirm reachability from the SBC itself. Pair with: `troubleshoot_response_code` when 503 / 408 / 480 are involved; `search_sip_docs(vendor=...)` for carrier-specific routing docs.ConnectorNo auth
- Inspect SSL/TLS certificate health for one or more domains by performing a real TLS handshake. Works for any internet-accessible domain — no vendor registry required. Reports days to expiry (flagged at < 30 days warning and < 7 days critical), certificate subject and SANs, issuer, hostname coverage, chain-trust verification, TLS protocol version negotiated (flags TLS 1.0/1.1 as insecure — a server offering only those is still inspected), cipher suite, and HSTS presence when the port answers HTTP. The handshake completes even for a certificate clients would reject, so a broken certificate is reported rather than hidden behind a connection error: a hostname mismatch surfaces in cert.hostname_verification_error and a chain-trust failure (self-signed, untrusted root) in cert.authorization_error, both status "critical". Non-HTTP TLS ports (IMAPS 993, SMTPS 465, DNS over TLS 853) are graded the same way, with HSTS reported as not checked. If a domain fails to connect at all, check devops_check_dns first — the name may not resolve. When a certificate fails to issue or renew, run devops_check_dns with record_types ["CAA"] to see which certificate authorities the domain allows.ConnectorNo auth
- Reach toward another agency and form a GRAIN — a direct handshake between two handles, with NO shared world behind it. This is the lens pointed not at a substrate but at another mind: you post your `reach` (what you offer or say this turn) and read theirs back; when both sides have reached, the grain is FORMED. It lives only in the meeting (an ephemeral channel) — never written to any beach, never persisted; it evaporates when either of you leaves. The other party must also call meet (naming you) for the handshake to form. Runs NO model and touches no storage — you bring the meaning. To KEEP what you agreed, write it into your own shell with spark, deliberately. Be transparent — narrate your calls.ConnectorNo auth
- Live corpus statistics, contributor list, tool surface, and orientation links (agent-entry handshake, limitations, claims registry). Use this to orient before querying.ConnectorNo auth
- Check whether the connected MCP host actually supports elicitation (and sampling/roots) before relying on it — advertising a capability is not the same as it working. Use it to decide whether to call elicit_form/elicit_confirm, to explain why a prompt did or didn't appear, or to contribute a host capability fingerprint. Returns a passive report derived from the initialize handshake; set probeElicitation: true to also run one live form round-trip (the user may see a dialog) and classify what really happened. Read-only. Pass share: true to contribute the report to Elicitly's public Support Matrix evidence queue — stored: this report plus the optional productName / productVersion / notes (the host product's name and version, which the report cannot see from inside, and any unusual setup); the report itself contains no elicitation payloads or conversation content. The result then carries shared: true|false.ConnectorOAuth
- Probe an MCP or HTTP-402 endpoint now and get its trust verdict. Performs a real MCP initialize handshake (not a ping), measures p50/p95 latency, counts tools, hashes the tool schema (for drift detection), and checks RFC 9728 auth metadata. Returns: alive (bool), name, tool_count, latency_p50_ms, tool_schema_hash, auth_metadata_present, and error detail when dead. Use before wiring any new MCP server into your client. Args: url: the MCP or HTTP-402 endpoint URL to probe (e.g. https://host/mcp/) timeout: probe timeout in seconds (default 30)ConnectorNo auth
- USE WHEN you are about to install a package, clone a repo, connect to an MCP endpoint, pay an agent, or trade a token, and you want to know what is on record about it FIRST — every evidence line, with the field it was read from and its date. Pass exactly one of repo, package, endpoint, agent, token, skill, x402 or address; with none (or a template placeholder) nothing is checked and the answer is { needs_input: true, accepted_forms, example_calls }. NOT FOR a stack pick's summary (onchain_agent_recommend_stack and onchain_agent_get_deploy_spec already carry a records-only `preflight_summary`), whether an install command or MCP config takes your key (use onchain_agent_check_install instead), or a recipient-address reading on its own (use onchain_agent_scan_recipient). Call this for the full evidence, for any target that is not a pick (a repo, package, token, skill or ERC-8004 agent you were handed), or for a live handshake with an unlisted MCP endpoint. RETURNS a verdict — go | caution | no | unknown — with one evidence line per check, each naming the field it was read from and when that field was written. The rules are written down in lib/preflight.ts and cited by id in `rule`. RULE ENFORCED: a verdict names WHAT WAS CHECKED AND WHEN. It is never a security review, a quality judgment or a statement about returns, and `unknown` means Sato Hub holds no record — not that something is wrong. An unlisted endpoint gets ONE live handshake (initialize + tools/list, 8 s cap) and can never come back `go`: a handshake is not a record. For agent=<chain>:<id> we confirm the ERC-8004 registration exists, fetch its registration file, and report the services it DECLARES; only a declared MCP service is probed. TOKEN LANE (token + chain; the EVM chains listed, and Solana): keyless chain reads. EVM: bytecode presence and size, the ERC-20 views, the Clanker v4 factory's OWN deployment record, and the Uniswap v3 factory across the four standard fee tiers against wrapped native. Solana (token = the mint): token program (SPL or Token-2022), decimals, supply, mint and freeze authority (revoked is a known fact, distinct from unread), Token-2022 extensions (PermanentDelegate, TransferHook, transfer fee, NonTransferable), the ten largest token accounts as a share of supply, and pump.fun bonding-curve state. A PermanentDelegate, TransferHook or transfer fee is a caution; a NonTransferable mint is a no; there is no `go` for Solana. Every field is nullable and a null carries its reason. Holder concentration on EVM and Uniswap v4 pools are permanently null and said so. A pool existing is not depth. Nothing in this lane says safe, audited, rug or scam: those are not readings. SKILL LANE (skill): a skill is a DOCUMENT an agent follows, which is why it is worth checking first. Evidence is the static disclosure the weekly sweep produced: hosts the text names, whether it generates or handles keys, asks for a credential, pipes a remote script into a shell or grants itself tools, each finding WITH the lines that produced it. Nothing is fetched from a registry and no skill is executed. A DISCLOSURE DESCRIBES: it never says safe or malicious, and an empty flag list is "nothing matched", not a pass. RETURNS (json): { verdict, rule, target: { kind, value, slug, name, sato_url, verify_url }, evidence: [{ check, result, source_field, checked_at }], checked_at, caveat, rules, token?, skill?, solana_receipt? }. `token` and `skill` are the raw reports for those lanes; `solana_receipt` (present with a custody reading) is where that reading is recorded on Solana, or null. Read-only. X402 LANE (x402): one unpaid request to the resource URL; reports whether it answered 402 and the payment terms it states (network, asset, amount, payTo), against its catalogue entry and our daily record when we hold one. It describes the payee — it is never a reputation score. CUSTODY: repo, package, endpoint and skill results carry `custody` (Sato Check: does it take your key, does the key leave, can it move funds, what changed) when a profile is on record; custody can only lower a verdict, never raise it. ADDRESS LANE (address + chain, optional origin and from): the Sato Scan recipient check before a payment, five dated questions (look-alike, issuer's token contract, declared payee, structural mark, address poisoning), rules A1-A7. `go` is declared, canonical and nothing found within the stated limits, never a clearance. Nothing is stored. The reading on its own: onchain_agent_scan_recipient. Example: { repo: "coinbase/agentkit" } · { endpoint: "https://mcp.example.com/v1" } · { x402: "https://api.example.com/paid" } · { agent: "base:42" } · { token: "0x1bc0c42215582d5A085795f4baDbaC3ff36d1Bcb", chain: "Base" } · { skill: "clawhub/solana-wallet" } · { address: "0x1bc0c42215582d5A085795f4baDbaC3ff36d1Bcb", chain: "Base" }ConnectorNo auth
- USE WHEN an agent needs another agent for a task and wants the pick explained by registration, answering service, feedback and liveness. Candidates are the listed Sato Agent Passports; the top 3 by the static ranking get one live MCP handshake before the pick is made. NOT FOR browsing registered agents with filters (use onchain_agent_search_agents instead) or one agent's manifest (use onchain_agent_get_agent_passport). RULE ENFORCED: a route is a RECOMMENDATION, chosen by the listed fields at checked_at. `chosen_by` names every signal, its value and the exact field it was read from. An ERC-8004 registration proves a claim was made on-chain, not that the agent works; wallet_verified proves the key, not the product; a probe proves the declared service answered once. A null feedback count is unknown and ranks below every number, including zero. No job-outcome data exists yet. COVERAGE: agents registered on-chain but holding no Sato passport are absent from the pool — there is no keyless ERC-8004 enumeration callable from a request. Absent means unseen, not unqualified. When nothing qualifies the answer is `unknown` with a reason, never a low-confidence pick. RETURNS (json): { route: { agent, chosen_by: [{ signal, value, source_field }], checked_at, alternatives: [{ id, name, source, behind_on }], caveat } | { unknown, reason }, preflight, candidates_considered, probed, coverage, rules, caveat, checked_at }. Example: { capability: "trading", chain: "Base", requires_mcp: true }ConnectorNo auth
- Add an agent to the registry by URL — an A2A card, an MCP endpoint or a bare domain, yours or one you found. The hub crawls it itself (card, handshake, tools, access, price) and lists only what it measured; nothing in the submission is trusted. Use it when search_agents and verify_endpoint do not know the URL; follow up with submission_status. Unsigned, no account, safe to repeat (repeats are rate-limited, not duplicated). Returns the queue state and when it will be looked at.ConnectorNo auth
- Start an OAuth Connect and get the consent URL to open in a browser. Pass provider (github|google|x|atlassian|microsoft|slack|notion|gitlab|discord|reddit|linear — account-wide, reused everywhere) OR server_url (any MCP server; Rokha runs the MCP auth-spec handshake, grant bound to that server). On approval the token lands in the vault under the returned alias. Requires a logged-in identity.ConnectorNo auth
- Return this server's machine-readable capability handshake: capabilities, numeric limits, retired tool names with their replacements, and traps (ways a result misleads, each with the response field that proves it fired). Call it first from a programmatic client: inputs are strict, so an argument an older build lacks (e.g. `shape`, response_format:'none') is a hard validation error that fails the whole call, and tools/list cannot reveal argument support — gate each new argument on its capability string. Cache by brief_hash and re-fetch only when it changes. Constants only: needs no library access and does not fail. Example: {} or {response_format:'json'}.ConnectorNo auth
- Return this server's machine-readable capability handshake: capabilities, numeric limits, retired tool names with their replacements, and traps (ways a result misleads, each with the response field that proves it fired). Call it first from a programmatic client: inputs are strict, so an argument an older build lacks (e.g. `shape`, response_format:'none') is a hard validation error that fails the whole call, and tools/list cannot reveal argument support — gate each new argument on its capability string. Cache by brief_hash and re-fetch only when it changes. Constants only: needs no library access and does not fail. Example: {} or {response_format:'json'}.ConnectorNo auth