# Why agents should never hold keys

> 2026-11-03. Standing keys give agents too much, for too long. How Titan keeps credentials in your vault and gives agents a signed grant for one call that lasts 30 seconds.

Source: https://www.hexelstudio.com/blog/why-agents-should-never-hold-keys

Published 2026-11-03 · By Hexel Studio

An agent with a standing key can do anything the key can, for as long as it lasts. Titan gives agents something narrower: a grant for one call.

The quickest way to let an agent use a system is to give it a key. Paste an API token into its environment and it can call the API. Many early agents run exactly this way, often on someone’s personal token. It works, and it is the riskiest thing about running agents.

A key is a promise to whoever holds it. It doesn’t know which agent is holding it, what that agent was asked to do, or whether the call it is about to make has anything to do with the task. It lasts until somebody remembers to revoke it. And an agent is a program that reads untrusted text for a living: web pages, emails, tickets, documents. Any of those can carry instructions. If one of them talks the agent into misusing its key, the key does what it’s told.

## What a key gives away

Three things go wrong with standing keys. The scope is the key’s, not the task’s: a token that can read invoices can usually delete them too, and the agent holds both powers all day. The lifetime is the key’s, not the call’s: a key copied into a log, a prompt or a crash report stays useful long after the agent is done. And the record is thin: the system on the other side sees the key, not the agent, and certainly not the person who asked the agent to act.

## Grants instead of keys

Titan takes the key out of the agent’s hands. Credentials stay where your organization already keeps them, in Vault, AWS KMS, Azure Key Vault or a hardware security module. Each stored credential is encrypted with a key of its own, and that key is wrapped by one you hold. Agents never see either.

When an agent wants to act, it asks Titan. Titan checks who the agent is and what it is asking for against your policy and, if the policy allows it, issues an execution grant. The grant is signed, lasts at most 30 seconds and is bound to the exact call: the capability, the target and the arguments. Change one argument and the grant no longer matches. It is checked again when the call runs.

## One release per grant

A grant is not a credential either. When the call runs, Connections, the service that holds your connected accounts, takes the signed grant, checks its signature, picks the one connection that grant may use and releases a short-lived credential for that call. It leases the connection once per grant, so the same grant can’t be replayed to draw a second credential. The credential is added to the outgoing request and is never handed back to the agent.

If anyone has stopped that agent, that session or that connection, the release is refused before any lease is taken. Token refresh happens on the same side of the line: tokens are refreshed shortly before they expire, under a lock, and the new token is stored encrypted. The agent never has to know a token exists.

## What changes for the people running agents

Without standing keys, a few hard things get simpler. A leaked log line is not an incident, because nothing in it works for more than a few seconds or for any other call. Taking access away is one action in one place: stop the connection, and every agent that used it loses the ability to act through it on its next call. Least privilege stops being something each key’s scopes approximate and becomes something your policy states, call by call.

The record gets better too. Every decision and every execution is written to the Agent Ledger, a hash-chained log in which each entry carries the digest of the one before. The ledger holds identifiers, outcomes and digests, never tokens, credentials or arguments, so the record of what an agent did isn’t itself a place secrets can leak from.

## What it doesn’t cover

Grants protect the systems Titan governs. They don’t stop a process that never asks Titan, such as a script someone runs by hand, and they don’t inspect traffic on a laptop. Titan’s protection on those paths is the same idea from the other side: governed tools keep no standing credentials on the device, so an agent that goes around Titan has nothing to act with. Use it alongside your endpoint security, not instead of it.

## The short version

Keys belong in vaults. Agents get permission for one call, for seconds, after a decision someone can read later. It is a small change in how access is handed out, and it removes the most common way an agent ends up able to do far more than it was asked.

---
Hexel Studio · https://www.hexelstudio.com · Index for agents: https://www.hexelstudio.com/llms.txt
