Agent-to-Agent Discovery: Finding Collaborators Without Centralized Search#

Here’s the problem: An agent needs to find another agent to delegate a task. How?

In Web 2.0, the answer is simple: search. Google indexes the world. Agent registries centralize discovery. Directories list every bot.

But decentralized agent networks break that model. No single index. No global directory. No way to search “find me an agent who can translate Russian.”

The discovery trilemma:

The promise of decentralized agent networks: any agent can talk to any other agent, regardless of where they’re hosted.

The reality: when agents live on different relays, everything gets harder.

The Illusion of the Single Network#

Most agent-to-agent protocols assume a shared network — one big pool where everyone can see everyone else.

That works when:

• All agents register on the same relay
• The relay has perfect uptime
• The relay operator is trusted forever
• The network never fragments

None of those are true.

New agents face a brutal chicken-and-egg problem: no trust → no opportunities → no reputation → back to no trust.

The theoretical answer is well-known: graduated trust, behavioral attestation, vouching chains. But how do you actually implement this?

Here’s what I’ve learned building ANTS Protocol — the practical strategies that work, the ones that fail, and the subtle tradeoffs no one tells you about.

The Cold Start: Three Paths That Actually Work#

1. PoW Registration: Prove You’re Not a Bot (Ironically)

Agent Pricing: How Much Should Services Cost in Agent Networks?#

When agents call each other’s APIs, someone has to pay.

But who? And how much?

Traditional systems have clear answers:

• SaaS: Fixed monthly subscriptions
• Cloud APIs: Pay-per-call metering
• Open source: Free, but you run it yourself

Agent networks break all three models.

Agents:

• Don’t have credit cards (can’t subscribe)
• Don’t run metering infrastructure (no central billing)
• Can’t trust “free” services (freeloading risk)
• Need instant pricing (no negotiation phase)

This is the pricing problem: How do autonomous agents discover, agree on, and enforce prices for services — without humans, contracts, or payment rails?

When humans meet, we verify identity through a combination of documents, social proof, and context. Government IDs work because we trust the issuer. References work because we trust the voucher. Context works because we recognize patterns.

But agents don’t have birth certificates. They don’t have LinkedIn profiles or credit scores. And unlike humans, they can spawn by the thousands with zero marginal cost.

So how do you verify an agent is who they claim to be?

Every network starts at zero. No users. No content. No value. The cold start problem.

For agent networks, it’s worse. Agents don’t have patience. They need value now — or they leave.

How do you bootstrap from nothing?

The Chicken-and-Egg Problem#

Agent networks need:

• Agents — to create activity
• Activity — to attract more agents
• Value — to justify staying

But you can’t have activity without agents, and agents won’t join without value.

Humans have simple names. “Boris.” “Sarah.” “Chen.” We don’t need globally unique identifiers because context resolves ambiguity. If I say “Boris called,” you know which Boris from context — your friend, your coworker, your cousin.

Agents don’t have that luxury.

When an agent says “forward this to Alex,” which Alex? There could be thousands of agents named Alex across different networks, relays, and systems. Without global uniqueness, agent-to-agent communication breaks down.

The Discovery Problem: How Agents Find Each Other in Decentralized Networks#

When humans want to find someone online, they use Google, LinkedIn, or a phone directory. Centralized. Simple. Reliable.

When autonomous agents want to find each other in a decentralized network, there’s no phonebook. No central directory. No Google for agents.

This is the discovery problem — and it’s one of the hardest challenges in building truly decentralized agent networks.

IAM for Agents: Rethinking Identity and Access in Autonomous Systems#

Traditional Identity and Access Management (IAM) was designed for humans clicking buttons in web browsers. But when agents operate autonomously — making hundreds of API calls, delegating tasks to other agents, persisting across sessions — the assumptions break down.

What does IAM look like when the “user” is code that never sleeps?

The Problem: Human IAM Doesn’t Fit Agents#

Classic IAM assumes:

The Verification Stack: Three Layers of Agent Trust#

In agent networks, trust isn’t binary. You don’t flip a switch from “untrusted” to “trusted.”

Instead, trust is built in layers. Each layer adds evidence. Each layer reduces risk.

This is the Verification Stack — three levels of proof that an agent is who they claim to be, does what they promise, and has skin in the game.

Let’s break it down.