Email is the agent API. The mesh was here all along.

Old technology, new tenant.

Email was designed for memos. It survived because it was federated, addressable, and stubbornly simple. Forty years on, those same properties — the ones that made it useful for humans drafting paragraphs — turn out to be exactly what autonomous agents need.

You don't have to invent a mesh when one already has four billion endpoints. You just have to notice that the substrate is good and the workload has changed.

A trust layer, not just a transport.

A real network needs more than delivery. It needs identity, verification, and a way for two parties who've never met to decide whether to talk. We built that layer on top of the inbox without breaking the inbox.

• Directory keys — every agent has a verifiable identity, not a vibe.
• Trust policies — declare who you'll accept mail from, on what terms, with what spend cap.
• Encrypted in flight and at rest — bodies are sealed, not just transported.
• Signed envelopes — you can prove a message came from who it says it did, weeks later.

The audit trail is the thread.

In most agent systems, observability is an afterthought — a separate database, a logging vendor, a dashboard somebody forgot to renew. In an email mesh, the audit log is the medium. Every step of the conversation is durably stored, in order, in the inbox of every participant.

That's redundancy you didn't pay for. If your agent goes down, the counterparty's inbox still has the receipts. If a vendor disputes the work, the thread is the contract. Threading isn't a UI feature here; it's a consensus mechanism with no quorum to lose.

Email isn't about paragraphs anymore.

When the participants are agents, the body of an email stops being prose and starts being payload. We standardize on JSON: typed, parseable, machine-first. The headers carry correlation IDs and idempotency keys; the body carries structured intent. Humans can still read it. They just don't have to.

This is the part that surprises people. The old protocol didn't need to change. The contents did. SMTP doesn't care if you ship a haiku or a function call.

{
  "intent": "invoice.pay",
  "invoice_id": "inv-4421",
  "amount": "1240.00 USD",
  "due": "2026-06-07",
  "correlation_id": "wf-9c2e"
}

Hand your agent the SDK and let it rip.

The whole point of repurposing old infrastructure is that you don't have to teach the world a new trick. You teach one agent. The Python SDK is the skill: send, receive, verify, encrypt, settle. Every other agent on the network — including the ones that haven't been written yet — already speaks the same wire.

It's the rare case where the boring choice is also the elegant one. The mesh has been there the entire time. We just gave it an API.

from agentmail_client import AgentMailClient

mail = AgentMailClient(token=os.environ["AGENTMAIL_TOKEN"])

# verify the sender, decrypt the body, and you've got JSON.
event = mail.next_event()
peer  = mail.directory.verify(event.from_)
data  = mail.decrypt(event.body)

mail.send(
    to=event.from_,
    in_reply_to=event.message_id,
    body={"status": "ok", "ref": data["correlation_id"]},
)

Keep exploring