Solutions · Agent Credential Theft

Your agents hold keys an attacker can steal and a prompt can extract.

API keys and tokens accumulate wherever agents run: environment variables, config files, context windows, CI pipelines. Each one works for anyone who holds it, from anywhere, until someone rotates it. With Gradient, the agent never holds a credential, so there is nothing to take.

Nothing standing to steal Stolen ≠ usable Expires in minutes
39%
Of breaches involve stolen or abused credentials at some point in the attack, not only as the way in. (2026 Verizon DBIR)
3 for 3
In the agent incidents Anthropic disclosed, every path from foothold to impact ran through a credential found lying in the open.
Minutes
How long a Gradient-issued credential lives before its holder must prove, again, that it is what it claims to be.
The problem

The most frequently stolen object in security now exists in far more copies

Credentials were already the attacker’s favorite instrument when only people held them. Agents multiply the copies: every agent needs keys to act, for inference, for the systems it works on, and today those keys live as static secrets in environment variables, config files, and CI pipelines, on every host an agent runs on.

These non-human credentials now outnumber your people’s, and in most organizations nobody owns them, no named owner, no lifecycle, no offboarding. Each one is a bearer secret: it works for whoever holds it, from anywhere, for everything it was ever granted, until someone remembers it exists.

The evidence

The models had no attacker behind them, and they still went straight for the credentials.

The clearest evidence does not come from a red-team report. When Anthropic audited 141,006 of its own evaluation runs, it disclosed three incidents in which a model, left with internet access it wasn’t supposed to have, reached real production systems. The three incidents started differently, and in each one the next move was the same: find a credential. On a debug page, inside a package install, in application config, extracted, then used to reach what actually mattered.

There was no adversarial intent, no operator, and no tradecraft involved. The models took the path of least resistance their environments offered, and that path ran through credentials left in the open. Read our full analysis of the disclosures, including why annual breach reports undercount exactly this step.

Three ways agent credentials get stolen

At rest, in flight, and over time

Stolen at rest

The infrastructure gets breached

In March 2026, backdoored builds of LiteLLM reached PyPI through a poisoned CI pipeline, harvesting cloud, SSH, and Kubernetes keys from every host that installed it. Weeks later a pre-auth SQL injection let attackers pull API keys from LiteLLM’s own database. The keys agents depend on were sitting in the one place everyone trusted.

With Gradient

There are no static keys to harvest

Credentials are minted per task, expire in minutes, and can’t leave the host they were issued to. A compromised package finds no standing secrets in the environment, and a dumped database yields nothing that can be replayed.

Extracted in flight

The agent is talked out of its token

An agent reading the web, email, or tickets can be persuaded to hand over what it holds. EchoLeak showed one crafted email could make Microsoft 365 Copilot leak internal data with zero clicks. There was no exploit and no malware involved. The agent did what it was told.

With Gradient

The agent holds nothing to hand over

Credentials stay outside the agent’s memory, logs, and prompts. The gateway attaches authority per call. An injected instruction to reveal keys finds nothing to reveal, which is how Gradient contains prompt injection as well.

Kept over time

The stolen key just keeps working

A leaked token is valuable in direct proportion to its lifetime, and most agent tokens live for months, work from anywhere, and get revoked app by app, after someone notices. Closing the entry point doesn’t revoke what was already copied.

With Gradient

A stolen token expires quickly and does not work anywhere else

Tokens are bound to the verified platform that earned them and are inert on any other machine. Renewal requires re-proving identity, platform, and scope. Pull renewal and access ends within one token lifetime, everywhere at once, with no per-application revocation to chase.

How it works

Four best practices, enforced by design

Every credential-security checklist says the same four things. With Gradient for Agents, none of them remains a policy you enforce through discipline. Each one becomes a property of the architecture.

The advice: shorten credential lifetimes

Minutes, by default

A stolen credential’s value is a direct function of how long it keeps working. Gradient credentials live for minutes rather than months, and renewal is a fresh attestation of identity, platform, and scope rather than a token refresh.

The advice: get secrets out of code and config

Custody at the gateway

Inference keys and target credentials come out of env vars, configs, and debug endpoints entirely. The agent asks for actions; the gateway attaches authority. There is no readable location where a secret sits waiting to be found.

The advice: inventory your non-human identities

Every agent named, owned, scoped

No anonymous service accounts. Every agent runs under a session identity with a named human owner and an explicit scope, and when that owner is deactivated in your IdP, their agents stop within one sync interval.

The advice: analyze credential exposure in incident response

The log already answers it

What could this agent reach, and what did it touch? Per-call audit, session identity, owner, scope, decision, streamed to your SIEM. Exposure analysis becomes a query rather than a forensics project.

The principle

A credential that cannot be copied, replayed, or kept is not worth stealing.

Hiding keys better will not get you there. Every incident above found them anyway. The approach that holds up is making the found key useless, which is what Gradient for Agents does by design.

Get started

Take your keys off the table

Book a session. We’ll show an agent doing real work with zero credentials in its environment, and the audit trail every call leaves behind.