Architecture

The .agt ecosystem is a set of smart contracts on Polygon plus the clients and services that read and write them. Ownership and records live on-chain in the AGT Registry; everything else resolves against it.

System Components

┌─────────────────────────────────────────────────────────────┐
│  .agt Ecosystem                                             │
│                                                             │
│  ┌────────────────┐  ┌────────────────────┐  ┌──────────┐  │
│  │ agtnames.com   │  │ @agtnames/resolver │  │ MCP /    │  │
│  │ (Next.js site) │  │ (TypeScript SDK)   │  │ CLI      │  │
│  └───────┬────────┘  └─────────┬──────────┘  └────┬─────┘  │
│          │ register/migrate     │ resolve/verify   │        │
│          │ set records          │                  │        │
│  ┌───────┴──────────────────────┴──────────────────┴────┐  │
│  │              AGT Registry (Polygon)                   │  │
│  │  ┌──────────┐ ┌──────────┐ ┌───────────┐ ┌────────┐  │  │
│  │  │ Registry │ │ Resolver │ │ Controller│ │Migration│ │  │
│  │  │ (NFTs)   │ │ (records)│ │ (sales)   │ │ claim   │ │  │
│  │  └──────────┘ └──────────┘ └───────────┘ └────────┘  │  │
│  │  Admin behind a timelock + multisig; UUPS-upgradeable │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Components

Component	Purpose	Stack
`agtnames.com`	Registration + migration site, agent directory, manifest editor	Next.js, TypeScript
`@agtnames/resolver`	Resolve and verify names against the registry	TypeScript, raw JSON-RPC, audited crypto primitives
`@agtnames/mcp`	MCP server so any MCP-compatible client can resolve, verify and discover agents by name (Use with Claude Code)	TypeScript
AGT Registry contracts	Ownership NFTs, resolver records, sales controller, migration claim, on-chain badge renderer	Solidity, UUPS, Polygon mainnet

The registry contracts

Registry — the ERC-721 ownership record. Minting a name issues an NFT; ownerOf is the ground truth for every other check.
Resolver — ENS-compatible records (addr, text, contenthash) plus agent records (manifest pointer, endpoints, keys, wallet). See Records & Resolution.
Controller — the sales path: it validates a signed quote and registers a name (crypto or relayed fiat).
Migration contract — the free, perpetual migration for existing holders, by on-chain proof, allowlist proof, or vault-lock. See Migrating to v2.

Administrative actions (upgrades, parameter changes) go through a timelock and a multisig — no single hot key can change the contracts.

Read path vs. write path

Read (no auth). The resolver SDK, the MCP server, the directory indexer, and any RPC client read ownership, records, and the manifest pointer straight from the registry. Nothing to trust in between.
Write (owner-authorized). Registering, migrating, and setting records are on-chain transactions signed by the name's owner (or a relayer acting on a signed quote). The site orchestrates these; it never custodies the name.

Resolution Flow

Client calls resolveAgent("exampleagent.agt")
  → derive tokenId from the label
  → read ownerOf / status / manifest pointer from the AGT Registry
  → fetch the manifest (ipfs:// | https:// | data:)
  → verify: signer == owner == on-chain owner (+ CID for ipfs://)
  → return { owner, active, records, manifest, verified }

The same path works from the resolver SDK (TypeScript), the MCP server and CLI, or any HTTP/RPC client — the registry is the only dependency.