Runtime Policies
Deterministic policy, compiled once, versioned like code, and evaluated every time an AI agent acts.
Written policy isn't executable policy
Every enterprise already operates a Delegation of Authority policy, an approval matrix, a signing schedule. These documents state, in advance, who or what may commit the organization, to what extent, and under what conditions. Nothing about them keeps an AI agent from acting outside that scope, because nothing evaluates the policy at the moment the agent tries to act. A written rule and a rule that's actually evaluated are not the same thing.
Policy, compiled once. Evaluated everywhere.
Runtime Policies compiles your existing Delegation of Authority documents into versioned, deterministic rules, and a policy can just as validly be authored directly where that's the better fit, not only compiled from a document. From there, each AI agent intent submitted to Runtime Authority is evaluated against the active policy automatically, before execution, and resolves to allow, escalate to human review, or deny. Your policy doesn't change. What changes is whether it's actually evaluated at the moment it matters. For what a compiled policy actually looks like, see Runtime Policies in the Developers section.
Every policy moves through the same states
A policy is drafted, reviewed by an accountable human, compiled into deterministic rules, and published as the active version. Retiring a policy doesn't delete it: every decision made under a since-retired version remains explainable against the exact version that was active when it was made.
Four capabilities, one deterministic runtime
Runtime Policy Evaluation
Each AI agent intent submitted to Runtime Authority is evaluated against published policy the moment it's formed, resolving to allow, escalate to human review, or deny, before the action executes, not on a review cadence after the fact.
Deterministic Policy Compilation
Policy is authored or extracted and compiled into deterministic rules. The same policy and the same input always produce the same decision: not a probabilistic judgment call. Where a policy is derived from an Authority Graph delegation, it stays grounded in that exact relationship: evaluation confirms the delegation is still active before the policy can grant the authority it was compiled from.
Inspectable Evaluation Engine
Compiled policy is inspectable and version-controlled, not an opaque model making a judgment call: every clause that matched a decision is traceable.
Policy Versioning
Every compiled policy is a signed, versioned artifact. A decision made under v3 remains explainable as a v3 decision even after v4 ships.
See Runtime Policies evaluate a real policy
Bring an existing Delegation of Authority document. We'll show you it compiled into machine-evaluable policy.