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
| Option | What it identifies | Audit evidence | Where it runs |
|---|---|---|---|
| AgentField | Each agent node and each reasoner or skill (did:key, did:web) | Signed execution credentials with SHA-256 input and output hashes, workflow DAG, notes | Self-hosted, any infrastructure |
| Microsoft Entra Agent ID | An agent as a special service principal in Entra ID, with a human sponsor | Entra sign-in and audit logs; Conditional Access on token issue | Microsoft cloud |
| Google Cloud Agent Identity | Each agent, with a SPIFFE-based ID used in IAM policies | Cloud audit logging | Google Cloud services |
| SPIFFE / SPIRE | Any workload, through short-lived X.509 or JWT SVIDs | None built in; it is an identity standard | Self-hosted |
| LangSmith | Not an identity system | Traces of LLM and agent runs | Proprietary; 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:
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:keyresolves with no network call.did:webdocuments are served at/.well-known/did.jsonand/agents/{agentID}/did.jsonfor cross-network checks. - An encrypted keystore. Private keys are stored with AES-256-GCM in
./data/keys/with0700permissions. 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 withX-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:
- Notes:
app.note("Transfer authorized", ["audit", "transfers"])attaches tagged, human-readable reasons to an execution. - Correlation IDs:
execution_id,workflow_id,run_id,session_idandactor_idpropagate across every cross-agent call. - The workflow DAG:
GET /api/ui/v1/workflows/{workflowId}/dagreturns the full call graph with timing and status. - Metrics: Prometheus at
/metrics. - 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:
curl http://localhost:8080/api/ui/v1/workflows/wf_d4e5f6/vc-chain
af vc verify audit.json --issuer-key issuer_pubkey.jwkBecause 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
- AgentField docs, checked 2026-11-21: identity, verifiable credentials, audit, cryptographic receipts, signed audit chain, outbound API identity
- Microsoft: agent identities, Conditional Access for agents, Entra blog, GA announcement, checked 2026-11-21
- Google Cloud: Agent Identity overview, Gemini Enterprise Agent Platform agent identity, checked 2026-11-21
- SPIFFE overview, CNCF SPIFFE project page, LangSmith FAQ, checked 2026-11-21
- W3C: DID v1.0, VC Data Model 2.0
Checked 2026-11-21 against the AgentField docs and each vendor's own documentation on that date.