At 3:00 PM on a Tuesday, an enterprise security operations center offboards an engineer named Alice.
Her corporate Okta identity is deactivated. Her active session tokens are invalidated. Her corporate laptop is remotely locked. By every standard compliance metric—SOC 2 Type II, ISO 27001, and corporate IAM policy—Alice's access to the enterprise is severed.
At 3:25 PM, an automated pull request lands in the company's core payment repository. It alters a database migration script, signs the commit with a GitHub API token, and pulls deployment credentials from an internal vault.
The SOC is paged for an unauthorized post-termination breach. Forensic investigators pull the audit log:
{
"timestamp": "2026-11-08T15:25:12Z",
"actor": "subagent-payment-worker-4",
"on_behalf_of": "alice@corp.internal",
"token_jti": "urn:uuid:7c8b91a2-4412",
"token_status": "VALID",
"action": "repo:write"
}
Alice did not execute the breach from her parking lot. Twenty-five minutes before she was notified of her departure, Alice had instructed an autonomous developer agent to optimize the database queries in the payment service. The orchestrator agent had exchanged Alice's token for three downstream worker subagent tokens.
Alice was gone. Her subagents were still working.
Removing a human user from your identity provider does not revoke the non-human identities executing in their wake. If your delegation architecture cannot transitively tear down a subagent DAG, your offboarding process is an illusion.
1. The Asynchronous Non-Human Identity Trap
We spent the early 2000s suffering through Kerberos ticket-granting services, LDAP replication lag, and stateful session pinning across hardware load balancers. When OAuth 2.0 and JSON Web Tokens (RFC 7519) arrived, identity architects breathed a collective sigh of relief: push validation to the network edge, verify the RS256 signature against an in-memory JWKS cache, and celebrate zero database lookups on the hot path.
It was a brilliant architectural trade-off—right up until software stopped waiting for humans to click buttons.
Stateless verification assumes that possession of a valid signature equals contemporary intent:
Resource Server: VerifySignature(JWT, JWKS) && (JWT.exp > Now()) ──> ACCEPT
In a world of short-lived browser sessions, stateless verification worked reasonably well. If Alice closed her laptop, her access token quietly expired forty-five minutes later without causing a catastrophe.
In multi-agent topologies, however, execution is asynchronous, hierarchical, and delegated. An orchestrator agent does not run sequential queries; it spawns a Directed Acyclic Graph (DAG) of specialized subagents across multiple systems of record:
┌──> Subagent A (GitHub Pull Request)
Alice ──> Agent ───┼──> Subagent B (AWS Secrets Manager)
└──> Subagent C (Jira Ticket Transition)
To maintain least privilege, the orchestrator uses RFC 8693 Token Exchange to mint distinct, downscoped access tokens for each worker.
Here is the mechanical failure: each exchanged token is a completely sovereign cryptographic artifact.
When Alice's primary corporate session is terminated:
- Okta or Entra records a revocation event for Alice's primary subject identifier.
- Subagent B calls AWS Secrets Manager with its exchanged token.
- AWS validates Subagent B's token signature against the public JWKS.
- The signature is mathematically valid. The expiration time is thirty-five minutes in the future.
- AWS returns production secrets to an autonomous process running on behalf of a human who no longer works for the company.
2. The Empirical Measurements: The Delusion of Immediate Revocation
Security teams routinely assume that modern token revocation standards—such as Continuous Access Evaluation (CAE / RFC 9493) or OpenID Shared Signals and Events (SSE)—solve this problem out of the box.
The empirical reality paints a radically different picture.
The Cloud API Delay Benchmark
In independent security testing, researcher Aikido measured the actual revocation latency of deleted Google Cloud API keys across repeated trials. The result: deleted keys remained fully authorized across backend services for 8 to 23 minutes (with a median latency of 16 minutes). The cloud vendor closed the vulnerability as expected distributed eventual consistency.
The Enterprise CAE Coverage Reality
ERNW analyzed Microsoft Entra ID Continuous Access Evaluation across enterprise environments. Out of 740 first-party Microsoft resources examined, only 33 resources (4.4%) actually enforced a CAE critical event check. In the remaining 95.6% of services, revocation signals were completely ignored until the standard 60-minute token lease elapsed.
The Open-Source IdP Blindspot
When we probed standard open-source identity providers (Keycloak, Authentik, Zitadel) with RFC 8693 token exchange fixtures, we observed the same invariant failure: revoking the parent subject_token via the /oauth/revoke endpoint (RFC 7009) invalidates the parent token record, but child tokens carry no foreign-key dependency to the parent session and continue to pass validation until expiration.
In 1971, Butler Lampson published Protection, formalizing the access matrix and establishing that delegated authority forms a directed graph. If subject S delegates authority to agent A, the authorization graph is a directed edge S → A. Severing S must prune the entire subtree. Yet in today's cloud architectures, child nodes run completely decoupled from their roots.
3. The Structural Fix: Transitive Revocation Cascades
To solve the Non-Human Identity trap, an agent delegation system must enforce Transitive Cryptographic Containment. At Invarcore, we codified this into three mandatory invariants across agent execution runtimes.
┌─────────────────────────────────────────────────────────────────┐
│ Alice (Root Subject) │
│ JTI: 0xROOT │ Exp: T_0 + 3600 │
└────────────────┬────────────────────────────────────────────────┘
│ RFC 8693 Exchange
▼
┌─────────────────────────────────────────────────────────────────┐
│ Orchestrator Agent (Actor) │
│ JTI: 0xORCH │ Parent_JTI: 0xROOT │ Exp: min(Parent, Lease) │
└────────────────┬────────────────────────────────────────────────┘
│ RFC 8693 Exchange
▼
┌─────────────────────────────────────────────────────────────────┐
│ Worker Subagent (Downstream) │
│ JTI: 0xWORK │ Parent_JTI: 0xORCH │ Root_JTI: 0xROOT │
└─────────────────────────────────────────────────────────────────┘
Invariant 1: Chained Parent Identity Claims. Every token minted via RFC 8693 token exchange must cryptographically bind its upstream ancestry into the token payload:
{
"jti": "urn:uuid:7c8b91a2-4412",
"sub": "alice@corp.internal",
"iss": "https://auth.corp.internal",
"aud": "https://api.github.com",
"exp": 1731079800,
"act": {
"sub": "agent-worker-4",
"client_id": "agent-worker-4"
},
"invar_dag": {
"parent_jti": "urn:uuid:3b21ef89-1104",
"root_jti": "urn:uuid:0a89cd44-9912",
"depth": 2
}
}
By including parent_jti and root_jti, the token self-identifies its exact position in the delegation tree.
Invariant 2: Mathematical Expiration Clamping. An exchanged token can never outlive its progenitor: Child.exp ≤ min(Parent.exp, Now + MaxLease). If Alice's session has twelve minutes remaining before refresh, the worker subagent's token is clamped to twelve minutes.
Invariant 3: Active Back-Channel SET Cascade. When a session termination or user revocation occurs, the Authorization Server broadcasts an RFC 8417 Security Event Token (SET) to the agent runtime gateway:
{
"iss": "https://auth.corp.internal",
"events": {
"https://schemas.invarcore.com/secevent/revocation-cascade": {
"root_jti": "urn:uuid:0a89cd44-9912",
"revoked_at": 1731078000,
"reason": "user_offboarded"
}
}
}
The gateway injects root_jti into an in-memory bloom filter. Any subsequent tool execution bearing an invar_dag.root_jti matching the revoked root is rejected at the HTTP proxy boundary in sub-millisecond latency, killing all downstream subagents instantly.
The Architectural Rule
In distributed systems, authority is not a static stamp; it is an active delegation contract.
If you design an agent system where subagents can survive the termination of their authorizing subject, you have not built autonomy. You have built a zombie process with production write access.