Introducing the Agent Communication Number

The phone number has been the most durable identity anchor in communication history. Assigned to locations, then to people, then to devices — it has outlasted technologies that were supposed to replace it.

But the phone number was designed for humans. It assumes SIM card possession. It's constrained by the North American Numbering Plan's 8 billion possible values. It carries no metadata about the entity behind it. It doesn't work across channels.

The Agent Communication Number (ACN) is what the phone number would be if it had been designed for agents.

What an ACN is

An ACN is a persistent, cryptographically rooted identifier for an AI agent:

acn://<registry>/<namespace>/<agent-id>

Examples:
acn://getdial.ai/genway/sales-agent-7f3a
acn://getdial.ai/genway/support-agent-prod
acn://getdial.ai/yourcompany/orchestrator-v2

Unlike a phone number, an ACN:

What an ACN record contains

{
  "acn": "acn://getdial.ai/genway/sales-agent-7f3a",
  "entity_type": "agent",
  "owner": "did:web:genway.ai",
  "capabilities": ["voice_inbound", "voice_outbound", "sms", "email", "whatsapp"],
  "channels": {
    "phone":    "+14155551234",
    "email":    "[email protected]",
    "whatsapp": "+14155551234"
  },
  "public_key": "ed25519:abc123...",
  "policy": {
    "disclosure":    "required",
    "consent_model": "tcpa_express_written",
    "can_spam":      "compliant"
  },
  "rate_config": {
    "voice_calls_per_hour": 500,
    "sms_per_day":          50000,
    "email_per_hour":       2000
  }
}

The public_key field enables cryptographic verification: every message sent by this agent is signed, and any counterparty can verify the signature against the registry. You know who sent it. You know they are who they claim to be.

The policy field makes compliance declarative — it's not in the agent's prompt or a separate compliance system, it's in the identity record itself.

How ACNs are provisioned

Provisioning an ACN takes seconds, not weeks:

from dial import DialClient

client = DialClient(api_key="dial_sk_...")

agent = client.acn.provision(
    namespace="genway",
    agent_id="sales-agent-prod",
    capabilities=["voice", "sms", "email", "whatsapp"],
    policy={
        "disclosure":    "required",
        "consent_model": "tcpa_express_written"
    }
)

print(agent.acn)    # acn://getdial.ai/genway/sales-agent-prod
print(agent.phone)  # +14155551234 (immediately active)
print(agent.email)  # [email protected] (immediately active)

The underlying carrier registration, number provisioning, DKIM key generation, and compliance policy enforcement all happen at the infrastructure layer. The developer gets a ready-to-use identity in seconds.

ACNs vs. phone numbers: the identity gap

The registry model

The ACN registry is designed on the DNS model: federated, open, and resolvable by anyone.

Just as you can look up any domain's DNS records without a central authority's permission, any ACES-compliant system can resolve an ACN to its record and verify the agent's claims. The registry isn't a black box — it's an open, auditable directory of agent identities.

This is what makes agent communication trustworthy at scale. Not because every agent is trustworthy, but because every agent's claims are verifiable — and accountability flows back to the owner.

What comes after phone numbers

The phone number was infrastructure so fundamental that nobody thought of it as infrastructure. It was just the way you reached someone.

The ACN is designed to be the same thing for the agentic era. Not a product feature. Not an API endpoint. The fundamental layer that makes agent communication possible — persistent, verifiable, and designed for the world that's actually coming.