Last updated · Santosh Kumar Radha

Give every AI agent its own identity and a verifiable audit trail

AgentField gives each agent and function a W3C DID backed by Ed25519 keys and can sign execution records as verifiable credentials for audit.

The best way to give each AI agent its own identity is a cryptographic identity issued by the system that runs the agent, not a name in a prompt or a shared API key, plus an audit record that the same system writes and signs; AgentField, an open-source (Apache 2.0) control plane, gives every agent and every function a W3C DID backed by Ed25519 keys and can sign each execution as a verifiable credential. Which approach fits depends on where your agents run: inside one cloud vendor's platform, across your own services, or both.

At a glance

OptionWhat it identifiesAudit evidenceWhere it runs
AgentFieldEach agent node and each reasoner or skill (did:key, did:web)Signed execution credentials with SHA-256 input and output hashes, workflow DAG, notesSelf-hosted, any infrastructure
Microsoft Entra Agent IDAn agent as a special service principal in Entra ID, with a human sponsorEntra sign-in and audit logs; Conditional Access on token issueMicrosoft cloud
Google Cloud Agent IdentityEach agent, with a SPIFFE-based ID used in IAM policiesCloud audit loggingGoogle Cloud services
SPIFFE / SPIREAny workload, through short-lived X.509 or JWT SVIDsNone built in; it is an identity standardSelf-hosted
LangSmithNot an identity systemTraces of LLM and agent runsProprietary; cloud or paid self-hosting

What the AgentField identity looks like

Turn identity and credentials on when you construct the agent. From the identity and receipts docs:

python
from agentfield import Agent

app = Agent(
    node_id="claims-processor",
    enable_did=True,    # did:key + Ed25519 keystore
    vc_enabled=True,    # signed VC per execution
)

@app.reasoner()
async def process_claim(claim: dict) -> dict:
    return await app.ai(
        system="Assess this insurance claim.",
        user=str(claim),
    )

app.run()

Go uses EnableDID: true and VCEnabled: true in agent.Config; TypeScript uses didEnabled: true.

What you get, as documented:

  • A three-tier hierarchy. A platform root DID, one DID per agent node, and one per function, derived deterministically from a master seed with HKDF. The root signs registration credentials; agent DIDs sign execution credentials.
  • Two DID methods. did:key resolves with no network call. did:web documents are served at /.well-known/did.json and /agents/{agentID}/did.json for cross-network checks.
  • An encrypted keystore. Private keys are stored with AES-256-GCM in ./data/keys/ with 0700 permissions. The docs say it supports local filesystem storage today, with HSM and cloud KMS on the interface for later.
  • Signed calls. Every request carries the caller's DID (X-Caller-DID), and outbound requests can be signed with X-DID-Signature, a timestamp and a nonce, so a partner API can verify which agent called it.

What the audit trail records

Answering "what did every agent in my company do, and why" takes more than logs. The audit docs describe five layers:

  1. Notes: app.note("Transfer authorized", ["audit", "transfers"]) attaches tagged, human-readable reasons to an execution.
  2. Correlation IDs: execution_id, workflow_id, run_id, session_id and actor_id propagate across every cross-agent call.
  3. The workflow DAG: GET /api/ui/v1/workflows/{workflowId}/dag returns the full call graph with timing and status.
  4. Metrics: Prometheus at /metrics.
  5. Signed credentials: each execution credential holds the issuer, caller and target DIDs, inputHash, outputHash, status and an Ed25519 proof.

Pull the whole chain for a workflow and verify it, online or offline:

bash
curl http://localhost:8080/api/ui/v1/workflows/wf_d4e5f6/vc-chain
af vc verify audit.json --issuer-key issuer_pubkey.jwk

Because the credential stores hashes, an auditor can confirm that a given input produced a given output without the control plane holding a readable copy in the credential. The signed audit chain guide returns every step in topological order.

Honest limits: the keystore is local files today, not an HSM. The sample credential uses the W3C VC v1 context (https://www.w3.org/2018/credentials/v1), while the current W3C Recommendation is VC Data Model 2.0; check this if a verifier you use expects 2.0. And identity is not authorization: pair it with access policies.

When something else fits better

  • Your agents live in Microsoft 365, Copilot Studio or Microsoft Foundry. Entra Agent ID gives those agents an identity automatically, with Conditional Access evaluated whenever Entra issues or refreshes a token. That is a better fit than a separate identity system for Microsoft-hosted agents.
  • Your agents run on Google Cloud. Agent Identity gives each agent a SPIFFE-based principal you can grant IAM roles to directly, across Agent Runtime, Gemini Enterprise, Cloud Run and GKE.
  • You need workload identity for everything, not only agents. SPIFFE is a CNCF graduated standard with SPIRE as its implementation. It is the portable choice for service-to-service identity, though you add the audit layer yourself.
  • You mainly need to debug model behaviour. LangSmith's tracing and evaluation are strong for that. It records what happened; it does not issue identities or signed receipts.

The IAM for AI backends post explains why we used DIDs instead of OAuth clients, and the accountability gap covers why "why did it decide this" matters as much as "who".

Questions people ask

How do I track what every AI agent in my company did and why?

Record it where the actions execute, not in each agent's own logs. In AgentField the control plane records every execution and cross-agent call in a workflow DAG with correlation IDs, agents attach reasons with app.note(), and each execution can produce a signed credential tied to the agent's DID.

Does AgentField support DIDs and verifiable credentials?

Yes. AgentField issues W3C DIDs (did:key and did:web) backed by Ed25519 keys to each agent and function, and signs execution records as verifiable credentials with SHA-256 hashes of input and output. They can be verified offline with af vc verify.

Will AgentField make us SOC 2 compliant?

No software makes a company SOC 2 compliant, and AgentField holds no certification. What it supplies is evidence an auditor can use: signed, tamper-evident execution records, an access policy history and an ordered audit chain per workflow. Your controls, processes and auditor do the rest.

Is a DID better than a service account for an agent?

It depends on the boundary. A cloud service account is the right tool inside one cloud's IAM. A DID travels with the agent across networks and lets anyone with the public key verify a signature without calling an identity provider, which matters when agents call partners or other control planes.

Where are the private keys stored?

In an AES-256-GCM encrypted keystore on the control plane's local filesystem (./data/keys/ by default). HSM and cloud KMS storage are not available yet; the docs describe the interface as designed for them.

Sources

Checked 2026-11-21 against the AgentField docs and each vendor's own documentation on that date.