DEV Community

Amit
Amit

Posted on Originally published at artificialcuriositylabs.ai

An Agent's Credentials Cross Clouds. Its Off Switch Doesn't.

A security lead learns at 9:40 on a Tuesday that the claims-triage agent is reading files outside its scope, and she has to stop it everywhere. Cutting its access takes three actions in three consoles, cleaning up afterward takes three more, and no console tells the others what happened.

The agent runs on Agent Runtime in Google's Gemini Enterprise Agent Platform, reads claim documents from an Amazon S3 bucket, and writes case notes to a SharePoint site through Microsoft Graph. Nothing in that setup stores a secret. Every hop uses workload identity federation, which is the good news and the cause of the problem: each cloud trusts the agent through a local rule that its own administrator wrote, and each rule has its own off switch.

Identity is one layer of a larger map of AI and data services across the three clouds, and companion posts cover agent platforms, models, and cloud marketplaces.

Three clouds, three kinds of identity

Google ties the identity to the resource. Agent Identity gives each agent a SPIFFE ID, a standard workload identifier, derived from the resource that hosts it, plus an X.509 certificate valid for 24 hours and rotated automatically. Access tokens are bound to that certificate, the identity can't be impersonated, and developers can't mint long-lived keys for it. The same page states the lifecycle cost: if you delete an agent and deploy a replacement, "even with the same display name, code, and configuration," it gets a new principal, and the old agent's IAM bindings stay behind as inactive grants that someone removes by hand. An in-place update keeps the same resource and the same identity.

In Microsoft Entra Agent ID, the identity is a directory record with people attached: an agent identity is a service principal created from a blueprint. It carries a sponsor and permission assignments, and because agents of one kind share a blueprint, an admin can disable every agent of that kind in one operation. Agent identities are single-tenant: they get tokens only in the tenant that created them.

AWS scopes the identity to an account and accepts tokens from any OIDC issuer. Amazon Bedrock AgentCore Runtime creates a workload identity automatically, and each AWS account has exactly one agent identity directory. Inbound calls can carry IAM SigV4 or a JWT from any OIDC discovery URL, including Entra. The token vault binds third-party tokens to the workload identity and the user ID, and the identity service works outside Runtime on ECS, EKS, Lambda, or on-premises.

Google Cloud Microsoft Azure AWS
Identity is tied to The hosting resource A blueprint in an Entra tenant An AWS account's directory
Strength Tokens bound to a 24-hour certificate, no keys Records a sponsor and a block state Accepts JWTs from any OIDC issuer
Gap Delete-and-recreate yields a new principal; old grants linger Identity works only in its own tenant The directory is scoped to a single account

The bridges are pairwise

To read S3, the claims agent requests an OIDC ID token from Google, a capability Google documents for AWS and Azure and still labels preview. An AWS administrator has written an IAM role whose trust policy accepts Google's issuer and this agent's subject. The agent calls AssumeRoleWithWebIdentity, following a sample from Google Cloud's solutions architects, and gets AWS credentials whose session defaults to 3,600 seconds; roles can allow up to 12 hours.

To reach SharePoint, an Entra administrator has added a federated identity credential with the "Other issuer" option, naming Google's issuer, the audience, and the subject claim, per the same Google page. Entra's integration guide supports this path for agents on Google Cloud and AWS, for app-only access, where the agent acts as itself with no signed-in user.

Think of the Google identity as a passport and each federation rule as a visa policy. Cancel the passport by deleting the agent, and I'd expect the agent can no longer get new visas, because the identity Google issues tokens for no longer exists. Visas already stamped, meaning the AWS session and the Entra token, work without the passport until they expire, and each country keeps its own visa record. The analogy breaks in one place: a visa names a person, while a federation rule names a subject string, and it honors any token from that issuer carrying that string.

Revoking one agent, counted

Back to 9:40 on Tuesday. To stop the agent everywhere and leave nothing behind, the security lead takes six actions in three consoles: three to cut access now and three to clean up.

Where Cut access now Clean up
Google Cloud Delete the agent Remove its inactive IAM bindings
AWS Revoke the role's active sessions Delete the trust rule for Google's issuer and subject
Microsoft Disable the Entra identity holding the federated credential Remove the Microsoft Agent 365 registry entry

Each cut has a different limit. On AWS, revoking attaches an AWSRevokeOlderSessions deny policy covering every session issued before the revocation and about 30 seconds after it, to absorb propagation delay. The role can be assumed again afterward, which is why the trust rule has to go too. On Microsoft, disabling the identity stops new tokens, but access tokens already issued last 60 to 90 minutes by default. Microsoft's answer is continuous access evaluation for workload identities: Microsoft Graph rejects a token once its service principal is disabled. It covers single-tenant service principals that opt in, and only on Graph.

Two gaps remain, and both are my inference. Google documents no lifetime for an ID token issued before deletion, so one already in hand might still be exchanged at AWS or Entra until it expires. And every token in this chain is a bearer token: if one leaks, it works from anywhere until it expires.

In the cleanup column, Agent 365 can connect to Bedrock and Google platforms and list their agents, but the connection is read-only apart from an optional delete permission, sync runs only when an admin starts it, and removal of an agent at the source is not guaranteed to remove it from the registry. The connection also needs a stored key, since keyless options such as workload identity federation aren't supported yet, so the registry that inventories federated agents reaches them with a secret.

What is standardizing

The piece that would remove rows from that table is a revocation signal. The IETF WIMSE working group's AI Identity Management System draft, with authors from Defakto Security, AWS, Zscaler, Ping Identity, OpenAI, and Okta, assembles existing workload identity and OAuth standards and defines no new protocol. On deprovisioning, it says the issuer stops renewing the agent's credentials, and when the change can't wait for expiry, the issuer signals relying parties and the issuers of derived credentials. The draft names the OpenID Shared Signals Framework as one way to carry that signal, and says recipients "MUST ensure that revoked or downgraded authorization is enforced without undue delay."

In the security lead's table, that signal would collapse the AWS and Microsoft "cut access" cells into the Google deletion: Google signals, AWS and Entra act. It would not touch the cleanup column.

Two other standards cover neighboring rows. MCP's Enterprise-Managed Authorization extension became stable on June 18, letting an enterprise identity provider grant MCP server access centrally, and Okta's Cross App Access names 25+ early adopters. That stops new user grants in one place, though issued tokens still run to expiry, and it applies when the agent acts for a person, which this app-only agent does not. A2A v1.0 lets an Agent Card carry JWS signatures, so a caller can check who published the card describing an agent.

Related work, for readers who want the plumbing: WIMSE's HTTP signature draft; an individual (not working-group) draft on applying WIMSE to AI agents; Microsoft's tutorial for federating SPIFFE identities with Entra; IAM Roles Anywhere, whose trust model maps a certificate's spiffe:// URI to session tags; and a Google Developer Expert's proof of concept of Foundry and Google agents calling each other over A2A with no stored secrets.

What is not standardizing

The record of the agent has no shared home. Entra holds the sponsor and the block state. The AWS Agent Registry, generally available since August 31, holds approval workflows and indexes agents "regardless of where they're built or hosted". Google's Agent Registry catalogs agents, MCP servers, and skills, including manually registered components running on-premises or in other clouds. Each is the system of record for the agents it hosts and a partial copy for the rest.

None of the three clouds documents subscribing to another cloud's revocation signal for an agent identity. The draft's signal only helps once AWS and Entra subscribe to Google as an issuer.

Lifecycles do not line up either. If a team deletes and recreates the Google agent, every AWS trust policy and Entra federated credential written against the old subject stops matching. The rewrite falls to administrators in other clouds who may not know the recreate happened.

The OpenID Foundation's threat model for cross-boundary agents, published October 12, frames the limit: "no single gateway will ever control all agent traffic. Each major provider runs its own gateway, on its own assumptions, and none will hand that role to a competitor." Among the threats it names are permissions broadened in translation from one domain to the next and access that outlives the task. It traces them to a common root, treating an agent as if it were a human user.

The closest neutral candidate I can see for a shared record launched on November 10. The Linux Foundation took on the Agent Name Service, a seven-document specification for naming, registering, and verifying agents through DNS. Its scope stops at naming and discovery, leaving out ownership and approval. AWS, Microsoft, and Google are not among its eleven supporters.

So what

If an agent crosses clouds today, its kill switch is a runbook. Write it before the agent ships.

  1. Keep one list per agent of every federation rule that trusts it: the issuer, the subject, the receiving cloud, the role or credential, and who owns the rule. Until a standard record exists, that list is the agent's identity outside its home cloud.
  2. Shorten sessions on the receiving side. AssumeRoleWithWebIdentity accepts sessions as short as 900 seconds. If the revoke step is missed, a 15-minute session cuts the exposure from an hour to 15 minutes.
  3. If your pipeline ever deletes and recreates an agent instead of updating it in place, it must also rewrite every federation rule that names the old subject.
  4. Put the six-action table in the incident runbook with a named owner for each cell, because no cloud will prompt anyone for the other two.

The question I have not answered: will the clouds subscribe to each other's revocation signals, or will an enterprise identity provider become the hub they all subscribe to? I also have not tested whether AWS still accepts a Google ID token from an agent deleted a minute earlier.

Top comments (0)