Enterprise architects who have run production infrastructure already use policy-as-code. Open Policy Agent (OPA), AWS Cedar, Rego, and the custom in-house equivalents evaluate standing rules against attempted actions. "Only users in group X can modify production." "Payments above £1m require two approvers." "No API key can access both PII and finance records." These rules are standing. They apply to every action.
Decision tokens are something else. A decision token is a signed artefact that captures a specific authorisation: Priya approved this action, under this authority, within these limits, before this time. The token is per-action, per-principal, per-moment. The previous piece in this series defined the decision token in the context of banking agent governance.
Architects moving from policy-as-code into agent governance want to know: does the decision token replace policy-as-code, or does it sit beside it? The answer is beside. The two models answer different questions. Serious agent governance needs both.
The two questions production agents need to answer before acting
Every action an agent takes in production has two questions in front of it.
The first is the standing rule. Is this type of action, at this scale, against this resource, permitted by the organisation's current policy? The question has nothing to do with the specific principal who authorised it. It is about the shape of the action against the shape of the rules.
The second is the specific authorisation. Did a named principal with the right authority approve this specific action, within these specific limits, within a window close enough to count as fresh? The question has nothing to do with whether the action type is generally allowed. It is about who signed off, right now, for this one.
Running agent governance on only one of these is a half-answer. Running policy-as-code alone means your rules are enforced, and your audit trail cannot say who authorised each action. Running decision tokens alone means every action has a signer, and your organisation's standing rules are not checked.
How policy-as-code answers the first question
Policy-as-code is where the standing rules live, expressed in a format a policy engine can evaluate. Open Policy Agent evaluates Rego. AWS Cedar evaluates Cedar. Each policy framework reads a request's attributes, applies the rules, and returns an allow or deny.
For agent governance, the request shape typically includes the agent identity, the action name, the resource, the inputs, the time, the principal on whose behalf the agent is acting, and the context in which the agent is running. The policy evaluates those attributes against the organisation's rules.
The rules themselves tend to look like:
- No agent may delete records older than seven years without an explicit retention override.
- Trading agents may place orders only during market hours.
- Any action against a customer's data requires that the agent's calling principal is the customer or an authorised delegate.
- No single action may transfer more than £500,000 without two signatures.
Policy-as-code captures the enduring rules. It is where the organisation's business logic lives, versioned in a repository, reviewed by compliance, deployed to production. Runtime policy enforcement covers the deployment side in more depth.
What policy-as-code does not capture is who, specifically, said yes to a given action right now. The standing rule says the action type is allowed under these conditions. It does not say the specific action was approved by a specific person. For most routine operations, that is fine. For actions that need a named approver, it is not enough.
How decision tokens answer the second question
A decision token is the signed, scoped, time-bounded proof that a specific principal authorised a specific action. It names the signer, the payload (the exact action and its parameters), the scope (the limits the authorisation does not exceed), and the expiry.
Decision tokens matter when the audit question is personal. "Who approved this withdrawal?" "Who authorised this limit change?" "Who signed off on sending this communication?" These questions do not have good answers from policy-as-code alone. Policy says the action was permitted by the rules. The regulator wants to know who, specifically, said yes.
Decision tokens are also how organisations keep humans in the loop at the right granularity. If the policy says payments above £1m require two signatures, a decision token captures each signature as a cryptographic artefact. The regulator can verify the signatures years later. The organisation can defend its approval chain. The record is not a reconstruction from a chat log.
Decision tokens are not required for every action. Most routine operations are policy-governed, period. Decision tokens are the primitive for actions that need a named approver on the record.
A worked case: a quarterly limit review
Consider a bank running a quarterly review of corporate credit limits. The review involves many thousands of accounts. An agent summarises each account, applies the standing rules, and surfaces exceptions. A human reviewer decides on each exception. The approved exceptions are then applied to the core banking system.
Policy-as-code governs the routine side. The agent is only allowed to touch accounts in its assigned portfolio. It can only propose changes within the quarterly envelope. It can only act during business hours. Any attempt that violates these rules is blocked at the request path, before the attempt reaches the core banking system.
Decision tokens govern the exception side. When the human reviewer approves a specific exception, their client produces a decision token: payload "reduce overdraft limit on account 7291 to £0", signer the reviewer's DID (their unique digital identifier), scope "quarterly review operations within the £10m envelope", expiry fifteen minutes. The agent carries the token when calling the core banking system. The core system verifies the signature and the scope, confirms the policy rules still hold, and executes.
Both run. The policy check gates every action, routine or exceptional. The decision token gates the exceptional ones specifically. The audit record names the policy result and the signer separately. An auditor can walk either axis.
Three questions a buyer should ask about any agent governance plan
Enterprise buyers evaluating agent governance vendors should ask three questions.
Does your runtime check both? A vendor that only enforces policy-as-code can tell you the action was within the rules. A vendor that only verifies decision tokens can tell you who approved it. Each alone is a half-answer. The runtime should check both, in a defined order, with both results in the record.
Where does the signer come from? For decision tokens to carry audit weight, the signer must resolve to a durable identity the organisation already uses. If the signer is a session identity minted at prompt time, the audit trail does not reach the human. The signer should be a DID bound to the organisation's identity provider, or an equivalent.
What goes into the record? The record should contain the policy result, the decision token (when one was required), the authority chain the venue checked, and the resulting change. All signed by the venue, all retrievable years later. A vendor whose record is their logging product is offering observability. A vendor whose record is a durable artefact of the runtime is offering governance. These are different categories of product.
For the architect
Policy-as-code and decision tokens answer different questions in the same agent action. Policy answers "is this action permitted by the standing rules?" Decision tokens answer "did a named principal with authority approve this specific action right now?" Production agent governance uses both. The runtime that provides both, in the right order, with both results in a signed record, is the one that will survive the audit.
The enterprise architecture that integrates both is the pattern the regulator will test against. Covia's grid is built around both running together, by design.