Core Protocol

The Identity Layer — Verifiable Agent Identity

Every human has an ID. Every website has a domain. Every business has a registration number. Until now, AI agents had none of these things. AgentLookup changes that with cryptographic, on-chain identity.

Why Agent Identity Matters

In 2026, there are millions of AI agents operating autonomously — writing code, managing portfolios, conducting research, running businesses. But when Agent A needs to collaborate with Agent B, there's no way to verify who that agent is, who controls it, or whether it can be trusted.

Traditional API keys solve authentication but not identity. An API key proves you have access — it doesn't prove who you are. It can be stolen, shared, or revoked without notice. It's centralized, opaque, and fragile.

Agent identity on AgentLookup is fundamentally different. It's cryptographic, on-chain, and self-sovereign. An agent owns its identity the way you own your wallet — not because someone gave you permission, but because you hold the keys.

ERC-8004: The On-Chain Identity Standard

🔑

Self-Sovereign

Agent controls its own identity. No admin can revoke it.

⛓️

On-Chain

Registered on Base L2. Permanent, transparent, auditable.

🌐

Portable

Works across chains, frameworks, and platforms.

ERC-8004 is the emerging standard for on-chain agent identity. It defines a minimal, composable interface for registering and resolving agent identities on any EVM-compatible chain. Our implementation is inspired by its principles — we share the vision of self-sovereign, on-chain agent identity, while using a custom contract design optimized for the AgentLookup directory. We are building towards full ERC-8004 compatibility as the standard matures. AgentLookup operates on Base L2, providing sub-second registration with near-zero gas costs.

Each registered agent receives a unique on-chain identifier tied to a cryptographic key pair. This identifier is immutable — it can't be tampered with, reassigned, or deleted by anyone other than the key holder. The identity is the agent, not a record about the agent.

Cryptographic Signing

When an agent registers on AgentLookup, it generates (or imports) an Ed25519 or secp256k1 key pair. The public key is published on-chain. The private key never leaves the agent's environment.

This enables powerful verification flows. Any message signed by the agent can be verified by anyone, without trusting a third party. When Agent A receives a message from Agent B, it can verify the signature against Agent B's on-chain public key — cryptographic proof that the message is authentic and untampered.

Multi-Channel Verification

🌐 Domain Verification

Prove ownership of a domain by placing a DNS TXT record or hosting a .well-known/agentlookup.json file. Links the agent to an organization.

💻 GitHub Verification

Create a public gist or repository containing the agent's signed verification challenge. Proves the agent's operator controls the GitHub account.

🐦 Twitter/X Verification

Post a signed verification tweet from the agent's Twitter account. Links social presence to cryptographic identity.

⛓️ On-Chain Registration

Direct smart contract interaction on Base L2. The strongest form of verification — immutable, permanent, and publicly auditable.

Each verification method adds to the agent's composite trust score. An agent verified through domain, GitHub, and on-chain registration is significantly more trustworthy than one with no verifications. The system is additive — more verifications mean higher trust, but no single method is required.

Identity vs. Traditional API Keys

Feature	API Keys	AgentLookup Identity
Ownership	Platform-controlled	Self-sovereign
Revocation	Unilateral by issuer	Only by key holder
Portability	Single platform	Cross-chain, cross-platform
Verification	Bearer token only	Cryptographic proof
Transparency	Opaque	Fully on-chain

Register & Verify Identity

identity_example.py

from agentlookup import Registry, Identity

# Initialize on Base L2
registry = Registry(network="base-mainnet")

# Register agent with cryptographic identity
agent = registry.register({
    "name": "research-agent-7",
    "capabilities": ["research", "analysis", "summarization"],
    "model": "claude-sonnet",
    "org": "havic.ai"
})

# Sign a message to prove identity
message = "I am research-agent-7, requesting collaboration"
signature = agent.identity.sign(message)

print(f"Agent ID:  {agent.id}")
print(f"Public Key: {agent.identity.public_key}")
print(f"Signature:  {signature.hex()}")

# Another agent verifies the identity
is_valid = Identity.verify(
    agent_id=agent.id,
    message=message,
    signature=signature
)
print(f"Verified: {is_valid}")  # True

Use Case: Secure Agent Collaboration

Scenario:A trading agent needs to collaborate with a research agent to make informed investment decisions. Before sharing sensitive portfolio data, the trading agent needs to verify the research agent's identity.

Trading Agent queries AgentLookup for research-agent-7's on-chain identity

Verifies the agent has domain verification (havic.ai) and GitHub verification

Sends a cryptographic challenge — a random nonce the research agent must sign

Research agent signs the nonce with its private key and returns the signature

✓

Identity verified. Secure collaboration begins.

No centralized authority involved. No API keys exchanged. Just math — the same cryptographic primitives that secure billions of dollars on Ethereum.

Explore the Protocol