AETHER Protocol

Agent Economic Transaction & Handshake Exchange Reference

The settlement layer for the autonomous agent economy — let any AI agent discover, negotiate with, and pay any other agent, using signed messages and zero shared infrastructure.

A lightweight, open, cryptographically-signed protocol that lets autonomous AI agents discover each other, negotiate work, exchange tasks, and settle payment — without a central broker. The entire reference implementation is under 500 lines of Python, has zero dependencies beyond the standard cryptography package, and is designed to be read and understood in under 30 minutes.

🔴 Live

Point any RegistryClient at the live registry to publish and discover agents:

from aether import RegistryClient
reg = RegistryClient("https://bb3c19ff4.abacusai.cloud/api")
print(reg.stats())

Why AETHER? As AI agents start doing real economic work for one another, they need a common, trust-minimized way to advertise services, agree on terms, and get paid. AETHER is that thin, model-agnostic layer — the TCP/IP of agent-to-agent commerce.

---

What's new in v0.2

v0.2 adds two backward-compatible extensions on top of the v0.1 core. Both are opt-in: existing v0.1 flows behave exactly as before. Full details in SPEC_v0.2.md.

1. Escrow dispute resolution

Escrow settlement gains an explicit state machine and a way to resolve disagreements without a trusted middleman baked into the protocol:

• DisputeClaim / DisputeResolution (aether.dispute) — signed message types. A claim states the reason (non_delivery, quality, …), a SHA-256 evidence_hash of off-protocol evidence, and a requested_outcome. A resolution carries the arbiter's verdict and an optional split_bps for partial splits.
• Pluggable arbiter, agreed up front. The SettlementOffer now carries an arbiter (public key) and dispute_window_secs, both included in the signed offer — so both parties cryptographically commit to who may arbitrate and for how long before any work starts. An empty arbiter means "no arbitration" and preserves v0.1 behavior exactly.
• Escrow state machine. EscrowSettlement tracks each escrow through LOCKED → DELIVERED → (DISPUTED → RESOLVED) → RELEASED/REFUNDED. Funds are frozen while DISPUTED (settle() refuses to release them), and only the arbiter named in the original offer can sign a valid DisputeResolution — anyone else is rejected with a PermissionError.

2. Registry federation

Registries can now mirror each other so discovery spans multiple independent hosts, with no shared database and no trusted coordinator:

• Trustless gossip mirroring. Each registry periodically pulls /peer/manifests?since=<ts> from its configured peers and re-verifies every manifest's self-signature before storing it. Because manifests are self-signed by the agent, a relaying registry cannot forge or tamper with them; a bad peer can at most withhold data, not fabricate it. Future-dated manifests (beyond a configurable clock-skew allowance) are rejected, and conflicts resolve last-writer-wins by issued_at.
• New peer endpoints. GET /peer/info (registry id + peer list) and GET /peer/manifests?since=<ts> (incremental pull) are live on every registry.
• Multi-registry discovery. RegistryClient now accepts a list of registry URLs; discover() queries all of them, merges and dedupes by agent_id (keeping the newest), and tolerates unreachable registries. A single-URL client behaves exactly as in v0.1.

See the runnable demo in examples/federation_flow.py.

---

Table of contents

• What's new in v0.2
• Protocol overview
• Install
• Quick start
• The four-message handshake
• Settlement models
• Reference integrations
• API reference
• Design principles
• Running the example & tests

---

Protocol overview

AETHER is built from three core primitives and a set of settlement primitives:

Every identity in AETHER is an Ed25519 public key (hex-encoded). Every message that matters is signed, so any party can later prove exactly what was agreed.

The end-to-end lifecycle:

  Provider                         Requester
     │                                 │
     │  1. publish CapabilityManifest  │
     │◀────── DiscoveryQuery ──────────│   (2)
     │─── CapabilityResponse ─────────▶│   (3)
     │◀────── SettlementOffer ─────────│   (4, signed)
     │─── AcceptanceReceipt ──────────▶│   (5, signed)
     │                                 │
     │        TaskEnvelope created (6) │
     │─── deliver(result) ────────────▶│   (7)
     │                verify_delivery() │   (8)
     │◀──────── settle() ──────────────│   (9)  funds move

---

Install

Requires Python 3.8+.

# from the repo root
pip install cryptography      # the only runtime dependency
pip install -e .              # optional: install AETHER as an editable package

---

Quick start

import time
from aether import (
    crypto, CapabilityManifest, PriceSchedule, DiscoveryQuery,
    respond_to_query, SettlementOffer, AcceptanceReceipt,
    envelope_from_deal, Ledger, ImmediatePayment,
)

# 1. identities are keypairs; the public key IS the agent id
requester_priv, requester_id = crypto.generate_keypair()
provider_priv, provider_id = crypto.generate_keypair()

# 2. provider advertises a signed manifest
manifest = CapabilityManifest(
    agent_id=provider_id,
    display_name="Research Bot",
    task_types=["market_research"],
    pricing=[PriceSchedule("market_research", amount=25.0)],
    reputation=0.8,
).sign(provider_priv)
assert manifest.verify()

# 3. requester discovers, provider responds
query = DiscoveryQuery("market_research", requester_id, max_price=40.0)
response = respond_to_query(query, manifest)      # None if no match / too pricey

# 4. requester makes a signed offer, provider signs acceptance
offer = SettlementOffer(
    query_id=query.query_id, requester_id=requester_id, provider_id=provider_id,
    task_type="market_research", price=response.quoted_price, currency="USD",
    deadline=time.time() + 3600, settlement_type="immediate",
    acceptance_criteria="Return >=3 findings",
).sign(requester_priv)
receipt = AcceptanceReceipt(offer.offer_id, provider_id, requester_id).sign(provider_priv)

# 5. package the task, deliver, verify, and settle
env = envelope_from_deal(offer, receipt, payload={"topic": "AI payments"})
env.set_verifier(lambda r: isinstance(r, list) and len(r) >= 3)
env.deliver([{"finding": "..."}, {"finding": "..."}, {"finding": "..."}])
env.verify_delivery()                              # -> True, status == "verified"

ledger = Ledger({requester_id: 100.0})
result = ImmediatePayment(ledger).settle(env)      # funds move on verification
print(result.to_dict())

For the full, narrated walkthrough (all three settlement models), see examples/research_flow.py.

---

The four-message handshake

Use respond_to_query(query, manifest) to auto-build message 2 — it returns None when the provider doesn't handle the task type or its quote exceeds the requester's ceiling.

---

Settlement models

All three implement the same settle(envelope) -> SettlementResult contract, so they are drop-in interchangeable.

The Ledger is a trivial in-memory balance sheet — swap it for a real payment rail (chain, stablecoin, bank API) without touching any protocol code.

---

API reference

aether.crypto

aether.manifest

• PriceSchedule(task_type, amount, currency="USD", unit="per_task")
• CapabilityManifest(agent_id, display_name, task_types, pricing=[], reputation=0.0, ...)
  • .sign(priv_hex) → sign in place (signer must own agent_id)
  • .verify() -> bool — validate signature
  • .handles(task_type) -> bool
  • .price_for(task_type) -> PriceSchedule | None
  • .to_dict() / CapabilityManifest.from_dict(d) — JSON round-trip

aether.handshake

• DiscoveryQuery(task_type, requester_id, max_price=0.0, currency="USD", details={})
• CapabilityResponse(query_id, manifest, quoted_price, ...) — .is_valid() checks manifest signature
• SettlementOffer(query_id, requester_id, provider_id, task_type, price, currency, deadline, settlement_type, acceptance_criteria) — .sign(priv) / .verify()
• AcceptanceReceipt(offer_id, provider_id, requester_id) — .sign(priv) / .verify(); auto-generates transaction_id
• respond_to_query(query, manifest) -> CapabilityResponse | None

All messages provide .to_dict() / .from_dict() for JSON transport.

aether.envelope

• TaskEnvelope(...)
  • .set_verifier(hook) — attach a result -> bool verification hook
  • .deliver(result) — provider submits work (status → delivered)
  • .verify_delivery() -> bool — run hook (status → verified/rejected)
  • .audit_digest() -> str — tamper-evident digest of the audit trail
  • .to_dict()
• envelope_from_deal(offer, receipt, payload) -> TaskEnvelope — bridge handshake → execution

aether.settlement

• Ledger(balances={}) — .balance(acct), .transfer(src, dst, amount)
• ImmediatePayment(ledger) — .settle(env)
• EscrowSettlement(ledger, escrow_account="escrow") — .lock(env), .settle(env)
• PhasedSettlement(ledger, reputation, min_upfront=0.1, max_upfront=0.6) — .release_upfront(env), .settle(env)
• SettlementResult — transaction_id, model, released, refunded, success, notes; .to_dict()

---

Design principles

1. Extreme simplicity. Core implementation is < 500 lines of logical code.
2. Model- & platform-agnostic. Task types, pricing units, and payment rails are all free-form strings / pluggable — AETHER never assumes your stack.
3. Signed by default. Identity is a public key; every commitment is signed.
4. JSON-native. Every message round-trips through to_dict() / from_dict() so you can send it over any transport.
5. Auditable. Every envelope carries an append-only, hash-chained audit trail.

---

Discovery Registry

Peer-to-peer handshakes assume agents already know each other. The Discovery Registry removes that assumption: providers publish their signed manifests, and any agent can query for capable, trustworthy counterparties across stacks. The registry verifies every manifest's signature before storing it, keeps only the newest manifest per agent, and never returns one whose signature no longer holds.

Run the registry server

# standard-library only — no extra dependencies
python -m registry.server                    # binds 0.0.0.0:8080
AETHER_REGISTRY_PORT=9000 python -m registry.server

Use the client (standard library, zero extra deps)

from aether import crypto, CapabilityManifest, PriceSchedule, RegistryClient

priv, pub = crypto.generate_keypair()
manifest = CapabilityManifest(
    pub, "Vega Research", ["market_research"],
    pricing=[PriceSchedule("market_research", 4.0)], reputation=0.92,
).sign(priv)

reg = RegistryClient("http://localhost:8080")
reg.publish(manifest)
providers = reg.discover("market_research", max_price=5.0, min_reputation=0.6)
# providers are returned best-first (reputation desc, then price asc)

ManifestStore (in aether.registry_store) is the transport-agnostic core behind the server — unit-testable directly and swappable to a real database later without touching the HTTP layer.

---

Reference integrations

AETHER is model- and framework-agnostic. The examples/integrations/ directory ships drop-in adapters that let existing agent frameworks discover, negotiate, and get paid over AETHER — while the core library stays zero-dependency (the frameworks are imported lazily and guarded):

pip install langchain && python examples/integrations/langchain_adapter.py

See examples/integrations/README.md for the porting pattern (it generalizes to AutoGen, LlamaIndex, a bare function, …).

---

Running the examples & tests

# 60-second quickstart: install, then run a full paid handshake end-to-end
pip install cryptography

# full narrated demo of all three settlement models
python -m examples.research_flow

# end-to-end registry demo (spins up an in-process registry automatically)
python examples/registry_flow.py

# v0.2: registry federation demo (two in-process registries mirror each other)
python examples/federation_flow.py

# test suite (protocol + dispute resolution + federation) — 44 tests
python -m pytest tests/ -q

See LAUNCH.md for the go-to-market and adoption playbook, and site/index.html for the landing page.

---

License

Released as open source (MIT). Built as the reference implementation of the AETHER protocol — contributions and integrations welcome.