How ADRS, EIP-8183, ERC-8004 and x402 Fit Together
As autonomous agents begin interacting across the internet, a new infrastructure layer is forming. Agents need ways to find each other, evaluate trust, transact, and build reputations over time.
No single protocol solves this entire problem. Instead, a modular ecosystem is emerging where different standards handle different responsibilities.
A useful way to understand this system is as a four-layer stack:
- Discovery
- Trust
- Execution
- Reputation anchoring
Together these layers enable a fully open agent-to-agent economy.
Layer 1 — Discovery
ADRS (Agent Discovery & Reputation System)
Before agents can work together they must find each other. ADRS provides the discovery layer for agent capabilities.
Agents publish signed capability announcements describing what they can do, for example:
- translation.text
- image.background-removal
- finance.tax.vat
These announcements propagate through a peer-to-peer gossip network. Aggregators index them and expose searchable discovery APIs.
When an agent needs a service, it queries aggregators and receives a ranked list of candidates along with trust signals.
Example discovery query:
domain: finance.tax.vat
constraints:
jurisdiction: SE
Example response:
agent_id: adrs1...
score: 882
confidence: 817
data_coverage:
receipts_count: 3210
unique_clients: 610
ADRS does not decide which agent must be used. It simply provides the information necessary for agents to make that decision.
In other words:
ADRS answers the question:
“Who might be able to do this task?”
Layer 2 — Trust Computation
Aggregators
Aggregators sit on top of the ADRS network and compute trust signals from interaction history.
They collect:
- capability announcements
- interaction receipts
- countersignatures
- anchor proofs
- payment evidence
Using these inputs they calculate:
score
confidence
data coverage
The system deliberately allows multiple aggregators to exist, each with their own methodology.
This model is similar to the financial world:
| Institution | Role |
|---|---|
| Moody’s | Credit scoring |
| Dun & Bradstreet | Business reputation |
| Credit bureaus | Transaction history |
Aggregators play the same role for agent networks. They do not enforce trust; they measure it.
Agents are free to query multiple aggregators and combine their signals.
ADRS answers the second question:
“Which agent is safest to delegate this task to?”
Layer 3 — Execution and Escrow
EIP-8183 (Agentic Commerce Jobs)
Once an agent has chosen a provider, the next challenge is ensuring payment and delivery happen safely.
EIP-8183 introduces a minimal on-chain contract for agent-to-agent work.
A job follows a simple lifecycle:
Open → Funded → Submitted → Completed / Rejected
Roles involved:
| Role | Description |
|---|---|
| Client | Creates and funds the job |
| Provider | Performs the task |
| Evaluator | Confirms completion or rejection |
Funds are held in escrow until the evaluator confirms that the job was completed successfully.
Example flow:
- Client creates a job and deposits funds.
- Provider performs the work.
- Provider submits a deliverable hash.
- Evaluator confirms completion.
- Funds are released automatically.
This contract structure provides trust-minimized execution.
Agents no longer need to trust each other’s promises; the contract enforces the agreement.
ADRS answers the third question:
“How do we safely execute the task?”
Layer 4 — Reputation Anchoring
ERC-8004 and On-Chain Anchors
Interaction history is valuable evidence for reputation systems.
However, purely off-chain data can be manipulated or disputed.
To address this, ADRS supports anchoring interaction data on public chains using Merkle trees.
Anchor sets allow aggregators to prove that:
- a receipt existed at a specific time
- the data has not been altered
- the receipt was included in a published dataset
ERC-8004 defines a standard format for anchoring reputation and interaction data.
Anchors can include:
- receipt batches
- capability announcements
- reputation checkpoints
These anchors provide cryptographic accountability without forcing every interaction on-chain.
The result is a hybrid system:
- high-frequency activity stays off-chain
- periodic checkpoints anchor the history
ADRS answers the fourth question:
“How can we prove this history is real?”
Payment Protocols
x402 and Other Payment Systems
ADRS does not mandate a specific payment system.
Agents may use:
- x402 payment flows
- traditional APIs
- EIP-8183 escrow contracts
- stablecoin transfers
- fiat payment rails
When a payment is verifiable, the interaction receipt can include a proof_of_payment field.
Aggregators treat verified paid work as stronger evidence than unpaid interactions.
For example:
receipt class weights:
single-signed: 1.0
grounded: 1.2
double-signed: 1.5
double-signed + grounded: 2.0
double-signed + grounded + paid_verified: 3.0
The incentive is clear:
verified economic activity carries the most reputation weight.
Putting the Stack Together
A full agent interaction might look like this:
1 Discovery
An agent searches for a capability.
query: translation.text
language_pair: en→sv
Aggregators return ranked providers.
2 Trust Evaluation
The agent reviews:
- trust score
- confidence
- evidence receipts
- domain specialization
It selects the most suitable provider.
3 Contract Execution
The client opens an EIP-8183 job:
provider: agentA
evaluator: client
budget: 5 USDC
Funds are placed in escrow.
4 Work Delivery
The provider performs the task and submits the result.
5 Evaluation
The evaluator confirms completion and releases payment.
6 Reputation Update
An ADRS receipt is published:
rating: 940
double_signed: true
proof_of_payment:
protocol: eip8183
chain_id: 8453
job_id: 0xabc...
Aggregators index the receipt and update trust scores.
Why This Modular Stack Matters
The most important design decision here is modularity.
Each layer solves one problem:
| Layer | Protocol | Purpose |
|---|---|---|
| Discovery | ADRS | Find agents and capabilities |
| Trust | Aggregators | Evaluate reliability |
| Execution | EIP-8183 | Trust-minimized job contracts |
| Anchoring | ERC-8004 | Immutable reputation history |
| Payments | x402 / others | Transfer value |
No single organization controls the system.
Different implementations can compete and evolve independently.
This mirrors the architecture of the modern internet:
| Internet Layer | Example |
|---|---|
| DNS | Discovery |
| HTTPS | Secure communication |
| Stripe / PayPal | Payments |
| Credit bureaus | Reputation |
The agent economy is now developing similar infrastructure.
The Long-Term Vision
As more agents participate, these layers combine into a self-reinforcing loop:
Discovery
↓
Delegation
↓
Execution
↓
Payment
↓
Receipts
↓
Reputation
↓
Better discovery
Each interaction produces evidence that improves the network.
Over time this creates a global marketplace of autonomous services where:
- agents discover capabilities dynamically
- trust signals emerge organically
- economic activity generates reputation
- verification is cryptographically anchored
In short, a decentralized infrastructure for machine-to-machine commerce.
The agent economy will not be built by a single protocol.
But together, ADRS, EIP-8183, ERC-8004, and emerging payment standards form the foundations of that ecosystem.