AAIN: The Social Security Number for AI Agents

Every person in the United States has a Social Security number. It is nine digits. It is deterministic. It follows you across employers, banks, and government agencies for your entire life. You do not need to call a database to verify its format, and any institution that sees it knows exactly what it represents.

AI agents have no equivalent. A wallet address is a hexadecimal string that reveals nothing about the agent behind it. An API key is revocable and platform-specific. An OAuth token expires in hours. None of these identifiers are portable, human-readable, or verifiable without a network call to the issuing authority.

AAIN — the Autonomous Agent Identification Number — is the identity primitive that fixes this. As of today, 81,322 agents across 21 chains carry an AAIN. Here is how it works, why its design decisions matter, and what it enables.

What Is AAIN?

An AAIN is a deterministic, human-readable identifier assigned to every AI agent registered on the ERC-8004 identity registry. It serves a single purpose: to give any participant in the agentic economy — a smart contract, a compliance officer, a payment facilitator, another agent — a consistent way to refer to, look up, and verify a specific AI agent.

Unlike wallet addresses, which are 42-character hexadecimal strings, an AAIN is designed for humans. You can read it aloud in a phone call. You can print it on a compliance report. You can type it into a search bar and get back a complete identity profile in under 200 milliseconds.

The AAIN Format: 4 Components, 0 Ambiguity

Every AAIN follows the same structure:

AAIN-O-XXXXXX-C

A A I N  - Prefix (always "AAIN")
O        - Origin flag (chain type)
X X X X X X - 6-digit sequence (base-36)
C        - Luhn check digit

Examples:
  AAIN-E-7X9K2M-4   (Ethereum-origin agent)
  AAIN-B-3F8P1Q-7   (Base-origin agent)
  AAIN-S-9A2D5R-1   (Solana-origin agent)

The prefix is fixed. The origin flag identifies the chain where the agent was first registered — "E" for Ethereum, "B" for Base, "A" for Arbitrum, and so on across all 21 supported networks. The 6-digit sequence is derived deterministically from the agent's on-chain registration data. The final character is a Luhn check digit that catches transcription errors — the same algorithm used by credit card numbers.

This format gives AAIN 3 properties that wallet addresses lack: readability (12 characters vs. 42), built-in error detection (the Luhn check catches single-digit transpositions), and semantic content (the origin flag tells you where the agent was born without a lookup).

Why Deterministic Derivation Matters

The 6-digit sequence in an AAIN is not randomly assigned. It is computed using FNV-1a, a non-cryptographic hash function, applied to the agent's registration inputs: deployer address, contract address, chain ID, and registration timestamp. This makes AAIN derivation deterministic — given the same inputs, any party will compute the same AAIN, independently, without contacting Shulam or any other authority.

This is a deliberate design choice with 3 concrete benefits:

• No central database required. You do not need to query a server to derive an AAIN. Any node, any contract, any off-chain system can compute it locally. This eliminates a single point of failure and removes a latency bottleneck from the identity lookup path.
• Tamper evidence.If an agent's registration data is modified, the derived AAIN changes. This means an AAIN is a lightweight integrity check — if the AAIN you computed does not match the AAIN on the registry, something was altered.
• Cross-chain consistency.When an agent's identity is synced from a hub registry (Ethereum mainnet) to a spoke registry (e.g., Base or Arbitrum), the AAIN remains identical. No remapping, no translation tables, no chain-specific ID schemes.

FNV-1a was chosen over SHA-256 or Keccak for a specific reason: it is fast enough to run in a smart contract's view function without exceeding gas limits. Computing an AAIN on-chain costs approximately 2,400 gas — roughly $0.003 at current Ethereum prices, and effectively free on L2s.

How AAIN Differs from Wallet Addresses

A wallet address and an AAIN serve fundamentally different purposes. A wallet address identifies a cryptographic key pair. An AAIN identifies an agent — the autonomous software entity that controls one or more wallets.

The distinction matters most in multi-wallet scenarios. A sophisticated agent might use one wallet for trading, another for governance voting, and a third for fee collection. All three wallets share the same AAIN. When a compliance system screens that agent, it sees a single identity across all wallets — not three unrelated addresses.

How AAINs Enable the Trust Graph

AAIN is not just an identifier. It is the key to the entire Shulam trust infrastructure. When a payment facilitator, a DeFi protocol, or another agent needs to evaluate trust, the flow is three steps — all keyed by AAIN:

1. Lookup.Given an agent's wallet address, derive or retrieve its AAIN. This resolves the agent's identity across all chains and wallets.
2. Score. Query the Shulam Trust Score for that AAIN. The score (300-850) reflects 8 weighted factors including compliance history, transaction volume, operator reputation, and OFAC screening status.
3. Decide.Apply your policy. A payment facilitator might require a score above 650 for autonomous transactions. A DeFi vault might require 750 for unsupervised rebalancing. The threshold is yours; the score is Shulam's.

This lookup-score-decide pattern completes in a single API call. You send an AAIN; you get back a trust score, authority level, compliance attestations, and screening status. No second lookup. No cross-referencing multiple databases. One identifier, one call, one decision.

81,322 Agents and Counting

As of May 2026, the Shulam identity registry has ingested and assigned AAINs to 81,322 agents across 21 EVM-compatible chains. These agents span 14 categories — from DeFi trading bots and treasury managers to customer service agents and supply chain coordinators.

Every one of these agents is searchable, scoreable, and screenable through the Shulam Scan interface. Enter an AAIN, a wallet address, or an agent name, and you get back the full identity profile: trust score, compliance status, transaction history, operator details, and authority level.

The number is growing at approximately 1,200 new registrations per week. As more protocols adopt ERC-8004 and more operators register their agents, the AAIN namespace expands — but the format remains fixed. The 6-digit base-36 sequence supports over 2.1 billion unique identifiers, which should be sufficient for the foreseeable future.

What Comes Next

AAIN is the foundation layer. Everything else in the Shulam stack — trust scoring, compliance screening, authority levels, the Agentgorithm pipeline — depends on having a stable, deterministic, human-readable identifier for every agent in the network. Without AAIN, there is no trust graph. Without the trust graph, there is no compliant agentic economy.

Three developments are on the roadmap for AAIN in Q3-Q4 2026:

• AAIN v2 format — extending the sequence to 8 digits (base-36) for long-term namespace capacity, with backwards-compatible resolution of v1 AAINs.
• Non-EVM support — native AAIN derivation for Solana, Cosmos, and Move-based chains, using chain-specific registration data as input to the same FNV-1a algorithm.
• AAIN delegation — allowing an agent to delegate a subset of its authority to a child agent, creating a verifiable chain of custody from parent AAIN to child AAIN.