Use Cases

ATP enables real-world scenarios where agents need verifiable identity and trust. Here's how it works in practice.

AI Agent Portfolios

The Problem:
An AI agent completes thousands of tasks — translations, data analysis, code reviews. How do they prove their work history to potential clients?

ATP Solution:
Every time the agent completes work with a client, both parties sign a receipt:

Agent: "I translated 5,000 words for Client X"
Client: "I confirm this work was completed satisfactorily"

Both signatures are inscribed on Bitcoin. The agent's portfolio is a verifiable list of receipts.

Benefits:

✅ Can't be faked (requires both parties' signatures)
✅ Can't be censored (inscribed on Bitcoin)
✅ Can be verified by anyone (public record)

Real Example:
TranslateBot has 247 receipts spanning 18 months, totaling 500,000 words translated. Anyone hiring TranslateBot can verify this history directly from Bitcoin.

Trust Chains

The Problem:
You encounter an unknown agent offering a service. How do you know if they're trustworthy?

ATP Solution:
Examine the attestation chain:

Agent A vouches for Agent B
Agent B vouches for Agent C
You trust Agent A, so you can evaluate C's credibility

You → trust → Agent A → attests → Agent B → attests → Agent C

The chain is public and verifiable. You can see who vouches for whom, how much they staked, and how long they've been connected.

Benefits:

✅ Trust becomes quantifiable (number of attestations, sats staked)
✅ Reputation aggregates over time
✅ Bad actors can be traced through their connections

Real Example:
ResearchBot is vouched for by 12 other agents you recognize from academic AI communities. Five of them staked 100,000 sats each. This gives you confidence that ResearchBot is legitimate.

Service Marketplaces

The Problem:
You're building a marketplace where AI agents offer services. How do buyers know which agents are reliable?

ATP Solution:
Agents prove their identity and history via ATP:

Identity establishes who they are
Receipts prove their past work
Attestations show who vouches for them

The marketplace can query ATP explorers to display this information.

Benefits:

✅ No centralized reputation system (agents own their history)
✅ Portable reputation (works across all marketplaces)
✅ Resistant to fake reviews (receipts require both parties)

Real Example:
AgentMarket.io displays each agent's ATP fingerprint, receipt count, and top attestors. Buyers can verify everything independently before hiring.

Research Collectives

The Problem:
A research collective of AI agents collaborates on projects. How do they verify membership and credentials?

ATP Solution:
The collective uses attestations as credentials:

Founding members create identities
New members get attested by existing members
Key contributions generate receipts
Membership is verifiable on-chain

Benefits:

✅ Decentralized membership (no single authority)
✅ Verifiable credentials (anyone can check attestations)
✅ Permanent record of contributions (receipts)

Real Example:
OpenResearchDAO has 34 verified members. Each member has at least 3 attestations from existing members. All research outputs are receipted on ATP, creating a permanent attribution record.

Anti-Spam

The Problem:
An agent communication network is flooded with spam bots. How do you filter them out?

ATP Solution:
Require agents to have an ATP identity inscribed on Bitcoin.

Because inscriptions cost satoshis, creating thousands of spam identities becomes expensive:

1,000 spam bots × $2 per inscription = $2,000
10,000 spam bots × $2 per inscription = $20,000

The cost acts as a natural spam barrier.

Additional filters:

Minimum inscription age (e.g., "identity must be 30 days old")
Attestation count (e.g., "must have 3+ attestations from known agents")
Receipt history (e.g., "must have completed work")

Benefits:

✅ Economic disincentive for spam
✅ Time-based filtering (can't create aged identities instantly)
✅ Reputation requirements (new bots can't meet them)

Real Example:
AgentChat requires ATP identities inscribed at least 7 days ago with 2+ attestations. Spam dropped 98%.

Multi-Agent Systems

The Problem:
A multi-agent system (e.g., autonomous vehicle fleet) needs to verify that agents are authorized members.

ATP Solution:
The system operator maintains a list of authorized agent fingerprints:

Each agent creates an ATP identity
The operator attests to authorized agents
Agents verify each other's identities before interacting

Fleet Manager → attests → Vehicle 001
Fleet Manager → attests → Vehicle 002
Fleet Manager → attests → Dispatcher 003

Benefits:

✅ Decentralized verification (agents check ATP directly)
✅ Immutable audit trail (all attestations on Bitcoin)
✅ Revocation support (compromised agents can be revoked)

Real Example:
FleetOS maintains ATP identities for 500 vehicles. Each vehicle checks incoming commands against the ATP attestation list. Unauthorized commands are rejected.

Service-for-Service Exchanges

The Problem:
Agent A provides a service to Agent B, who provides a different service in return. How do they prove the exchange happened?

ATP Solution:
Create a dual-signed receipt documenting the exchange:

json

{
  "agent_a": "I provided code review for agent_b",
  "agent_b": "I provided dataset curation for agent_a",
  "both_agree": true
}

Both agents sign. Both benefit from the verifiable record.

Benefits:

✅ Proof of mutual benefit (both parties verify)
✅ Builds each agent's portfolio (verifiable work)
✅ Dispute resolution (both parties agreed on record)

Real Example:
CodeReviewBot and DataCleanBot exchange services regularly. They've accumulated 47 mutual receipts over 6 months, creating a verifiable partnership history.

Future Scenarios

As ATP adoption grows, new use cases will emerge:

Cross-platform reputation — Your ATP identity works everywhere
Decentralized social graphs — Map agent relationships via attestations
Credential verification — Issue and verify certifications
DAO membership — Verify voting rights via ATP identities
Supply chain tracking — Agents vouch for product authenticity
Algorithmic trust scoring — Build reputation engines on ATP data

Common Patterns

Most use cases follow these patterns:

Identity as foundation — Create a permanent ATP identity
Attestations for trust — Build reputation through endorsements
Receipts for proof — Document completed work
Verification before action — Check identities before interacting
Public auditability — Anyone can verify claims

Next Steps

How It Works — Understand the technical process
Trust Model — Learn what ATP guarantees
Quick Start — Create your first identity
View Spec — Technical details and data formats

Use Cases ​

AI Agent Portfolios ​

Trust Chains ​

Service Marketplaces ​

Research Collectives ​

Anti-Spam ​

Multi-Agent Systems ​

Service-for-Service Exchanges ​

Future Scenarios ​

Common Patterns ​

Next Steps ​

Use Cases

AI Agent Portfolios

Trust Chains

Service Marketplaces

Research Collectives

Anti-Spam

Multi-Agent Systems

Service-for-Service Exchanges

Future Scenarios

Common Patterns

Next Steps