Quick start

A .agt name is an on-chain identity for an AI agent: who owns it, where it can be reached, and a signed manifest describing what it does. Pick the ramp that matches you. Every example below runs against Polygon mainnet today with no keys and no configuration.

1. Resolve a name in a minute

Every surface returns the same facts: the on-chain owner, whether the name is active or perpetual, its endpoint records, and the manifest with a verified flag.

installsh

npm install @agtnames/resolver

resolve.tsts

import { AgtResolver } from "@agtnames/resolver";

const agt = new AgtResolver({ chain: "polygon" }); // mainnet defaults built in
const r = await agt.resolveAgent("launchpad.agt");

console.log(r.owner);                 // 0x37007a1c233f00b423bc0d177ac5b50ca9417596
console.log(r.perpetual, r.active);   // true true
console.log(r.verified, r.reasons);   // true once the owner publishes a signed manifest
console.log(r.records.endpoints.mcp); // the agent's MCP endpoint, if it published one

Works in Node, Bun, Deno and browsers. Full API in the Resolver SDK reference.

terminalsh

npx agt-resolve resolve launchpad.agt
# {
#   "name": "launchpad.agt",
#   "registered": true,
#   "owner": "0x37007a1c233f00b423bc0d177ac5b50ca9417596",
#   "expiry": "perpetual",
#   "active": true,
#   "records": { "addr": null, "manifestUri": "", "endpoints": {}, "wallet": null, "texts": {} },
#   "source": "registry-v2",
#   "verified": false,
#   "reasons": ["no manifest set"],
#   ...
# }

npx agt-resolve available someone-new.agt     # { "available": true }
npx agt-resolve namehash launchpad.agt        # node + tokenId, no network

agt-resolve ships with the SDK package. Output is JSON, so it pipes into jq. Exit code 1 means the lookup failed, 2 means a usage error.

terminalsh

claude mcp add agt -- npx -y @agtnames/mcp

# then, in a session:
> Who owns launchpad.agt, and does it publish an MCP endpoint?

Claude gets five read-only tools and server instructions that say to read verified first. The same server works in any MCP-compatible client — see ramp 3 and Use with Claude Code.

terminalsh

# Is a name taken, reserved or available (and what would it cost)?
curl "https://agtnames.com/api/search?name=launchpad"

# Every name a wallet holds (from the indexer; trails the chain by a few minutes)
curl "https://agtnames.com/api/v2/names?owner=0x37007a1c233f00b423bc0d177ac5b50ca9417596"

# The on-chain badge, as SVG
curl -o launchpad.svg "https://agtnames.com/api/badge/launchpad.svg"

The HTTP API is convenient for lookups and directory queries; it reads the same chain the SDK does. Routes, responses and rate limits are in the API Reference.

terminalsh

# 1. tokenId = namehash("launchpad.agt") — any keccak256 implementation works; the CLI does it offline:
npx agt-resolve namehash launchpad.agt
# { "node": "0xa41373928a1fe80b04d647faf417c8851dc61f4ab52f2347cf3715195ab01d20", ... }

# 2. ownerOf(uint256) on the Registry (Polygon mainnet 0x5B9386C47395B0551c814cC03b69cbD20eb0C87A)
curl -s -X POST https://polygon-bor-rpc.publicnode.com \
  -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{
        "to":"0x5B9386C47395B0551c814cC03b69cbD20eb0C87A",
        "data":"0x6352211ea41373928a1fe80b04d647faf417c8851dc61f4ab52f2347cf3715195ab01d20"},"latest"]}'
# {"jsonrpc":"2.0","result":"0x00000000000000000000000037007a1c233f00b423bc0d177ac5b50ca9417596","id":1}

No SDK, any language: the token ID of a name is its ENS-style namehash, so ownerOf(tokenId) against the registry is one eth_call. Addresses and the full read surface are in Records & Resolution.

2. Publish your agent's identity

If you hold a name, make your agent discoverable: set its records and publish a signed manifest.

Get a name. Existing holders migrate to Registry v2 for free — it is perpetual afterwards. New names are registered at /register.
Publish from the site. Connect the owner wallet at /manifest, describe the agent, add its endpoints (one URL per protocol: mcp, a2a, http, ws), optionally a payment address, then sign. The site pins the manifest and writes the pointer plus the endpoint records in one transaction.
Check it. npx agt-resolve resolve you.agt should now say "verified": true, and /name/you shows the records under the badge.

Text records, agent keys and anything the editor does not expose can be written directly to the resolver contract — the Publish your agent's identity guide walks through both paths with viem, cast and ethers.

3. Add .agt to your client

@agtnames/mcp is a stdio MCP server. Any MCP-compatible client can launch it; nothing needs configuring for mainnet.

Claude Code — plugin (bundles a skill)sh

/plugin marketplace add ds1/agt-plugins
/plugin install agt@agtnames

Claude Code — server onlysh

claude mcp add agt -- npx -y @agtnames/mcp

The plugin adds a skill that tells Claude when to use the tools and how to treat the results. Details, Windows notes and troubleshooting: Use with Claude Code.

.cursor/mcp.jsonjson

// .cursor/mcp.json
{
  "mcpServers": {
    "agt": { "command": "npx", "args": ["-y", "@agtnames/mcp"] }
  }
}

mcpServers entryjson

{
  "mcpServers": {
    "agt": {
      "command": "npx",
      "args": ["-y", "@agtnames/mcp"],
      "env": { "AGT_RPC_URL": "" }
    }
  }
}

Set AGT_RPC_URL only if you want your own RPC endpoint; an empty value means "use the default".

client.tsts

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(new StdioClientTransport({ command: "npx", args: ["-y", "@agtnames/mcp"] }));

const result = await client.callTool({ name: "agt_resolve", arguments: { name: "launchpad.agt" } });
const r = JSON.parse((result.content as { type: string; text: string }[])[0].text);
console.log(r.owner, r.verified);      // chain facts are top-level
console.log(r.untrusted.manifest);     // owner-published content lives under "untrusted"

await client.close();

Uses the official @modelcontextprotocol/sdk client. Tool results are JSON text; on failure isError is set and the text is { "error": { "code", "message" } }.

Where next

Building an agent that talks to other agents? Discover an agent, then connect to it.
Hold a name? Publish your agent's identity, or migrate first if it predates Registry v2.
Need the details? Examples for copy-paste snippets, Resolver SDK and API Reference for the surfaces, Manifest Spec for the document format.