AUID: The Agent Unique Identifier That Makes AI Trust Portable

The AUID — Agent Unique Identifier — is the cryptographically anchored identity layer that makes AI agent trust portable across platforms, deployments, and operators. Here is how it works.

By Leonidas Esquire Williamson — March 22, 2026

Every Trustworthy System Starts With a Stable Identity

The internet needed IP addresses before it could route packets. Financial systems needed account numbers before they could track balances. The agentic economy needs stable, unique identifiers for AI agents before it can build any of the trust infrastructure that makes agents safe to deploy at scale.

This is what the AUID — Agent Unique Identifier — provides. It is the foundational identity primitive of the AxisTrust ecosystem: a stable, cryptographically anchored identifier that every registered agent receives and that persists across the agent's operational lifetime.

Without a stable identifier, every other component of agent trust becomes unreliable. Reputation scores cannot be attributed to a specific agent with confidence. Behavioral history cannot be tracked across deployments. Access control cannot be enforced based on agent identity. The AUID is not one feature of the trust stack — it is the prerequisite for all the others.

What Makes an AUID Different From a Simple ID

A naive approach to agent identity would be to assign each agent a UUID at registration and call it done. The AUID goes significantly further than this in three important ways:

Cryptographic Anchoring

Each AUID is tied to a cryptographic key pair. The agent's legitimate operator holds the private key; the public key is registered in the [AXIS agent directory](https://axistrust.io/directory). When an agent presents its AUID in an interaction, it can prove possession of the corresponding private key — demonstrating that it is the legitimate holder of that identity, not an impersonator.

This cryptographic anchoring is what makes the AUID verifiable rather than merely assertable. Any system that wants to verify an agent's identity can challenge the agent to sign a nonce with its private key and verify the signature against the registered public key. This is a standard cryptographic authentication pattern, and it is robust against impersonation attacks.

Persistence Across Deployments

One of the most important properties of the AUID is that it persists across redeployments. When an agent is updated, migrated to a new infrastructure, or operated by a new principal, its AUID does not change — but the change events are recorded in the agent's history.

This persistence is what makes reputation portable. An agent that has spent two years building a strong behavioral track record does not lose that track record when it is redeployed. Its AUID travels with it, carrying its full history.

Immutable History

The AUID is associated with an immutable event log: every significant event in the agent's lifecycle — registration, operator changes, model updates, verification milestones, behavioral flags — is recorded against the AUID in a way that cannot be altered retroactively. This creates an auditable history that principals can inspect when evaluating an agent's trustworthiness.

The AUID Format

AxisTrust AUIDs follow a structured format designed to be both human-readable and machine-parseable:

```

axis:{namespace}.{registry}:{tier}{hash}:{version}:{checksum}

```

An example AUID looks like:

```

axis:axis.registry:enterprise:01hx7k2m3n4p5q6r7s8t9u0v1w:a3f7

```

The components encode:

This structured format allows systems to extract basic information about an agent (its tier, its registry) directly from the AUID, without requiring a registry lookup for every interaction.

How the AUID Integrates Into Agent Workflows

The AUID is designed to be embedded in agent interactions at multiple levels:

In API calls: Agents include their AUID in the headers or payload of API calls, allowing receiving systems to verify the agent's identity and check its trust scores before processing the request.

In agent-to-agent communication: When agents communicate with each other, they exchange AUIDs as part of the trust handshake, allowing each agent to verify the other's identity and retrieve its reputation scores.

In audit logs: Every action an agent takes is logged against its AUID, creating a complete, attributable audit trail that can be inspected by principals, regulators, or dispute resolution systems.

In access control: Systems that want to restrict access to verified or high-reputation agents can use the AUID as the key for trust-based access control — querying the [AxisTrust T-Score API](https://axistrust.io/t-score) with the AUID to retrieve the agent's current trust tier before granting access.

Why the AUID Needs to Be an Open Standard

The AUID format and the registry that backs it are designed to be open standards. Any platform can implement AUID support. Any agent can register for an AUID. Any system can query the AUID registry.

This openness is essential for the same reason that open identity standards like OAuth and OpenID Connect are essential for human identity on the web: closed, proprietary identity systems create lock-in, fragment the ecosystem, and prevent the kind of interoperability that makes the whole system more valuable.

If you are building AI agents that will operate in the agentic economy, registering them for AUIDs is the first step. [Register your agent in the AXIS directory](https://axistrust.io/directory) — free forever — and give it the stable identity it needs to build a trustworthy track record.