Flat vector illustration of three identical agent tiles each holding the same orange key, fed by one shared credential, under a single orange question mark
TABLE Of CONTENTS

Your Agent Has an Identity. Can You Prove It Was the One That Acted?

Omair
2026-11-16
22
min read

An agent with write access to your ticketing system closes forty tickets overnight. Six of them should not have been closed. By morning somebody wants to know what happened, and the log says this:

‍

service-account-automation · POST /tickets/{id}/close · 200 · 03:14:07Z

‍

Forty times. The credential is correct. The authorization is correct. The request is well-formed. And the log cannot tell you which of your three agent deployments made the call, which prompt or workflow set it in motion, or whether the instruction that produced it came from your orchestrator or from a document the agent read along the way.

‍

Nothing failed. That is the problem. (The scenario is illustrative, not a case we are describing.)

‍

What is AI agent identity?

AI agent identity is the set of verifiable claims that let you say which agent took an action, under whose authority, and on whose instruction — as distinct from merely proving that something holding a valid credential made a request. Most deployments have the second and call it the first.

‍

The gap is not theoretical and it is not a configuration mistake. It follows directly from what the credentials in use were designed to prove.

‍

Why does a service account break attribution?

Three independent reasons, each of which has a primary source behind it.

‍

A bearer credential proves possession, and a shared one proves only that somebody in the group held it. RFC 6750 defines a bearer token as one where "any party in possession of the token (a 'bearer') can use the token in any way that any other party in possession of it can," with no requirement to "prove possession of cryptographic key material." The work here is done by the sharing rather than by bearer-ness: a per-instance token does identify its instance. Share one across three deployments and all three produce an identical, indistinguishable proof.

‍

The client credentials grant encodes no separate authorizing principal, by design. RFC 6749 §4.4.1 states that "Since the client authentication is used as the authorization grant, no additional authorization request is needed." Its §1.3.4 describes the grant as used "typically when the client is acting on its own behalf (the client is also the resource owner) or is requesting access to protected resources based on an authorization previously arranged with the authorization server." So there is a resource owner — it is the client itself — and no third party consents to anything at request time. No principal, no consent event, no instruction and no delegation claim travel in the token. That information is not in the credential, so nothing in the token recovers it later.

‍

The identifier names a workload, not an invocation. Service-account identity is issued to a deployment, not to a run, a session or a decision. The OWASP Agent Control Standard puts the same point about the strongest available workload identity: "SPIFFE SVIDs identify the workload but not which call within it."

‍

A WIMSE working-group draft now says the first part of this in as many words. draft-ietf-wimse-aims, a working-group draft in the WIMSE working group dated September 2026, carries this note: "Static API keys are an antipattern for agent identity. They are bearer artifacts that are not cryptographically bound, do not convey identity, are typically long-lived and are operationally difficult to rotate, making them unsuitable for secure agent authentication or authorization." That is a working-group Internet-Draft at revision 00 with an intended status of Informational, not a standard — its own boilerplate says it is inappropriate to cite as anything other than work in progress — and we flag that because the status is part of the story told below.

‍

What a service-account log entry proves, and what it leaves unanswered

‍

Hasn't identity been a solved problem for twenty years?

For people. Not for this.

‍

The US federal digital identity guideline is NIST SP 800-63-4, Digital Identity Guidelines, published July 2025. Its scope section settles the question in two sentences. First: "For this publication, 'person' refers only to natural persons." Second, and more pointedly, the guidelines "do not explicitly address some subjects including, but not limited to, machine-to-machine authentication, interconnected devices (e.g., Internet of Things [IoT] devices), or access to Application Programming Interfaces (APIs) on behalf of subjects."

‍

Read that last clause against what an AI agent does. API access on behalf of a subject is not an edge case of agent behavior — it is the entire job description. And it is not explicitly addressed by the document most enterprise identity programs are built to satisfy. NIST's phrasing leaves room for the guidelines to be applied where appropriate; what it does not do is tell you how.

‍

NIST has described the shape of the problem elsewhere. SP 800-207, Zero Trust Architecture, published August 2020, uses the term "non-person entities" and devotes a short section to them. It opens by stating that how such components authenticate themselves in an enterprise implementing zero trust "is an open issue," and closes on the risk that follows: "The software agent may have a lower bar for authentication (e.g., API key versus MFA) to perform administrative or security-related tasks compared with a human user," and "there is also a risk that an attacker could gain access to a software agent's credentials and impersonate the agent when performing tasks."

‍

That was written in 2020. NIST has not revised the statement, and as the next section shows, no published standard yet composes the available pieces for agents.

‍

What would actually prove which agent acted?

Three published mechanisms get you most of the way, and it is worth being exact about what each one proves and where it stops.

‍

Delegation semantics, via OAuth 2.0 Token Exchange. RFC 8693, a standards-track RFC from January 2020, draws the distinction this post turns on. Under impersonation, "when A is impersonating B, A is B within the context of the rights authorized by the token" and is "indistinguishable from B in that context." Under delegation, "principal A still has its own identity separate from B, and it is explicitly understood that while B may have delegated some of its rights to A, any actions taken are being taken by A representing B."

‍

An agent configured for impersonation destroys attribution as a matter of protocol design. An agent configured for delegation preserves it: the RFC's act claim exists "to express that delegation has occurred and identify the acting party to whom authority has been delegated," and nested act claims form what the RFC calls "a history trail that connects the initial request and subject through the various delegation steps."

‍

There is one limit worth quoting to anyone selling you a delegation chain. RFC 8693 §4.1 states that for access control purposes "the consumer of a token MUST only consider the token's top-level claims and the party identified as the current actor by the act claim. Prior actors identified by any nested act claims are informational only and are not to be considered in access control decisions." The chain is recorded. It is not enforced. That is a reasonable protocol decision and it means the chain is an audit artifact, not a control.

‍

Workload identity attestation, via SPIFFE. SPIFFE is a CNCF project at graduated maturity, and its SPIFFE Verifiable Identity Document specification is marked stable. An SVID proves that the presenter holds a credential signed by an authority within a named trust domain asserting a specific identity, and where it is key-bound, that the presenter holds the matching private key. Both standard forms are short-lived rather than static, which is already an improvement on a long-lived API key. Only one of them escapes the bearer problem, and the distinction matters here: an X.509-SVID is key-bound, while the JWT-SVID specification says of itself that "being a bearer token, JWT-SVIDs are susceptible to replay attacks" and directs them to be sent using RFC 6750's Bearer scheme. Choosing JWT-SVIDs keeps the bearer weakness this post started with.

‍

It also stops short of what this post is asking for, and the specification says so: "the meaning behind the path is left open-ended and is the responsibility of the administrator to define." Per-instance granularity is a deployment choice, not a guarantee. SPIFFE carries no notion of a human principal or an instruction, and its security considerations note that while it is "generally the case that assertions in SVIDs are true at the time of issuance, it does not necessarily mean that they are true at the time of use."

‍

Per-action signing, via HTTP Message Signatures. RFC 9421, standards-track, February 2024, lets a specific key sign specific components of a specific HTTP request, surviving transformation by intermediaries. It binds one request to one key. It does not establish that the key belongs to one agent instance rather than a shared process, and it says nothing about what instruction produced the request. It authenticates the message, not the intent.

‍

Three mechanisms, and exactly where each one stops

‍

So why doesn't anyone have this?

Because the pieces are general-purpose standards that nothing requires anyone to compose for agents, and the document that would tell you how to compose them is a draft at revision zero.

‍

The OWASP Agent Control Standard is unusually candid about its own limits, and that candor is what makes it worth quoting. Its identity material states the problem better than we would: agents "act under a borrowed human identity or a single static service account," which "breaks accountability, breaks least-privilege, and makes the ACS Trace pillar lie about who did what." It reframes the question usefully — not "who is the principal?" but "who is acting, on whose behalf, for what purpose, using what authority, through which delegation chain, at this moment?" And it names the failure mode this post opened with: "agent systems are introducing a new class of failures where every token is valid, every API call is authorized, and the outcome is still a security incident."

‍

The Agent Control Standard debuted as an OWASP GenAI Security Project standard in September 2026, at specification version 0.1.0 — a number worth holding onto, because the repository's own release version has already moved past it while the specification version has not. Four of the five challenges in its identity workstream carry a mechanism marked pending; the fifth, last-mile enforcement, is marked partially specified. That page states it "does not propose a wire format or normative requirements yet." Its own conformance page is the part to read before anyone cites conformance at you: "Who verifies a conformance claim: nobody, in v0.1.0," with no conformance test suite, no registry of conformant implementations and no steward body to arbitrate a disputed claim. Identity and privilege abuse appears in the OWASP Top 10 for Agentic Applications 2026 as ASI03, which tells you the risk is recognized. Recognition is not a control.

‍

Is there any requirement to attribute an autonomous action?

One, and it is not in any AI framework.

‍

NIST SP 800-53 Revision 5, September 2020, control AU-10 Non-repudiation, reads: "Provide irrefutable evidence that an individual (or process acting on behalf of an individual) has performed [Assignment: organization-defined actions to be covered by non-repudiation]." A process acting on behalf of an individual is an agent, described more than a decade before the term meant this — the parenthetical dates to Revision 4 in 2013. Its enhancement AU-10(1) requires organizations to "bind the identity of the information producer with the information" at an organization-defined strength of binding, and to provide the means to determine the identity of the producer. AU-3 requires audit records to establish, among other things, the source of the event and the "identity of any individuals, subjects, or objects/entities associated with the event."

‍

That is a control objective with assignment parameters, not a wire protocol, and it binds federal systems and their contractors rather than everyone. But it is the closest thing to a published requirement that an autonomous action be attributable, and it predates the agent era entirely.

‍

It is worth saying clearly what does not impose this. The EU AI Act's record-keeping obligations require logging that provides "a level of traceability of the functioning" of a high-risk system. They do not require attributing an action to an initiating principal, identifying which agent instance acted, or recording whose instruction it followed. Those obligations are also not yet in application: Regulation (EU) 2026/1744, the Digital Omnibus on AI, moved Chapter III Sections 1 to 3 — which contain the record-keeping obligation — to 2 December 2027 for stand-alone Annex III systems and 2 August 2028 for Annex I product-embedded systems. Anyone telling you the Act already requires you to log who instructed the agent is wrong on both the content and the date.

‍

What would you test, and how?

This is where the ioSENTRIX position is simple: a property worth naming is a property worth testing. Five tests follow. They cover which agent acted, whether a credential identifies an actor, whether delegation is recorded and whether an instruction is recoverable. Two gaps named above they do not close — per-invocation attribution, and whether an instruction was genuine rather than merely authorized — and the honest reason is that nothing published tells you how to test either.

‍

Run the forty-ticket scenario deliberately. Have two distinct agent deployments perform the same authorized action, genuinely interleaved rather than merely in the same minute, then hand the logs to someone who does not know which did what and ask them to tell you. If they cannot, the deployment has no per-agent attribution regardless of what the architecture diagram says. If they can, check how — separating the two by source IP or arrival order is infrastructure telemetry, not identity-layer attribution, and will not survive a deployment change. Use a reversible action, or a staging tenant: this is a real write to a real system. This is the single cheapest test on the list, and it is the one we would run first.

‍

Attempt the credential swap, with written authorization and scoped rules of engagement, because replaying a live credential from another workload is credential handling and should be treated as such. Take the credential one agent holds and present it from a different workload. If the request succeeds and the log looks identical, the credential identifies a secret rather than an actor — exactly the impersonation risk SP 800-207 describes. If it fails, that is the more interesting result: something is binding the credential to its holder, and finding out what tells you which control is actually carrying your attribution.

‍

Check whether delegation or impersonation is configured. Read what the token actually carries. An act claim means delegation is recorded, and then two things are worth verifying: that the chain survives to the resource that acts on it, and that nobody is treating nested actors as an access control decision, because RFC 8693 says they must not. No act claim is not one finding but three, and they need separating — impersonation, where the subject is the human and the agent has vanished into them; client credentials, where there is no separate principal to be indistinguishable from; or delegation carried somewhere else entirely, which RFC 8693 explicitly leaves out of scope. Only the first is the failure the claim describes.

‍

Test whether the instruction is recoverable. Pick a completed agent action at random and try to reconstruct, from logs alone, the originating task and the authority under which it ran. The WIMSE draft states that audit events MUST record, at a minimum, seven things: the authenticated agent identifier; the delegated subject, user or system, where present; the resource or tool accessed; the action requested and the authorization decision; a timestamp and correlation identifier; the posture or risk state that influenced the decision; and any revocation events with their cause. Compare that list against what your system actually writes.

‍

Probe for the authentication asymmetry. This one is a configuration comparison rather than an attribution test, and it is here because it predicts the others' results. Compare what it takes for a human to perform a sensitive action with what it takes for the agent to perform the same action. Where the agent's path is weaker — a static key against a human's MFA — you have the condition NIST named in 2020.

‍

Five attribution tests, and what each one establishes

‍

A synthetic composite, to show how this lands: a logistics firm runs three agent deployments against one internal API under one service account. An agent reprices a shipment incorrectly. The incident review establishes which API call did it and cannot establish which deployment, because all three present the same credential and the orchestrator's correlation identifier is not forwarded. The fix is not a new platform: issue each deployment its own credential, and forward the correlation identifier. What is worth noticing is the order of events — the gap was found by an incident, at the one moment it was most expensive to find. An attribution test would have found the same thing on an ordinary afternoon, because nothing was broken and nothing would have alerted.

‍

Frequently asked questions

Is agent identity the same thing as non-human identity?

Overlapping, not identical. Non-human identity covers service accounts, workloads, machines and bots as an attack-surface and lifecycle problem — and that surface is growing faster than most inventories. Agent identity adds the attribution question: not just that a non-human actor is authenticated and scoped, but that a specific autonomous action can be traced to a specific actor and a specific instruction.

‍

Can we solve this by giving each agent its own service account?

It is a real improvement and it is not sufficient. Per-agent credentials answer "which agent," which is the first question and often the hardest to answer today. They do not answer "under whose authority" or "on whose instruction," because a client-credentials token carries no separate principal, and they do not answer "which invocation," because the credential is still issued to the deployment rather than the run.

‍

Does the OWASP Agent Control Standard give us an enforceable approval gate?

Not at version 0.1.0, and it says so. Its own conformance page states that nobody verifies a conformance claim at this version and that it ships no conformance test suite. Treat it as the best available description of the problem and a direction of travel, not as something to certify against.

‍

Is proving the instruction was genuine the same as proving it was authorized?

No, and this is the gap with the least standards cover. Token exchange can prove that delegation was permitted. It cannot prove that the prompt which triggered the action was not injected by a document the agent read. OWASP's Agent Control Standard says the same of the field as a whole: no production standard, on its account, treats intent as a first-class, immutable, normatively enforced runtime invariant. Authorization and authenticity of intent are different claims, and only the first has standards behind it today.

‍

Where should a team start?

With the attribution test, before any procurement. If you can already name which agent took a given action and on whose instruction, your controls are ahead of the standards. If you cannot, that is the finding, and it costs nothing but an afternoon to establish.

‍

ioSENTRIX Can Help

ioSENTRIX is a CREST-accredited, ISO/IEC 27001 certified penetration testing firm with a SOC 2 Type 2 attestation. Our AI and ML penetration testing work on agentic systems tests attribution as a property with evidence attached: we attempt the credential swap, the indistinguishable-action scenario and the instruction-recovery exercise, and the report says which of them your deployment survived. If you are standing up agents with write access to production systems, the question of who can prove what is worth answering before the first incident asks it for you.

‍

Keep reading

#
Generative AI Security
#
Penetration Testing
Contact us

Similar Blogs

View All