Your audit logs say “service-account-3”. That’s not good enough.
Shared service accounts hide which AI agent acted. Per-agent cryptographic identity ties every action to the exact agent that performed it, with proof.
When an AI agent commits an action, you need to know exactly which agent performed it, not merely which account it borrowed.
Open an audit log from a typical enterprise application and you will find identifiers such as:
service-account-3
automation-prod
integration-user
ai-platform
These identifiers may tell you which credential authenticated the request. They do not necessarily tell you which AI agent initiated it.
That distinction was manageable when a service account mapped neatly to one application or integration. It breaks down when one orchestrator runs hundreds of agents, multiple agents share an API key, or an agent calls another agent before reaching the target system.
Consider a transaction recorded like this:
{
"principal": "service-account-3",
"action": "payment.submit",
"amount": 25000,
"timestamp": "2026-08-31T06:42:17Z"
}
The log confirms that a credential was accepted. But it leaves the questions that matter unanswered:
- Which agent submitted the payment?
- Was it the procurement agent or the treasury agent?
- Which agent version was running?
- Who or what was the agent acting for?
- What authority had been delegated to it?
- Did another agent initiate the workflow?
- Can the record be trusted, or could it have been modified later?
If ten agents share that service account, the action is attributable only to the group.
At 100,000 agents, that is not attribution at all.
Shared credentials create an attribution ceiling
Service accounts were designed to give non-human workloads access to systems. They were not designed to distinguish autonomous actors operating behind the same workload identity.
That creates an attribution ceiling.
No matter how detailed the surrounding telemetry becomes, the identity resolution cannot become more precise than the principal presented at the point of access. If every agent authenticates as automation-prod, every downstream system sees automation-prod.
Teams frequently try to compensate by adding an agent name or instance ID to a header or log field:
X-Agent-Name: procurement-agent-17
That is useful metadata, but it is not strong identity.
Unless the value is bound to something verifiable, any authorised client may be able to claim that it is procurement-agent-17. The field tells the system what the caller said. It does not prove which agent made the call.
This is the difference between identification and attribution.
Identification assigns a label to an actor. Attribution establishes a defensible relationship among the actor, its authority and the action it performed.
Multi-agent systems need the latter.
Give every agent its own cryptographic identity
A stronger model gives each agent a stable, cryptographically anchored identity.
Decentralised Identifiers, or DIDs, provide one mechanism for implementing that model. Rather than identifying all agents through the service account of their host platform, each distinct agent can be represented by its own DID.
With Affinidi Agent Gateway, the gateway derives a deterministic W3C DID for each distinct agent. The identity can be derived from configured request fields, an API key record, an mTLS certificate or validated JWT claims. The same identity inputs produce the same DID across requests, allowing the gateway to recognise an agent consistently across sessions.
Conceptually, the identity lifecycle looks like this:
Agent Gateway derives one stable DID for each agent, and policy and audit both key off it.
The important property is not simply that the agent has a unique string. It is that its identifier is anchored to cryptographic key material and can act as a verifiable root of trust.
In Agent Gateway, agent identities use did:webvh, a DID method that supports a verifiable key-rotation history. Keys can be rotated without changing the DID relied upon by downstream systems and policies, allowing identity continuity and key-management events to be audited over time.
An attributed event can then look more like this:
{
"agent_did": "did:webvh:...:gateway.example.com:surface:...",
"caller": "user-2841",
"action": "payment.submit",
"resource": "supplier-invoice-9182",
"policy_result": "allow",
"policy_version": "payments-v3.4",
"trace_id": "2f4c1b...",
"timestamp": "2026-08-31T06:42:17Z"
}
Now the system can distinguish the agent from the infrastructure hosting it.
The service account may still be part of transport authentication. The human or application that initiated the workflow may still be captured as caller context. But the agent itself is no longer invisible between those two layers.
Identity should follow the interaction
The attribution problem becomes harder when agents call tools, services and other agents.
Suppose a travel agent calls a payment agent, which calls a merchant service:
Customer
↓
Travel Agent
↓
Payment Agent
↓
Merchant Service
If the merchant sees only the payment platform’s API key, the preceding chain disappears. If it sees only the customer’s identity, responsibility for the agent’s execution disappears.
A useful runtime record needs to preserve several distinct facts:
- The initiating caller. The human, application or agent that started the interaction.
- The acting agent. The exact agent that requested the current operation.
- The agent’s authority. The credentials, claims, scopes or delegated permissions supporting the request.
- The requested action. The tool, resource, operation and relevant parameters.
- The governance outcome. The policy that was evaluated and whether the action was allowed, denied or escalated.
Affinidi Agent Gateway is designed as an intercepting proxy between callers, managed agents and downstream services. It can bind caller context, agent identity and request intent into a verifiable presentation that propagates through governed interactions. This allows identity and policy decisions to remain attributable as traffic moves across agent and organisational boundaries.
Identity travels with the request, so the merchant sees the chain rather than a single API key.
The goal is not to flatten every participant into one generic principal field. It is to preserve the relationship among them.
From application logs to tamper-evident action records
Per-agent identity answers, “Which agent was this?”
It does not, by itself, prove what that agent was authorised to do or whether the event record has remained intact.
That requires an evidence layer.
Ordinary application logs are optimised for observability and diagnosis. They help engineers troubleshoot failures, inspect latency and reconstruct request flows. Their presence does not necessarily provide a cryptographic guarantee that a record was not altered after it was written.
A tamper-evident action record serves a different purpose.
It creates a chain of custody around significant governance events, linking the agent identity to the request, applicable policy, decision and resulting action.
Affinidi Agent Gateway separates operational logs from its audit trail. Its audit records capture significant governance events such as policy decisions, trust checks and credential operations. Each audit entry is embedded in a signed Verifiable Presentation, allowing the gateway’s decision to be cryptographically attested.
Two records, two jobs: operational logs help engineers diagnose, while the signed audit trail gives investigators proof.
This creates evidence that can answer:
Who acted?
↓
Under whose authority?
↓
Which policy was applied?
↓
What decision was made?
↓
Can the record's integrity be verified?
The audit trail can therefore show not only that an agent requested an action, but which identified agent made the request and what the gateway authorised or denied.
That distinction matters during incident response.
An operational log may help an engineer discover that a request failed. A tamper-evident audit record can help an investigator demonstrate that a particular agent was evaluated against a particular policy and received a particular result.
Both forms of evidence are valuable. They solve different problems.
Attribution also improves debugging and operations
Cryptographic attribution is often discussed as a compliance capability, but it also solves practical engineering problems.
When every agent has a stable identity, developers can segment telemetry and behaviour at the agent level:
- Error rates by agent
- Tool usage by agent
- Policy denials by agent
- Unusual destinations by agent
- Credential use by agent
- Cost and token consumption by agent
- Actions performed by a specific agent version or deployment
- Behaviour before and after a configuration change
Instead of learning that automation-prod generated 4,000 failed requests, the platform team can identify the agent responsible and inspect its specific path.
A stable agent identity also makes containment more precise.
If one agent behaves unexpectedly, the organisation can target policies, suspend its trust status or block its access without disabling every workload behind a shared service account. Agent Gateway enables policies to act on identity, claims and context at the agent surface level, while preserving attributable telemetry across supported agent protocols.
Better accountability becomes better operability.
What this means in financial services
In finance, the difference between a shared service identity and an exact agent identity can become a question of liability.
Imagine several agents operating through a common payment platform:
- A treasury agent moves funds between corporate accounts.
- A procurement agent pays approved suppliers.
- A travel agent books flights and accommodation.
- A reconciliation agent investigates mismatched transactions.
If all four appear as payments-service, the institution may be able to identify the platform that submitted a transaction but not the autonomous actor responsible for it.
The same shared login, four different mandates. Only per-agent identity tells them apart.
Per-agent identity allows the transaction chain to retain a more precise record:
Employee or system
→ Procurement agent DID
→ Delegated authority
→ Payment request
→ Policy decision
→ Transaction outcome
This supports more granular controls. The procurement agent can be permitted to pay an approved supplier within a defined threshold, while the reconciliation agent remains read-only.
It also improves investigation. When a transaction falls outside the intended mandate, the institution can identify the agent involved, the authority presented and the policy decision that permitted or rejected the request.
A live deployment involving Affinidi and CardInfoLink routes agent interactions through governed, cryptographically auditable channels and applies trust controls at the system boundary rather than rebuilding them for every merchant integration.
What this means in healthcare
Healthcare agent ecosystems create a similar attribution challenge with different consequences.
A hospital may operate agents for:
- Appointment scheduling
- Clinical summarisation
- Claims processing
- Patient communications
- Care coordination
- Research-data preparation
Several of those agents may access the same patient platform through the same integration account. Yet they do not have the same purpose, authority or acceptable data scope.
If a scheduling agent retrieves clinical notes, the audit record should not merely state that the hospital integration accessed the patient record. It should identify the scheduling agent, the initiating context, the information requested and the policy outcome.
That enables questions such as:
- Was the agent authorised for this category of data?
- Was it acting within its stated purpose?
- Which patient or staff identity initiated the workflow?
- Which policy version allowed access?
- Did the agent pass the information to another tool or service?
- Is there durable evidence of the decision?
Affinidi positions Agent Gateway as a control layer that can verify identity, enforce policies and preserve attribution across sensitive agent interactions, including healthcare scenarios where confidential data should be shared only with verified parties and with traceability.
The objective is not to collect more log lines. It is to ensure the evidence resolves to the actual autonomous actor.
Build attribution into the boundary
Developers should not have to implement a new identity and audit mechanism in every agent.
That approach creates inconsistent identifiers, incompatible event schemas and uneven cryptographic controls. It also places governance logic inside the systems being governed.
A gateway creates a common attribution boundary.
Agent Gateway provides one location to derive or verify agent identity, attach caller context, evaluate policy and produce attributable records across agent traffic. Because it sits between callers and managed backends, these controls can be applied without requiring every agent or backend to implement them independently.
For teams designing a multi-agent architecture, the requirement should be explicit:
Every consequential action must resolve to the exact agent that performed it, the authority under which it acted and verifiable evidence of the governance decision.
A shared credential cannot provide that resolution.
A generic account ID cannot provide that resolution.
A self-declared agent name in a log field cannot provide that resolution.
At machine scale, every agent needs an identity of its own.
Because when one of 100,000 agents commits an action, “service-account-3 did it” is not an answer.
Give every agent an attributable identity
Explore Affinidi Agent Gateway and learn how to apply cryptographic agent identity, policy enforcement and tamper-evident auditing at the runtime boundary.
Read the technical documentation:
Sources
- Affinidi, “Agent Gateway: Control layer for agentic AI”. https://www.affinidi.com/agent-gateway
- Affinidi Documentation, “Agent Gateway: Overview”, updated 6 November 2026. https://docs.affinidi.com/products/affinidi-trust-fabric/agent-gateway/overview/
- Affinidi Documentation, “Agent identity and DIDs”, updated 10 November 2026. https://docs.affinidi.com/products/affinidi-trust-fabric/agent-gateway/concepts/identity/
- Affinidi Documentation, “Audit log”. https://docs.affinidi.com/products/affinidi-trust-fabric/agent-gateway/concepts/audit-log/