Understanding AI Agents, Their Risk, and the Governance Unit
How algedonic.ai turns a fuzzy question — "how risky is this agent?" — into a number you can budget, compare, and defend. Now with a seventh dimension: Cost.
From chatbots to agents
For two years the conversation about AI risk was mostly about what a model might say. That era is ending. The systems being deployed across enterprises today are not chatbots; they are agents — software that takes a goal, makes a plan, calls tools, remembers what happened, and acts on the world without a human pressing the button each time. An agent doesn't draft a refund email for someone to send; it issues the refund. It doesn't suggest a Jira ticket; it creates one, assigns it, and closes three others it decided were duplicates.
That shift — from generating text to taking actions — is the whole story of agent risk. A language model that hallucinates produces a wrong sentence. An agent that hallucinates produces a wrong action: a refund that shouldn't have been paid, an IAM policy that shouldn't have been changed, a production deploy that shouldn't have shipped. The blast radius is no longer the conversation; it's whatever the agent can touch — and, increasingly, whatever it can spend.
The uncomfortable consequence is that the model name tells you almost nothing about the risk. A harmless meeting-notes assistant and a privileged production-remediation bot can run on the exact same frontier model. What separates them isn't intelligence — it's agency, access, impact, and cost. Two agents with identical IQs can sit at opposite ends of the risk spectrum depending on what they're allowed to do, what breaks if they're wrong, and how much compute they burn doing it.
So the first job of any agent-governance framework is to stop asking "which model is this?" and start asking "what can this thing actually do, what happens if it does it wrong, and what does it cost to run?"
THAMPI-C: seven questions that describe an agent's risk
algedonic.ai answers that question with a seven-dimension framework called THAMPI-C. Rather than collapse an agent into a single "good/bad" label, it scores seven independent properties — because risk is a combination, and any single axis can mislead you.
T — Tool authority (0–4): what the agent can touch. From no tools, to read-only, to business-critical writes, to admin/production/finance/identity-level authority.
H — Human oversight (0–4): how much a human is in the loop. This one is inverted on purpose: H0 means a human reviews every action; H4 means no meaningful oversight at all. A higher H means less control — which keeps the rule "higher = riskier" true on every axis.
A — Autonomy (0–4): how independently it acts — from a passive task assistant, through bounded and adaptive executors, to an autonomous operator, and finally a delegated authority that commits on the organization's behalf.
M — Memory (0–4): what it retains, from stateless, to session-only, to long-lived adaptive memory that accumulates across customers.
P — Planning depth (0–4): how emergent its behavior is, from a single hardcoded step to multi-agent self-decomposition.
I — Impact domain (0–4): what's at stake — informational, internal productivity, customer-facing, regulated (finance/HR/legal), or production/physical systems.
C — Cost (0–4): its compute and spend footprint, from negligible, through metered/moderate, to unbounded/runaway.
Every agent gets a compact code like T3H2A3M3P3I3C2. It travels with the agent into the registry, the policy engine, and the audit log — a portable, machine-readable summary of why something is risky, not just that it is.
The power of seven axes is that they expose the combinations a single score would hide. An autonomous agent (high A) with no tools and no real-world impact is interesting but safe. The same autonomy attached to production financial write-access, no human oversight, and an uncapped budget is a different animal entirely. THAMPI-C lets you see that difference at a glance.
Why cost is a risk dimension
It's tempting to file cost under "finance," not "risk." But for agents the two have merged. An agent that loops until it "finishes," fans out into a swarm of sub-agents, calls premium models on every step, and has no loop limit and no budget cap isn't just expensive — it's an operational hazard. A single misfire can burn through a month's budget overnight, and a runaway loop is its own kind of incident. Cost is the dimension that captures how badly the lights can flicker when an agent goes wrong, independent of what it can touch.
The C axis is derived from an agent's structured cost facts — model and tool calls per run, tokens consumed, premium-model use, paid external tools, multi-agent fanout, whether loops are bounded, whether a spend policy exists, and the estimated dollars per run. Those signals add up to a cost-exposure band, and two safeguards push it to the top: an estimated cost above the "critical" dollar threshold, or an unbounded loop on a dynamic planner, both force C4.
Here's the important nuance. Cost is the one axis that does not feed the weighted capability/impact score — burning money doesn't make an agent more capable. Instead, Cost works two other ways. It can floor the governance tier through explicit cost rules ("critical cost with no spend limit → at least Gated"; "C4 with high autonomy and no loop limit → Prohibited-by-default"), and it adds Governance Units. That keeps cost-driven risk visible and governable without distorting the blast-radius math.
From seven numbers to one decision: the governance tier
Seven axes are great for understanding, but a governance team needs a decision: how much control does this agent require? algedonic.ai derives a governance tier (0 to 4) in transparent steps.
First, a weighted risk score blends the six capability/impact axes (Cost excluded), with tools, autonomy, and impact weighted most heavily because they define the blast radius. That score maps to a base tier.
Then a set of explicit combination rules can floor the tier higher regardless of the score — and these now include cost rules alongside the capability rules. Business-critical write authority in a regulated domain (T≥3, I≥3) floors to "Gated." Privileged tools with critical impact (T4, I4) floor to "Prohibited-by-default." And critical cost with no spend limit, or a runaway loop with high autonomy, floor the tier on cost grounds alone. A separate cost floor also lifts the tier directly from the C band. The final tier is the highest of the score-derived tier, the strictest fired rule, and the cost floor — and every contributor is recorded with its reason.
The five tiers run: 0 Observe (log and watch) · 1 Standard guardrails · 2 Gated (approvals before actions) · 3 High-assurance (named owner, change review, audit) · 4 Prohibited-by-default (requires an explicit, time-boxed exception). This is explainable governance: the verdict is never a black box, and every input that produced it is on the table.
The problem tiers don't solve
Tiers tell you what controls an agent needs. They don't tell you how much governance effort your organization is carrying in total. Two agents can both be "Tier 3" while demanding very different amounts of oversight. And a Chief Risk Officer staring at a fleet of 300 agents has a question tiers can't answer: do we have the review capacity to govern all of this, and where is it concentrated?
You can't add up tiers. "Tier 3 plus Tier 2" is meaningless. What's needed is a quantity that behaves like a real unit of work — something you can sum across a fleet, track over time, and use to size a team. That's the Governance Unit.
The Governance Unit: a currency for oversight
A Governance Unit (GU) is a single, additive number representing how much oversight and control capacity an agent consumes. Think of it like story points for governance: a transparent, tunable estimate of governance load you can roll up across an entire population.
GU is computed deterministically from the classification:
The tier base reflects that higher tiers cost disproportionately more — controls compound. The bases roughly double each step: Tier 0 = 1, Tier 1 = 2, Tier 2 = 5, Tier 3 = 10, Tier 4 = 20.
Per-axis surcharges add load for the specific capabilities that make an agent expensive to supervise — e.g. T4 adds 3 and T3 adds 2; A3 adds 2 and A4 adds 3; regulated/critical impact and deep planning add more as their levels rise.
Cost load and cost surcharges are the THAMPI-C addition. The C band itself contributes (C2 adds 1, C3 adds 3, C4 adds 6), and specific cost hazards each add their own load: no hard budget limit (+2), no loop limit (+2), a premium model (+1), multi-agent fanout (+2), a production agent running at C3/C4 (+2). This is where an agent's spend risk shows up as a concrete, summable number.
Rule load adds a flat amount whenever any combination rule fires — a signal that the agent tripped at least one explicit governance obligation.
A worked example makes it concrete. Take a customer service agent classified T3 / H3 / A2 / M1 / P3 / I2 / C2 — it can update CRM records and process returns (T3), runs an adaptive multi-step workflow with only exception-alert-level oversight (A2 Adaptive Executor, P3, H3), and has a moderate, premium-model cost footprint with no spend cap (C2). It lands at Tier 2 (Gated), and its GU breaks down as:
Component | Points |
|---|---|
Tier 3 base | 5 |
T3 surcharge | +2 |
H3 surcharge | +1 |
A3 surcharge | +1 |
P3 surcharge | +1 |
I2 surcharge | +1 |
C2 cost load | +1 |
Premium model allowed | +1 |
No hard budget limit | +2 |
1 combination rule fired | +2 |
Total | 17 GU |
Contrast the extremes. A bounded, read-only field assistant (T1H0A1M0P0I1C1) lands at Tier 0 and just 1 GU. A multi-agent research agent (T1H3A3M2P4I1C4) is unremarkable on the pure capability axes — weak tools (T1) and low impact (I1) — but it fans out, replans recursively, runs on premium models with no loop limit and no budget, and burns past the critical dollar threshold. Its cost profile alone floors it to Tier 4 and piles on cost load and cost surcharges, landing it at 42 GU. Without the Cost axis, that agent would look almost harmless. With it, the framework correctly flags it as one of the most governance-hungry things in the fleet.
Why a single number changes the conversation
Because GU is additive, it unlocks things tiers cannot.
Capacity planning. Sum GU across your fleet and you get its total governance load — "this division is carrying 242 GU across 11 agents." Now staffing a review function becomes arithmetic instead of guesswork, and you can see exactly where the burden concentrates (often a handful of Tier 3–4 and high-cost agents carry most of it).
Drift detection. Re-classify an agent after its Agent Card or configuration changes, and the GU delta quantifies the shift. An agent that quietly loses its loop cap, switches to a premium model, or gains billing-API write access can jump a dozen GU in one change — "governance load jumped 60%" is a sharper, more honest alert than "the config changed," and it's exactly the signal that should pull a human back into the loop.
Prioritization and explainability. Sort a backlog of un-reviewed agents by GU to triage the heaviest first. And because every GU is itemized — Tier-3 base 10, +2 for T3, +1 for C2 cost load, +2 for no budget limit… — you can always answer "why is this number so high?" with the specific capabilities and cost hazards that drove it.
Numbers propose; humans decide
One last point matters as much as the math. In the algedonic.ai framework, the classification and its GU are a proposal, not a verdict. Evidence is extracted from the agent's documentation with every score citing the exact source snippet, deterministic rules floor the high-risk and high-cost cases, and the result is handed to a human reviewer who can accept or override any axis — with a recorded justification. Only then does the score become the agent's approved governance baseline.
That's the whole philosophy in one line: make risk legible — seven honest dimensions including cost, an explainable tier, and a single Governance Unit you can add up — and then keep a human accountable for the decision. As agents move from generating words to taking actions (and spending real money to do it), that combination of transparency and human ownership is what turns "how risky is this agent?" from an anxious guess into a number you can budget for, compare across a fleet, and defend in an audit.
