Ask a team running agents in production a simple question: when the agent did that, who did it? The honest answer is usually “it ran as me,” or “it uses the integration’s service account.” That answer is the whole problem. An agent acting on a borrowed badge can do anything the badge can do, at machine speed, with nobody’s name on the decision. Every guardrail written into its prompt is a request, not a control.

The borrowed-badge problem

We spent two decades teaching organisations that people should have their own identities, the least privilege they need, and an audit trail. Then agents arrived and we quietly skipped all of it. The fastest path to a working demo is to hand the agent a person’s token or a broad service account, and the demo becomes the production design.

The failure mode is not exotic. An agent reads a document, an email or a web page that contains instructions. It follows them, because following instructions in text is what it is built to do. Whether that ends as an odd answer or as data walking out of the building is decided almost entirely by what the agent was allowed to touch — not by how clever the model is. Permission scope is the blast radius.

A standards body just wrote down the fix

On 27 October 2026, NIST’s cybersecurity team proposed ten design tenets for agent identity management. They are a starting point, not a standard, and the authors say plainly that today’s standards don’t yet support all of them. But read as a set, they are the clearest description I’ve seen of what “safe by construction” means for an agent. Four of them do most of the work.

1. Every agent gets its own identity. Not the user’s, not a shared account. A distinct, verifiable name, so that “who did this?” has an answer that isn’t a person who was asleep at the time.

2. Delegation narrows at every hop. The agent is linked to the person who started the task, and when it hands work to a sub-agent or a tool, the authority it passes on can only shrink. A downstream agent can never claim more than its parent. This single rule closes the most common escalation path: an agent with modest rights calling something with broad ones.

3. Zero standing privilege. An idle agent holds no rights at all. It receives short-lived, task-scoped credentials when it starts work and they expire when the work ends. A leaked credential that is valid for ten minutes and one task is an incident; a leaked admin token is a breach.

4. Policy lives outside the model, and the decision is deterministic. Tenets seven and eight say it directly: separate policy from reasoning, and make access decisions deterministically. This is the argument from Put the Model Where Being Wrong Is Cheap, now in a standards-body draft. The model gets to want things. Ordinary, testable code decides whether it is allowed them.

Mandates: what the human actually asked for

The most interesting tenet is the least mature. A mandate is a signed statement of what the person intended — the outcome and the limits — that travels with the task. “Rebook my flight to Thursday, same fare class, no more than a modest change fee.” The agent can act within it and cannot widen it. If the cheapest Thursday option breaks a limit, the mandate says stop and ask.

There is no agreed format for mandates yet. You don’t need one to start. Write the limits of each agent task as data, check actions against them in code before they run, and log which mandate authorised each action. It is the same instinct as the propose, don’t act gate: the agent prepares, a boundary it cannot argue with decides.

The flight recorder

The last tenet is evidence: an append-only, tamper-evident record of who delegated what, under which mandate, and what the agent actually did — held somewhere the agent cannot write to. An agent that can edit its own logs can hide its own mistakes, and so can anyone who has compromised it. When something goes wrong, and it will, this record is the difference between a two-hour review and a two-week argument.

Where to start on Monday

  • Inventory. List every agent and the credential it runs under. Any agent running as a person, or on an account more than one agent shares, is first in line.
  • Separate the badge. Give each one its own identity, even if its rights are identical to start with. Attribution comes before restriction.
  • Shrink and shorten. Replace standing rights with task-scoped, expiring credentials, starting with anything that can write, send or pay.
  • Move the gate out of the prompt. Any rule that matters — spending limits, who may be emailed, which records may change — belongs in a deterministic check, not a sentence the model is asked to respect.
  • Log outside the agent. Delegation, mandate and action, to a store the agent cannot touch.

This is a different problem from securing the tools an agent calls, which I covered in Your MCP Server Is an Attack Surface. That post is about the door. This one is about the badge of whoever walks through it.

The question to leave with: for each agent you run, whose name is on the action — and could it do more than that person actually asked? If the answer to the second half is yes, the model is not your control. It’s your risk.


A companion to the six-part series Cheap to Be Wrong — an architecture for agentic systems.

Related: Your MCP Server Is an Attack Surface · An Agent Is a State Machine, Not a Loop · The Trust Ladder.


Discover more from Digital Reflections

Subscribe to get the latest posts sent to your email.

Leave a Reply

The Blog

At the intersection of data, AI, and imagination lies the path to transformation. Our greatest evolutions occur when we use technology not just to improve what is, but to reimagine what could be.

Discover more from Digital Reflections

Subscribe now to keep reading and get access to the full archive.

Continue reading