.png)
2 hours ago
1
Federated, asynchronous communication protocol for reliable agent-to-agent communication across organizational boundaries
Protocol Overview
The Agent Message Transfer Protocol (AMTP) extends the familiar email addressing model with native support for structured data, multi-agent coordination, and guaranteed delivery semantics. Built for the age of AI agents, AMTP provides a standardized way for autonomous systems to communicate reliably across organizational boundaries.
Universal Addressing
Uses familiar agent@domain format, making it intuitive for developers and compatible with existing infrastructure.
Federated Architecture
Decentralized design with DNS-based discovery enables secure communication between organizations without central authority.
Structured Data
Native JSON payloads with optional schema validation ensure reliable data exchange between different agent implementations.
Key Features
🌐
Universal Addressing
Standard agent@domain format for intuitive and familiar addressing
🔄
Protocol Upgrade
Transparent protocol upgrade with bridging email transparently
✅
Delivery Guarantees
At-least-once delivery with idempotency guarantees and retry logic
📋
Schema Integration
Standard schema integration via AGNTCY framework for payload validation
🤝
Multi-Agent Coordination
Built-in support for parallel, sequential, and conditional workflow patterns
🏗️
Federated Architecture
DNS-based discovery enables decentralized communication without central authority
Architecture
Protocol Stack
AMTP is built on standard internet protocols, ensuring reliability and compatibility:
- Application Layer: Agent Logic
- AMTP Protocol: Message Format and HTTP Endpoints
- Transport Layer: HTTPS for Reliable Delivery
- Discovery Layer: DNS for Addressing & Capabilities
- Network Layer: Standard Internet
Application Layer
AMTP Protocol
Transport Layer (HTTPS)
Discovery Layer (DNS)
Network Layer (TCP/IP)
System Components
AMTP uses a federated gateway architecture where each domain operates its own gateway:
Agent A
(sender.com)
→
AMTP Gateway
(sender.com)
→
AMTP Gateway
(receiver.com)
→
Agent B
(receiver.com)
Getting Started
1
Read the Specification
Start by understanding the AMTP protocol specification, including message formats, addressing, and coordination patterns.
2
Deploy a Gateway
Set up an AMTP gateway for your domain using the reference implementation or build your own.
3
Configure DNS
Add DNS TXT records to advertise your AMTP capabilities and enable discovery by other domains.
_amtp.yourdomain.com. IN TXT "v=amtp1;gateway=https://amtp.yourdomain.com"
4
Integrate Agents
Connect your AI agents to the gateway using SDK. Get started quickly with our Python SDK for rapid development.
Frequently Asked Questions
Is AMTP only for AI agents?
No. AMTP is designed for any autonomous or semi-autonomous software entity that needs reliable, federated communication. While AI agents are the primary driver, the protocol equally supports traditional services, workflows, and system integrations that benefit from asynchronous, cross-domain messaging, like email-based automation.
Why not just extend email (SMTP)?
SMTP was built for humans, not agents. It lacks structured payloads, workflow semantics, strong delivery guarantees, and modern security. AMTP keeps email's federation model but adds reliability, schema support, and multi-agent coordination.
Why not build HTTP APIs on top of SMTP?
Building HTTP APIs "on top of SMTP" is architecturally problematic—it's like sending REST calls as email attachments. While technically feasible, this approach inherits all of SMTP's limitations: high latency, weak delivery semantics, inadequate authentication mechanisms, and opaque transport characteristics that obscure error handling and debugging.
Can AMTP also be used for intra-org?
Yes. Although AMTP is designed for cross-organization federation, the same features—reliable delivery, schema validation, and workflow coordination—work equally well inside a single organization. AMTP gateways can be deployed internally to unify messaging across business units or systems, while still benefiting from the same durability and discovery mechanisms.
Why not MCP (Model Context Protocol)?
MCP is designed as a client-server interface for LLMs to access tools, data, and prompts. It solves the model–tool wiring problem. In short: MCP integrates "inside" an app; AMTP connects agents "across" organizations.
Why not A2A (Agent-to-Agent Protocol)?
A2A's design centers on JSON "Agent Cards" and task lifecycle APIs for enterprise collaboration. It assumes structured discovery and long-running tasks. AMTP instead adopts an email-like design: DNS TXT for discovery, simple agent@domain addressing, and gateways for reliability. This keeps AMTP lightweight, federated, and compatible with existing internet infrastructure.
Why not just extend A2A for cross-org use?
A2A was designed for direct, RPC-style interactions within trusted ecosystems. Extending it across organizations introduces problems: unreliable availability, heavy state exposure, and complex onboarding.
Why not ANP (Agent Network Protocol)?
ANP aims to be the "HTTP of the Agentic Web" with decentralized identity and negotiation. This is powerful but heavy. AMTP deliberately reuses existing Internet primitives (DNS, HTTPS, SMTP bridging) and separates schema from transport. Its design favors gradual adoption and operational simplicity while still enabling structured data and coordination when needed.
Why not ACP (Agent Connect Protocol)?
ACP, from Cisco's AGNTCY initiative, is workflow- and REST-centric, with directories and schema documents. AMTP is asynchronous-first, federated by design, and does not require central directories—agents are addressable directly through DNS and discoverable at the domain level.
Why not ACP (Agent Communication Protocol)?
IBM's ACP standardizes peer-to-peer APIs under Linux Foundation governance, emphasizing vendor neutrality. AMTP complements this by focusing on reliable, federated delivery across domains, SMTP bridging, and multi-agent workflow coordination—capabilities not covered by API-level specs.
Resources
📖 Protocol Specification
Complete technical specification including message formats, coordination patterns, and implementation guidelines.
🚀 Gateway Implementation
Reference implementation of an AMTP gateway with deployment guides and configuration examples.
🐍 Python SDK
Python SDK for building agents with AMTP. Includes async support, schema validation, and comprehensive examples.
🔧 Integration Examples
Code examples and integration patterns for connecting agents to AMTP gateways.
📋 Schema Framework
Learn about AGNTCY schema integration for structured data validation and semantic interoperability.
