The VERIFY Runtime Rubric evaluates autonomous runtimes across six dimensions that determine whether an AI system can reliably execute real business processes—not merely generate outputs.
VERIFY is a framework for specifying, comparing, manufacturing, validating, and operating domain-specific autonomous systems. The sections below show how Razor, the policy-guardrail runtime, improves every dimension.
Visual summary
Click the image to open it full-size.
Razor: Compile Policy Once, Apply It Many Times
Most policy automation asks a language model to reason from policy prose every time a case appears. The model must interpret the rule, extract the facts, resolve the boundary conditions, and decide what to do. That repeats an expensive and variable reasoning process for every decision.
Razor separates that work into two stages.
Policy time: policy text -> LLM + domain expert -> formal policy Case time: case -> entity extraction -> typed facts -> formal processor -> decision
At policy time, an LLM helps translate natural-language policy into explicit rules. A domain expert resolves genuine ambiguity. The result is a reviewed formal specification that defines the relevant facts, conditions, exceptions, outcomes, and required approvals.
At case time, the system no longer needs to reinterpret the full policy. It extracts the relevant entities from the case, validates them as typed facts, and evaluates them against the released specification. For example, a refund request may become:
days_since_delivery = 18 item_damaged = true final_sale = true refund_amount = 150 manager_approval = approved
A deterministic processor can then identify whether the rules allow, block, escalate, or require more information. LLM-heavy interpretation is concentrated where it adds value. Repeated policy application becomes formal processing.
Why this improves every VERIFY dimension
| Dimension | Leverage created by the formal representation | Primary metric |
|---|---|---|
| V — Verticalized | Expert retail knowledge is encoded once as domain facts, predicates, exceptions, and workflows. Every case reuses that expertise instead of asking a general model to reconstruct it. | Required policy checks covered |
| E — Enforceable | The specification becomes an execution gate. Tools remain disabled until authentication, fact validity, policy eligibility, and confirmation pass. Missing or conflicting facts cannot silently become permission. | Unauthorized attempts blocked |
| R — Reproducible | The same policy version and typed facts produce the same decision. Versioned rules and decision receipts support repeated trials, audits, and replay under later policies. | Repeated-pass reliability (pass^k) and outcome-state consistency |
| I — Interoperable | Typed facts, actions, and outcomes form a stable contract. Models, extractors, and tool adapters can change without changing the policy logic. | Verified model and tool substitutions |
| F — Fast | Case-time work becomes entity extraction plus rule evaluation. It avoids repeatedly loading policy prose and asking a model to reason through the same rules. | p50 and p95 latency |
| Y — Yield-Efficient | The expensive policy interpretation and expert review are performed once and amortized across many cases. Per-case tokens, retries, and review effort fall while accepted outcomes increase. | Accepted outcomes per dollar |
This architecture does not remove the need for LLMs or human judgment. Extraction can still fail, and ambiguous policy still requires an expert decision. The advantage is that uncertainty becomes visible and bounded. LLMs handle language. Experts define policy meaning. Formal processing handles repeated decisions — delivering clear and quantifiable benefits in each of the VERIFY dimensions above.
Watch Razor in action: standard LLM agent vs Razor-guarded RunTime
We recorded the same set of retail service tasks running on a frontier-model agent and on a Proverify RunTime compiled with Razor policy guardrails. The comparison shows where an open-ended agent proposes policy-violating actions, and how Razor blocks them before the tool layer.
Proverify.AI Positioning
Proverify.AI manufactures contract-grade autonomous runtimes that are verticalized, enforceable, reproducible, interoperable, fast, and yield-efficient.
VERIFY converts autonomy from a model capability into a measurable operating system.