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.
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 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.
At rest, in flight, and over time
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.
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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.