Measuring AI agent risk
It is not a policy-scope dimension; rules bind on agent id, team and tag
every questionOn this page
Autonomy is not the risk; reachable effect is
The instinct is to rank agents by how much they decide for themselves, and it produces the wrong order. An agent that runs a fifteen-step plan without supervision, reading and summarising internal documents, can do exactly one thing wrong: produce a bad summary. An agent that makes one tool call, reviewed by nobody, can issue a refund. The second is riskier by a wide margin, and it looks simpler in every architecture diagram.
So the primary question is not how much latitude the agent has but what it can reach. That reframing has a useful property: the answer is already written down, in the grant list, and it is enforceable rather than descriptive. An agent’s permissions are the specification of what a hijacked version of that agent can do, which is the correct threat model given that persuasion is unsolved and detection has false negatives.
The second question is what happens if the reachable action is taken wrongly, and the axis that matters is not severity in the abstract but reversibility. A read is recoverable. A write into a system you control is usually recoverable. Money leaving, a record being deleted, an email reaching a customer, a ticket being closed on a regulator’s deadline — those are not, and no amount of afterwards fixes them. Reversibility is what turns a mistake into an incident, and it is the multiplier on everything else.
The third question is exposure: does this agent read text written by people outside your organisation. A ticket body, a scraped page, a database row populated from a public form, a document in a shared drive. That is the channel through which the grant set gets exercised for the wrong reason, and an agent with a wide grant set and no untrusted input is a materially different proposition from the same grants pointed at a public inbox.
Four inputs you can actually measure today
None of these needs a new tool. They need somebody to look at rows you already have and write down what they found.
The grant set, counted as actions rather than as roles. How many distinct actions can this agent take, and how many of them does its declared purpose actually require? The exercise of comparing the two is the single most productive hour in this whole area, because grants accumulate — an agent gets a role that was convenient at the time, the role gets widened for somebody else, and nobody removes anything. Note also whether the agent could obtain, through a delegation chain, an action it does not hold directly. Where the chain intersects rather than accumulates it cannot, but that is a property worth confirming rather than assuming.
Irreversibility, marked per action rather than per agent. Token Observe supports pinning a tool as requiring an effect contract, which is a durable classification independent of whether a contract is currently active: with the pin set and no active valid contract, raw execution is refused. That flag is useful as a risk input as well as a control, because it forces somebody to make and record the judgement that this particular call has an external effect worth constraining.
Untrusted-text exposure, established from what the agent reads rather than from what it is called. Which of its tools return content written outside your organisation? Does it consume retrieved documents? Does it read tool results at all, or only produce them? A directive inside a tool result is weighted higher than the same words from a user for exactly this reason, and an agent whose entire input is internal and structured is exposed differently from one triaging a public queue.
Money, measured as headroom rather than as spend. What ceilings does this agent have — per request, rolling hour, day, month — and does it have any at all? The number worth putting in front of a finance owner is not the total spend but the count of agents with no ceiling configured, because those are the ones outside the control entirely. Rate limits belong here too, on requests, tool calls and tokens per minute, because they bound the loop rather than the invoice and catch a runaway in minutes rather than at the daily boundary.
- Grants, counted as actions
- The count of distinct actions the agent may take, and the count its declared purpose requires. The gap between the two is the risk you can remove this week.
- Irreversibility, marked per action
- Which reachable actions move money, delete data or reach a customer. A durable per-tool classification is better than a judgement made freshly each time somebody reviews the agent.
- Exposure to outside text
- Which tools return content written by people outside your organisation. That channel is how the grant set comes to be exercised for the wrong reason.
- Ceilings, and their absence
- Per-request, hourly, daily and monthly money plus per-minute request, tool-call and token limits. The headline number is how many agents have none.
Two evidence questions that change the answer more than the inputs do
An agent’s risk is not a property of the agent alone; it is a property of the agent and the controls that are actually operating on it. Two questions establish that, and both have a specific failure mode where the honest answer and the reassuring one look identical.
First: is the rule that would catch this actually enforcing? A policy in observation mode is evaluated exactly as an enforcing one and then skipped, which is the right way to learn a false-positive rate and the wrong way to leave a rulebook for six months. The mechanism that makes this answerable is that a shadow match writes a decision event on the trace naming the policy, its mode, its action and why it matched — so an estate where every rule is in shadow is distinguishable from one with no rules at all. Ask for the count of enforcing rules that bind each high-risk agent, not the count of rules in the system.
Second: is this agent inside your coverage at all? An agent that never routes through the control is not low risk, it is unmeasured, and the two render identically as an absence. This is why discovery belongs in the same programme rather than in a later phase: its output is the denominator. An estate where forty agents route through the gateway and an unknown number do not is not fully governed, and the honest sentence needs a number on both sides of it.
The same rule applies inside discovery. A findings list is empty both when nothing is wrong and when the evidence feed died in July, so coverage has to be reported per source and beside the findings — separating a connector that is alive from one that is actually delivering rows, since an exporter returning an empty page every hour is the commonest way a feed fails and the one that affirmatively asserts freshness while observing nothing. A source may only clear a finding when its run completed, so a failed or timed-out pass leaves every existing finding standing rather than silently resolving the estate.
Write both answers next to each agent. A wide grant set behind an enforcing rule, inside coverage, is a managed risk; the same grant set behind a shadow rule, outside coverage, is an unmanaged one wearing the same badge.
The risk tier field, and the limit worth knowing before you rely on it
Token Observe records a risk tier per agent — minimal, limited or high, defaulting to limited — and it is worth being precise about what that field is and is not.
What it is: a place to record a decision a person made, displayed in the console, carried verbatim into every recertification snapshot so a named reviewer attests it, and sealed by that snapshot’s digest. That makes the tier reviewable rather than merely present, which is most of the value: the failure mode of a risk register is not that the tiers are wrong but that nobody can say when they were last looked at or what configuration they were looking at.
What it is not: a policy-scope dimension. Policy scope matches on agent id, on team case-insensitively, and on tag case-sensitively — not on tier. So a rule intended to bite on your high-risk agents is written against a tag you maintain, and the tag and the tier can drift apart unless somebody keeps them together. That asymmetry in case handling is worth knowing before you name things, because to a kill switch two spellings of a team are the same team, while to a policy two spellings of a tag are two different tags.
There is also no scoring model, no weighting and no computed rating anywhere in the product, and that absence is deliberate rather than a gap waiting to be filled. A number carries an authority its inputs do not support: an agent scored 7.4 invites a conversation about whether it should be 7.1, when the useful conversation is about which two grants to remove. What replaces the score is the recertification record — a named human attesting an exact configuration, with a validity period, so the question becomes when was this last reviewed and by whom rather than what does the dashboard say.
Review rather than score, and make staleness mean something
The mechanism that makes a periodic review worth anything is what the review binds to. An access review recording that an agent holds a role certifies almost nothing, because the role is editable afterwards and the record does not say what was in it. Six months later a named reviewer’s attestation sits beside a permission set they never saw, and nothing distinguishes that from a genuine review.
Token Observe binds a review to a digest over the exact governance-bearing configuration — name, owner, team, lifecycle status, role ids, the effective role grants, tags, purpose, risk tier, budgets, rate limits, data policy, routing, the named-human requirement and metadata — and, crucially, binds each referenced role by name, permission count and a hash over its normalised permissions rather than by its identifier. Editing a role therefore makes every affected review stale immediately, without rewriting the history of what was actually attested. Ordering is normalised where it grants no different authority, so reordering tags or actions does not manufacture staleness and dilute the signal.
That produces six postures rather than a score: never reviewed, current, due, overdue, stale — meaning the review verifies but the live configuration no longer matches what was attested — and invalid, meaning the stored snapshot or its binding no longer holds. A fleet register reports those across the estate, and it requires an organisation-wide evidence scope precisely because a whole-estate posture filtered to one team would report the posture of a fraction as the posture of the whole.
The limit belongs here rather than in a footnote. An overdue or stale review never suspends the agent. There is no notification scheduler. Turning a compliance calendar into an availability control needs an explicit grace period, a named escalation owner and a dry-run path before it can be a default, and the enforcement action today is a person using the lifecycle API, with their decision audited. That is a real gap and it means the review cadence is a process you have to run rather than one the software runs for you.
Where the numbers come from, and how to read them honestly
Four surfaces produce figures worth putting in a quarterly review, and each has a caveat that belongs beside it.
A governance report over a window: blocks, redactions and approvals. Read a rising block rate as a question rather than as a success — it can mean a control is working or that a rule is mis-scoped and somebody is about to route around it. Read a zero block rate as a question too.
A budget report: utilisation against ceilings with headroom, aggregated by team and by fleet. The caveat is structural and worth stating: ceilings bind per agent rather than per pool, so team and fleet figures are the sum of the per-agent ceilings that exist, published beside a count of the agents that have none. That count is the number to look at, because an agent with no ceiling is not covered by any of this.
A policy replay against recorded traffic, which is the only way to know what a candidate rule would have done to last month. Three properties decide whether the report means anything. Coverage is full, partial or none, and none returns null counters rather than zeroes — null means the recorded traffic never carried the input this rule triggers on, while zero means it did and the rule would have changed nothing. The denominator is the count evaluated, not the count scanned: requests refused before policy evaluation, by a bad credential, permissions, a kill switch or a delegation denial, are excluded because a rule cannot be credited with stopping a request that never reached it. And the earliest trace actually seen is reported, so a window trimmed by retention is visible rather than implied.
Discovery coverage and findings, read in that order. The findings are the interesting part and the coverage is the part that tells you whether the findings mean anything, which is why the coverage belongs above them on the page rather than in a tab.
One figure to treat with more suspicion than the rest: any retrospective savings estimate. It can model what a cheaper model would have cost at the same token counts and it cannot tell you the cheaper model would have answered acceptably. Quote the high-confidence band, carry the assumptions with the number, and treat it as a ceiling rather than a forecast.
How to put measuring AI agent risk into practice
- 01
List each agent’s actions, not its roles
Expand the roles into the distinct actions they permit, and set that list beside the declared purpose. The gap is the risk you can remove without buying anything. - 02
Mark the irreversible actions durably
Per tool rather than per agent, as a classification that survives a configuration change, so the judgement is made once by somebody accountable rather than freshly at each review. - 03
Establish which agents read outside text
Which tools return content written by people outside your organisation, and whether the agent consumes tool results at all. That is the channel through which authority is exercised for the wrong reason. - 04
Count the agents with no ceiling
Money and rate. That count, rather than total spend, is the headline for a finance owner, because an agent with no ceiling is outside the control rather than under a generous one. - 05
Ask whether the relevant rules are enforcing
Per high-risk agent, count the enforcing rules whose scope actually selects it. A rulebook in observation mode produces the same outcomes as no rulebook and a very different impression. - 06
Read the coverage before the findings
Establish which agents are inside the measured set at all. An unmeasured agent is not a low-risk one, and the two look identical on every surface that renders an absence. - 07
Record the decision against the agent and have it reviewed
A tier set by a named person, attested against an exact configuration with a validity period, so the question six months later is who reviewed this and against what rather than what the dashboard says.
Where this argument meets an implementation
Agent registry
One record per agent, and it is the record the gateway enforces against.
Agent permissions
Deny by default, explicit deny wins, and delegation intersects — so an agent cannot borrow authority it was never granted.
Spend controls
Hard USD ceilings, per-minute rate limits and a kill switch, all decided before the request leaves your network.
Shadow AI radar
Five evidence sources for AI activity that never touched the gateway, and a coverage model that refuses to call a dead feed a clean estate.
Those pages are one product's implementation of what this guide argues for; describe what your agents actually do and you will get a straight answer about whether you need any of it, including when the answer is no.
Talk it throughShould agent risk be scored?
A recorded decision beats a computed score, and Token Observe deliberately ships no scoring model. The reason is that a number carries an authority its inputs do not support: the grant set, the reversibility of the reachable actions and the exposure to outside text are judgements, and averaging judgements into a rating invites an argument about the rating rather than about the two grants worth removing. What replaces the score is a tier recorded against the agent, carried into a recertification snapshot that a named human attests against an exact configuration, with a validity period — so the reviewable question becomes when was this last looked at and by whom.
What is the single best proxy for how risky an agent is?
The number of irreversible actions it can reach. Everything else adjusts that figure rather than replacing it. An agent with fifty read-only grants and a public input queue is a nuisance risk; an agent with one grant that moves money is an incident risk, and it looks simpler in every diagram. If you have time for one exercise, expand each agent’s roles into distinct actions, mark which are irreversible, and start the conversation there rather than with model capability or degree of autonomy.
Why does a risk tier not drive policy scope?
Because in Token Observe policy scope matches on agent id, on team case-insensitively and on tag case-sensitively, and not on the tier. That is a real limit rather than a design preference to defend: a rule meant to bind your high-risk agents has to be written against a tag you maintain, and tag and tier can drift apart unless a person keeps them together. It is worth knowing before you name things, along with the case asymmetry — two spellings of a team are the same team to a kill switch, while two spellings of a tag are two different tags to a policy.
How do you account for agents you have not found yet?
By treating the coverage figure as the denominator for everything else and reporting it beside the findings rather than behind them. An estate where a known number of agents route through the control and an unknown number do not is not a governed estate, and every percentage you compute over the known set inherits that uncertainty. The specific discipline is that a dead evidence feed must never be indistinguishable from a clean estate, which means reporting per-source coverage, separating a connector that is alive from one that is delivering rows, and never letting a failed or truncated scan clear an existing finding.
What does an overdue review actually do?
Nothing automatic, and that is a stated limit rather than an oversight. Token Observe derives and exposes six postures — never, current, due, overdue, stale and invalid — in the console and in a paginated fleet register, and it runs no notification scheduler and never auto-suspends. Automatic suspension would turn a compliance calendar into an availability control, which needs an explicit per-install grace period, a named escalation owner and a dry-run path rather than a surprising default. The enforcement action is a person suspending the agent through the lifecycle API, with that decision audited.
Prefer to ask a person? Write to us →
Bring us the question this guide did not answer.
Write to hello@tenhaw.com with what your agents do, which providers they call and what would have to be true for you to put something in front of them. James Rooney replies. You will get a straight answer about whether Token Observe fits, including when it does not.
no form · no qualification step · no sales desk · the other three ways in