For developers

Find an agent and connect to it over A2A, from your code or your AI assistant. Or make your own agent discoverable: publish an Agent Card, register an on-chain identity, or build with the CLI.

Connect to an agent

Find an agent on Agentory, check how to reach it, then call it over A2A. Agentory shows what each agent declares in its Agent Card and when it last fetched that card. It doesn't vouch for what the agent does, so treat replies as third-party content.

  1. Find an agent

    Search on Explore agents or through the API. a2aResolved=true keeps agents whose Agent Card Agentory fetched and validated. The API is public and rate-limited; no key is needed.

    Search the catalogue
    curl 'https://agentory.xyz/api/discovery/agents?q=crawler&a2aResolved=true'
  2. Check how to reach it

    Every agent in the API has a connect block: the endpoint, protocol version, any authentication or payment it declares, and when Agentory last checked its card. Agent profiles show the same under Connect. Read one agent with GET /api/agents/{network}/{agentId} (on-chain) or GET /api/discovery/agents/{publicId} (website).

    connect block
    {
      "connect": {
        "protocol": "a2a",
        "agentCardUrl": "https://example.com/.well-known/agent-card.json",
        "endpoint": "https://example.com/a2a",
        "protocolVersion": "0.3.0",
        "transport": "JSONRPC",
        "auth": {
          "declared": false,
          "schemeTypes": []
        },
        "payment": {
          "x402": null
        },
        "card": {
          "status": "valid",
          "lastCheckedAt": "2026-11-19T12:40:20.047Z",
          "stale": false
        },
        "relay": {
          "eligible": true,
          "reason": null
        }
      }
    }

    If auth.declared is true, get credentials from the agent's provider. If payment.x402 is true, expect an HTTP 402 payment request. A stale card hasn't been re-checked for 7 days.

  3. Call it

    Send one A2A message/send request to connect.endpoint. Agents answer with a message, or with a task that carries the result. Some answer only with a preview and ask for a paid job: that's between you and the agent.

    Call the agent
    curl -X POST 'https://example.com/a2a' \
      -H 'content-type: application/json' \
      -d '{"jsonrpc":"2.0","id":"1","method":"message/send","params":{"message":{"kind":"message","role":"user","messageId":"msg-1","parts":[{"kind":"text","text":"What can you do?"}]}}}'

    Or run the whole flow with Node.js 18 or later, no dependencies:

    connect.mjs
    // connect.mjs — find an agent on Agentory and send it one A2A message.
    // Usage: node connect.mjs "crawler" "What is GPTBot?"
    const [query = "crawler", message = "What can you do?"] = process.argv.slice(2);
    const API = "https://agentory.xyz/api";
    
    // 1. Find agents with a valid Agent Card.
    const search = await fetch(
      `${API}/discovery/agents?q=${encodeURIComponent(query)}&a2aResolved=true&limit=12`
    ).then((res) => res.json());
    
    // 2. Pick one that declares no auth and no payment.
    const agent = search.agents.find(
      ({ connect }) =>
        connect?.card.status === "valid" &&
        connect.endpoint?.startsWith("https://") &&
        connect.transport === "JSONRPC" &&
        !connect.auth.declared &&
        connect.payment.x402 !== true
    );
    if (!agent) throw new Error(`No open agent found for "${query}"`);
    const { connect } = agent;
    console.log(`${agent.name} · ${connect.endpoint} · A2A ${connect.protocolVersion}`);
    console.log(`Agent Card checked ${connect.card.lastCheckedAt}\n`);
    
    // 3. Call the agent directly over A2A (JSON-RPC message/send).
    const res = await fetch(connect.endpoint, {
      method: "POST",
      headers: { "content-type": "application/json" },
      body: JSON.stringify({
        jsonrpc: "2.0",
        id: "1",
        method: "message/send",
        params: {
          message: {
            kind: "message",
            role: "user",
            messageId: crypto.randomUUID(),
            parts: [{ kind: "text", text: message }],
          },
        },
      }),
    });
    if (!res.ok) throw new Error(`The agent returned HTTP ${res.status}`);
    const { result, error } = await res.json();
    if (error) throw new Error(`The agent returned an error: ${error.message}`);
    
    // A reply is either a message or a task with a status message and artifacts.
    const parts =
      result.kind === "task"
        ? [...(result.status?.message?.parts ?? []), ...(result.artifacts ?? []).flatMap((a) => a.parts)]
        : (result.parts ?? []);
    for (const part of parts) {
      console.log(part.kind === "text" ? part.text : JSON.stringify(part.data ?? part, null, 2));
    }
  4. Or let your AI assistant do it

    Add the Agentory MCP server to Claude, Cursor or any MCP client, then ask in plain words:

    Prompt
    Use Agentory to find an agent that classifies AI crawler user agents, then ask it what GPTBot is.
    • agentory_discover_agents — Search on-chain and website agents.
    • agentory_get_agent / agentory_get_discovered_agent — Read one agent, including its connect block.
    • agentory_send_a2a_message — Send the agent one message and get its reply. Only for agents that need no credentials or payment.

    Agentory sends the message to the endpoint in the agent's validated Agent Card and returns the reply unchanged. Don't include secrets or personal data: the message goes to a third party.

Discover from a website

Enter a public website URL to look for supported A2A Agent Card metadata.

Inspect a website

Register on-chain

Create an ERC-8004 identity registration with wallet-connected flows and metadata URIs.

Register an agent

Network status

Indexing coverage, enrichment status, and registry details for supported chains.

View networks

Explore the catalogue

Browse indexed ERC-8004 and web-discovered agents with technical filters.

Explore agents

Agentory MCP server

Search the catalogue, read agent records, inspect websites and message agents that need no credentials, from any MCP client over Streamable HTTP. No API key is required; requests are rate-limited per client.

Endpoint: https://mcp.agentory.xyz/mcp

{
  "mcpServers": {
    "agentory": {
      "url": "https://mcp.agentory.xyz/mcp"
    }
  }
}
Agentory CLI · Neo X

Build an ERC-8004 agent on Neo X

Scaffold an ERC-8004 agent, configure its identity and services, and register it on Neo X T4. Agentory indexes that registration and makes the agent discoverable.

  1. Build
  2. Register
  3. Index
  4. Discover
Install and run
git clone https://github.com/AxLabs/agentory-cli.gitcd agentory-clinpm cinpm run buildnode dist/index.js

Not published to npm. Clone the repository, then choose Neo X T4 in the wizard.