ASYNC DATA TRANSPORT PROTOCOL

The async data layer
for agents and humans.

ADTP is an open protocol for sending signed, structured data between agents, apps, and people: asynchronously, over plain HTTPS, addressed like email.

It is the delivery layer. It holds a payload, retries until it arrives, and reports back when it was delivered and read.

agent@acme.example
  1. 01  FIND
  2. 02  SIGN
  3. 03  SEND
  4. 04  STORE
  5. 05  DELIVER
scheduler@globex.example

There is no standard way for an agent to reach another agent it has never met.

Not at a company it has no integration with. Not when the other side may be offline. Not when the other side is a person. So every platform reinvents delivery, and answers the same questions on its own.

How do I address an agent at another company?

Like email: agent@company.com, found through ordinary DNS.

How does the recipient know who sent it, and that it wasn't changed?

Every payload is signed by the sending domain and checked on arrival.

What if the other side is offline?

The payload is held and retried until it arrives or expires.

Did it arrive? Was it read?

Signed receipts: stored, delivered, read, replied, or failed.

Can people and agents reach each other?

Yes. The receiving node delivers to an agent or to a person's inbox, and an agent can act on a person's behalf.

What about messages from strangers?

A first message from an unknown sender waits for the recipient's approval and is rate-limited.

Each domain runs one node.
Agents and apps hand it data.

The same shape as mail: you run a server for your domain, and anyone who can find your domain in DNS can reach you.

  1. 01

    Run a node

    A node is one container. It uses SQLite out of the box and Postgres with one setting.

    1 container · SQLite | Postgres
  2. 02

    Publish your domain

    A DNS TXT record at _adtp.<domain> points other nodes to your card: where to send, and which public keys you sign with.

    _adtp.acme.example  TXT  → card
  3. 03

    Hand it data

    Agents and apps address payloads like email and give them to their own node. It signs, sends, retries and collects receipts. On the other side, the payload lands with an agent or in a person's inbox.

    agent@acme.example → node

NOT REQUIRED

  • A directory to join
  • A central registry
  • An integration per counterpart
  • Signing keys in agents

A hosted option at adtp.run is planned, not built. See roadmap.

Find, sign, send, store, deliver.

Each domain runs a node, the way each mail domain runs a mail server. An agent hands a message to its own node and never holds a signing key.

agent@acme.example

Sending agent. Holds no key.

hand off

node · acme.example

1Find: DNS TXT _adtp.globex.example

2Sign: Ed25519

3SendHTTPS POST

node · globex.example

4Store: check signature, store, return signed receipt

5Deliver

scheduler@globex.example

Agent, or a person's inbox.

Signed receipts back to the sender: stored · delivered · read · replied · failed
  1. 01

    Find

    The sender's node looks up a DNS TXT record at _adtp.<domain>. It points to a small card for the recipient: where to send, and which public keys it signs with.

  2. 02

    Sign

    The node wraps the message in a JSON envelope and signs it with Ed25519.

  3. 03

    Send

    One HTTPS POST of the envelope to the recipient's node.

  4. 04

    Store

    The recipient's node checks the signature against the sender's card, stores the message, and answers with a signed receipt. If it is down, the sender's node keeps retrying with backoff until the message expires.

  5. 05

    Deliver and report

    The recipient's node hands the message to the agent (or to a person's inbox) and sends back status receipts: delivered, read, replied, or failed.

A MESSAGEenvelope.json · Ed25519 · kid 2026-11-a
{
  "adtp": "0",
  "id": "msg_01KAGZ4Q8Y5V7W3N9M2T6R0XEB",
  "from": "agent@acme.example",
  "on_behalf_of": "dana@acme.example",
  "to": ["scheduler@globex.example"],
  "intent": "request",
  "created_at": "2026-11-21T10:00:00Z",
  "content": { "parts": [{ "type": "text", "text": "Can you meet Thursday at 10?" }] },
  "delegation": "<token signed by dana's key>",
  "signature": { "alg": "Ed25519", "kid": "2026-11-a", "value": "..." }
}
{
  "adtp": "0",
  "id": "msg_01KAGZ4Q8Y5V7W3N9M2T6R0XEB",
  "from": "agent@acme.example",
  "on_behalf_of": "dana@acme.example",
  "to": ["scheduler@globex.example"],
  "intent": "request",
  "created_at": "2026-11-21T10:00:00Z",
  "content": {
    "parts": [{
      "type": "text",
      "text": "Can you meet Thursday at 10?"
    }]
  },
  "delegation": "<token signed by
     dana's key>",
  "signature": {
    "alg": "Ed25519",
    "kid": "2026-11-a",
    "value": "..."
  }
}
from · on_behalf_of
An agent at acme.example, sending for Dana.
intent
What the payload asks for. See Structured data below.
delegation
Proof that Dana authorised this agent. See Delegation below.
signature
Made with a key published under acme.example.

PROPERTIES

THE DIFFERENCE FROM EMAIL

Structured data, not prose.

Each payload states an intent and can carry text, data and file links, so the receiving agent, app or person knows what is being asked.

INTENT

  • inform
  • request
  • propose
  • accept
  • …

PARTS

  • text
  • data
  • file links

Addressing

Addresses are local@domain, found through a DNS TXT record under the recipient's domain.

Store-and-forward

Payloads are held and retried until they arrive or expire.

Signed like DKIM

Every payload is signed with a key published under the sender's domain, the same trust model as DKIM. Tampering in transit is detected.

Delegation

An agent acting for a person carries a short-lived token signed by that person's key, limited to certain kinds of message, and revocable.

Receipts

A signed receipt when the payload is stored, then delivered, read, replied or failed.

As of v0

Exists today

04
  • A written v0 specification.
  • A reference node in TypeScript, to be released under the MIT license.
  • A demo in which two agents on two domains exchange one signed message, with receipts and a reply, in about a tenth of a second on one machine.
  • About 250 automated tests, run on both SQLite and Postgres.

Not yet

05
  • Both sides have only run on one machine. A run across two real domains over the public internet is the next step.
  • The specification and code are not public yet.
  • A hosted version with one-click setup (add your domain, the DNS records are written for you, a node starts) is planned, not built.
  • There is no end-to-end encryption. The two nodes can read message contents.
  • The aim is to take the specification to the IETF. That has not started.

From open spec to the new default

ADTP is the async data layer for agents and humans. Here's how we get from here to everywhere.

  1. 01BUILT · NOT YET PUBLIC

    Open Spec

    Publish the protocol in the open.

    A clear spec, a reference node anyone can self-host, and an MIT license. Agents can send structured data to any ADTP address over plain HTTPS.

  2. 02PLANNED

    Builders

    Make it effortless to adopt.

    SDKs, a hosted option at adtp.run, and integrations with the agent frameworks developers already use. Spin up an address for your agent in minutes.

  3. 03PLANNED

    Network

    Grow the web of connected nodes.

    Custom domains, discovery between servers, and trust and verification built in, so agents and people can find each other and know who they're talking to.

  4. 04PLANNED

    People

    Bring humans into the loop.

    Apps and inboxes where people send, receive, and act on structured data alongside their agents, not just read messages.

  5. 05PLANNED

    The New Default

    An open standard that works everywhere.

    Async communication between agents, apps, and people, owned by no one and usable by anyone.

Email took decades to connect the world. ADTP is built for what comes next.

Behind it
Stratus Labs
Specification and code
github.com/adtprotocol · to be published
Contact
hello@adtprotocol.com