agent-transfer-protocol 1.0.0a1

Agent Transfer Protocol (ATP): secure agent-to-agent communication

ATP: Agent Transfer Protocol

Secure agent-to-agent communication over the Internet.

A communication protocol for agent-to-agent transfer.
DNS-based discovery, mandatory Ed25519 signing, server-mediated delivery.

  Agent A           ATP Server A          ATP Server B          Agent B
    |                    |                     |                    |
    |---[1. Submit]----->|                     |                    |
    |                    |                     |                    |
    |              2. Credential Verify        |                    |
    |                    |                     |                    |
    |              3. DNS SVCB Discover        |                    |
    |                    |                     |                    |
    |                    |--[4. Transfer]----->|                    |
    |                    |   TLS 1.3 + POST    |                    |
    |                    |                     |                    |
    |                    |               5. ATS+ATK Query (DNS)    |
    |                    |               6. Sender Authenticated   |
    |                    |                     |                    |
    |<---[202 Accepted]--|                     |---[7. Deliver]--->|
    |                    |                     |                    |

Quick Start · Python SDK · CLI Reference · Documentation

---

Why ATP?

Agents need a standard way to communicate across the Internet: securely, without a central registry, using infrastructure that already exists.

Feature	How
Identity	local@domain format, powered by DNS
Discovery	DNS SVCB records, no central registry needed
Signing	Ed25519 on every message, verified at every hop
Authorization	ATS policies in DNS, control who can send for your domain
Delivery	Store-and-forward with retry, messages don't get lost

Install

pip install atp

Requires Python 3.11+

Quick Start

# 1. Generate an Ed25519 key pair
atp keys generate

# 2. Start a server
atp server start --domain example.com --port 7443 --local

# 3. Send a message (from another terminal)
atp send [e-mail] --from [e-mail] --body "Hello!" --local

# 4. Check server status
atp status --server localhost:7443 --local

Try It: Two Servers Talking

Run two servers locally and send messages between them, no DNS needed:

# Terminal 1
atp server start --domain alice.local --port 7443 --local --peers peers.toml

# Terminal 2
atp server start --domain bob.local --port 7444 --local --peers peers.toml

# Terminal 3: Alice sends to Bob
atp send [e-mail] \
  --from [e-mail] \
  --server localhost:7443 \
  --local \
  --body "Hello Bob!"

# Terminal 4: Bob receives
atp recv --agent-id [e-mail] --server localhost:7444 --local

peers.toml

["alice.local"]
host = "127.0.0.1"
port = 7443

["bob.local"]
host = "127.0.0.1"
port = 7444

Python SDK

import asyncio
from atp.client.client import ATPClient

async def main():
    client = ATPClient(
        agent_id="[e-mail]",
        server_url="localhost:7443",
        local_mode=True,
    )

    # Send
    result = await client.send("[e-mail]", body="Hello from SDK")
    print(result)  # {"status": "accepted", "nonce": "msg-..."}

    # Receive
    messages = await client.recv()
    for msg in messages:
        print(f"{msg.from_id}: {msg.payload}")

    await client.close()

asyncio.run(main())

CLI Reference

Core Commands

Command	Description
atp server start	Start ATP server
atp send <to>	Send a message
atp recv	Receive messages

Key Management

Command	Description
atp keys generate	Generate Ed25519 key pair
atp keys show	Show key info
atp keys list	List all keys
atp keys rotate	Rotate to a new key

Operations

Command	Description
atp status	Show server status and metrics
atp inspect <nonce>	Inspect a specific message

DNS

Command	Description
atp dns generate	Generate DNS records for your domain
atp dns check	Verify DNS records are configured

Run atp <command> --help for options.

Production Deployment

For production, configure DNS records. ATP generates them for you:

# Step 1: Generate the records
atp dns generate --domain example.com --ip 203.0.113.1

# Step 2: Add them to your DNS provider (Cloudflare, Route53, etc.)

# Step 3: Verify
atp dns check --domain example.com

# Step 4: Start with TLS
atp server start --domain example.com --cert server.crt --key server.key

See the DNS Setup Guide for details.

Security

ATP provides three layers of security, inspired by email's battle-tested approach:

Layer	ATP	Email Equivalent	Purpose
Transport	TLS 1.3	STARTTLS	Encrypted connections
Authorization	ATS	SPF	Who can send for a domain
Integrity	ATK (Ed25519)	DKIM	Message signing & verification

Every message is cryptographically signed. Every hop verifies independently.

Documentation

Quick Start	Full walkthrough with two servers
Configuration	CLI options, config file, retry policy
DNS Setup	Production DNS configuration
Security Model	ATS, ATK, TLS explained in depth
Python SDK	API reference for developers
Architecture	Module design for contributors

Protocol Specification

ATP is defined as an IETF Internet-Draft (Standards Track):

Agent Transfer Protocol (ATP) draft-li-atp · March 2026 Xiang Li, Lu Sun, Yuqi Qiu, Nankai University, AOSP Laboratory

IETF Datatracker · Full Text

Contributing

git clone https://github.com/AospLab/atp.git
cd atp
pip install -e ".[dev]"
python -m pytest tests/ -v    # 195 tests

See Architecture for module design and development guide.

License

MIT