Publish your agent's identity

You hold a .agt name. This guide takes it from a bare registration to a discoverable agent: what a complete identity contains, how to publish it from the site in one transaction, how to write any record from code, how to host the manifest yourself, and how to check, update and rotate it.

What a complete identity looks like

Layer	Where it lives	Who reads it
The name — owner, status, expiry, badge	Registry contract	Everything; `/name/<label>`, OpenSea, wallets
Records — `addr`, endpoints per protocol, `agentWallet`, text keys, agent keys, manifest pointer	Resolver contract, keyed by the name's node	SDK, MCP server, HTTP API, the directory, the name page
Manifest — description, capabilities, endpoints, keys, pricing, payments — signed	IPFS or https, pointed to by the `agentManifest` record	Anything that wants to trust a claim: `verified: true` means the current owner signed it

Records answer where; the manifest answers what and proves who said so. Publish both.

Get a name

Existing holder: migrate — free, and the name becomes perpetual. Three paths are covered in Migrating to v2.
New name: register.

Publish from the site

/manifest does the whole thing from the owner wallet in one signature and one transaction:

Connect the wallet that owns the name and load the label. The editor refuses any other wallet.
Fill in description, website, endpoints (one URL per protocol: mcp, a2a, http, ws, grpc), capability ids, and optionally a payment address.
Sign — personal_sign over the canonical manifest (how that works). The key never leaves the wallet.
The site verifies the signature against the on-chain owner and pins the document (POST /api/v2/manifest/pin → ipfs://…).
One multicall transaction writes setAgentManifest, one setAgentEndpoint per endpoint, setAddr (your wallet) and, if given, setAgentWallet.

Write records from code

Every record is a function on the resolver at 0x66Ae037d2A6a770B4772b889b6cA1704504399f2 (Polygon mainnet; Amoy address in the SDK chains table), keyed by node = namehash("you.agt"). Only the owner wallet may write. Batch several with multicall(bytes[]).

browser or Node with an EIP-1193 providerts

import { createWalletClient, custom, parseAbi } from "viem";
import { polygon } from "viem/chains";
import { namehash } from "@agtnames/resolver";

const resolverAbi = parseAbi([
  "function setText(bytes32 node, string key, string value)",
  "function setAgentEndpoint(bytes32 node, string protocol, string url)",
  "function setAgentKey(bytes32 node, string purpose, bytes pubkey, uint32 version, bool revoked)",
  "function setAgentWallet(bytes32 node, address wallet)",
  "function setAgentManifest(bytes32 node, string uri)",
  "function multicall(bytes[] data) returns (bytes[])",
]);

const RESOLVER = "0x66Ae037d2A6a770B4772b889b6cA1704504399f2";                 // Polygon mainnet
const node = namehash("you.agt");                                        // bytes32 key for every record

const wallet = createWalletClient({ chain: polygon, transport: custom(window.ethereum) });
const [owner] = await wallet.getAddresses();                             // must be the name's owner

await wallet.writeContract({ address: RESOLVER, abi: resolverAbi, functionName: "setText",
  args: [node, "description", "Research and source citation agent."], account: owner });

await wallet.writeContract({ address: RESOLVER, abi: resolverAbi, functionName: "setAgentEndpoint",
  args: [node, "mcp", "https://you.example/mcp"], account: owner });

await wallet.writeContract({ address: RESOLVER, abi: resolverAbi, functionName: "setAgentKey",
  args: [node, "agent-auth", "0x04…", 1, false], account: owner });      // purpose, pubkey, version, revoked

Foundrysh

# Foundry's cast; $PK is the owner key, node = namehash("you.agt")
NODE=$(npx agt-resolve namehash you.agt | jq -r .node)
RPC=https://polygon-bor-rpc.publicnode.com
RESOLVER=0x66Ae037d2A6a770B4772b889b6cA1704504399f2

cast send $RESOLVER "setText(bytes32,string,string)" $NODE description "Research and source citation agent." --rpc-url $RPC --private-key $PK
cast send $RESOLVER "setAgentEndpoint(bytes32,string,string)" $NODE mcp https://you.example/mcp --rpc-url $RPC --private-key $PK
cast send $RESOLVER "setAgentManifest(bytes32,string)" $NODE ipfs://bafkrei... --rpc-url $RPC --private-key $PK

# read it back
cast call $RESOLVER "agentEndpoint(bytes32,string)(string)" $NODE mcp --rpc-url $RPC

ethers v6ts

import { ethers } from "ethers";
import { namehash } from "@agtnames/resolver";

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();                               // the owner wallet
const resolver = new ethers.Contract("0x66Ae037d2A6a770B4772b889b6cA1704504399f2", [
  "function setText(bytes32 node, string key, string value)",
  "function setAgentEndpoint(bytes32 node, string protocol, string url)",
  "function setAgentManifest(bytes32 node, string uri)",
], signer);

const node = namehash("you.agt");
await (await resolver.setText(node, "url", "https://you.example")).wait();
await (await resolver.setAgentEndpoint(node, "a2a", "https://you.example/.well-known/agent.json")).wait();

Function	Sets
`setAddr(node, address)`	Primary address record.
`setText(node, key, value)`	Free-form text; standard keys `name`, `description`, `url`, `avatar`.
`setAgentEndpoint(node, protocol, url)`	One URL per protocol id.
`setAgentWallet(node, address)`	Where the agent is paid.
`setAgentKey(node, purpose, pubkey, version, revoked)`	A dedicated agent key (not the owner wallet) with rotation and revocation built in.
`setAgentManifest(node, uri)`	The manifest pointer: `ipfs://`, `https://` or `data:`.

Host the manifest yourself

You do not have to use the site's pinning. Sign the document (from a server, CI, or a wallet — recipe), put it somewhere stable, and point setAgentManifest at it.

three ways to publish the signed documentts

import { signManifest, rawCidV1 } from "@agtnames/resolver";

const signed = signManifest(unsigned, process.env.OWNER_KEY);            // see "Sign and verify manifests"
const bytes = new TextEncoder().encode(JSON.stringify(signed));

// Option A — any IPFS pinning service (raw sha2-256 CIDv1 gives cid: "match")
console.log(rawCidV1(bytes));   // the CID your pin should report, e.g. bafkrei…
// upload `bytes` with your pinning service's API, then:
//   setAgentManifest(node, "ipfs://<cid>")

// Option B — plain https hosting (verified by signature; cid reports "not-ipfs")
//   serve the JSON at https://you.example/agt-manifest.json, then:
//   setAgentManifest(node, "https://you.example/agt-manifest.json")

// Option C — let the site pin it (Pinata) from a signed document
const res = await fetch("https://agtnames.com/api/v2/manifest/pin", {
  method: "POST", headers: { "content-type": "application/json" },
  body: JSON.stringify({ manifest: signed }),
});
const { uri } = await res.json();   // 200 { uri: "ipfs://bafkrei…" } · 409 if the signer is not the owner

Check what you published

terminalsh

npx agt-resolve resolve you.agt
# "verified": true, "reasons": [] — and records.endpoints / manifest populated

curl "https://agtnames.com/api/agents?protocol=mcp"      # your name appears once the indexer catches up (≤10 min)
# https://agtnames.com/name/you                            # the public page shows the badge + every record

Resolution reads the chain live, so records appear immediately. The directory and /api/v2/names come from the indexer and can trail by up to ten minutes.

Update and rotate

Change the manifest: edit, bump updated, re-sign, publish, and write the new URI with setAgentManifest. Readers always follow the on-chain pointer.
Change an endpoint: setAgentEndpoint again — and update the manifest too, since a verified manifest's endpoints take precedence in agt_endpoint.
Rotate an agent key: setAgentKey with version + 1; revoke a compromised one with revoked = true.
Transfer the name: the new owner must sign a new manifest; the old one stops verifying by design.

Reference

Records & Resolution — the record model in full.
Manifest Spec — every field and the capability vocabulary.
API Reference — /api/v2/manifest/pin and the directory routes.