v2.0

GoRules Version 2 is here - redesigned, now with managed cloud.GoRules Version 2 is here!

Watch the launch videoWatch
gorules
Book a demoGet started

AI governance software that enforces,
not just documents.

Your governance platform inventories models, scores risk, and files the assessments. GoRules is the AI policy enforcement layer that runs beside it: every model score and agent action passes through versioned decision rules that approve it, escalate it to a human, or block it - deterministically, with an audit trail from regulation clause to individual decision.

The auditor's question,
answered at runtime.

Watch an EU AI Act readiness audit at a bank: a governance file that cannot answer one question, a policy clause and a hardcoded threshold that disagree, the clause codified as an executable rule, 48,200 AI decisions replayed - and a decision stream where every model and agent output carries its policy version and clause.

scroll to play
Tuesday, 09:12

The documentation is perfect. The question is not about documentation.

An EU AI Act readiness audit at a bank: 14 AI models inventoried, every risk assessment signed, policy v4 published. Then the request lands: demonstrate that credit decisions above the high-risk threshold receive human review - Policy 4.2, Art. 14. Beneath it, the decision stream keeps flowing.

The gap

Paper says 0.72. Production says 0.80.

The policy PDF requires human review above a 0.72 risk score. The gate that actually runs, risk_gate.py, has 0.80 hardcoded since 2024. Between the two numbers sit months of model and agent decisions, and nobody can say which ones slipped through.

The codification

The clause becomes a rule that runs.

Policy 4.2 opens in GoRules as a decision table. The review threshold is typed in at 0.72, the value the clause always said. Above it, a rule the code never had: fully automated denials for vulnerable-segment customers are blocked outright, with the Art. 5 reference attached.

Proof over history

48,200 AI decisions replayed.

Ninety days of model and agent output re-run against the draft while you watch: every high-risk decision routes to review, no prohibited denials, every decision carries its clause. And the audit answer nobody had: 312 decisions between 0.72 and 0.80 would have been reviewed.

Sign-off

Risk and compliance sign. v4.2.0 ships.

Jane Cooper signs for model risk, compliance countersigns, and the policy promotes through staging to production with the diff and both approvals recorded. Rollback stays one click away.

The answer

Every decision now carries its clause.

The stream stamps each row with v4.2.0 and the rule that fired. A 0.76 decision flips to human review and lands in the queue with full context. An agent tries a prohibited denial and stays blocked - the refusal is the feature. The auditor gets a chain: decision to rule to version to approver to clause to Art. 14.

Documented everywhere.
Enforced nowhere.

An AI governance platform can tell you which models you run, who owns them, and what risk tier each one landed in. What none of that machinery can do is stop this afternoon's 0.76 from being auto-approved. Between the policy PDF and the model output sits the only thing an auditor ultimately asks about: the mechanism that applies the rule to every single decision. In most organizations that mechanism is a threshold hardcoded into a service nobody has touched since 2024, a spreadsheet of per-system exceptions, and a backlog ticket promising to reconcile them.

The EU AI Act turned that gap from uncomfortable into non-compliant. Article 14 requires that high-risk AI systems - credit scoring is explicitly on the Annex III list - be designed for effective human oversight. Article 12 requires automatic, decision-level record-keeping across the system's lifetime. Article 5 prohibits certain practices outright, including systems that exploit the vulnerabilities of specific groups, and carries the highest penalty tier in the regulation: up to 35 million euros or 7 percent of global turnover. None of those articles are satisfied by an inventory entry. They are satisfied by enforcement at the moment of decision, and by a record of it.

AI agents multiply the surface. Model governance assumed a model returns a score and human-built software decides what to do with it. Agentic AI collapses that distance: the agent drafts the denial letter, sets the payment plan, calls the API. Every agent action is a policy decision made at machine speed, which means agentic AI governance cannot live in a quarterly review - the check has to sit in the execution path, before the action, on every action.

So when the auditor asks the concrete question - show me that decisions above your high-risk threshold received human review - the documentation stack has no answer. The policy says 0.72, production says 0.80, and nobody can list the decisions that fell between. That is the moment teams discover that monitoring and enforcement are different products.

The enforcement layer
under your governance stack.

Governance platforms answer what AI you have and how risky it is. GoRules answers the runtime question: what is this model or agent allowed to do right now - and proves the answer, decision by decision.

01

Policy clauses become executable decision tables

The clause that lives on page 12 of the policy PDF becomes rows in a versioned decision table: risk score bands, decision types, model versions, customer segments in, an action and a clause reference out. Prohibited uses are rows too, so the ban is enforced by the same engine that routes the routine cases. Natural-language rendering means the compliance officer reads the same rule the engine executes, which ends the drift between what the policy says and what production does. Start from 70+ templates rather than a blank table, and let GoRules AI draft rule changes, run the tests, and explain any decision while you iterate - releasing stays a human act with an approval attached.

02

Runtime enforcement for every model and agent

Every model score and every agent action routes through the policy engine before it takes effect. The model proposes; the rules dispose: auto-approve, escalate to a human, or block, in under a millisecond, deterministically - the same inputs produce the same outcome every time, which is precisely what a probabilistic model cannot promise. AI agents pass through the same gate as models, so an agent that attempts a prohibited action is refused by policy, not caught by a dashboard three weeks later.

03

Human in the loop by rule, not by habit

Article 14 asks for effective human oversight, and effective means systematic: a rule that routes every decision above the threshold to a reviewer, with the score, the inputs, the model version, and the clause that routed it attached. No reliance on someone remembering to check, no oversight that quietly erodes as volume grows, and a queue you can point to when asked how oversight actually works.

04

An audit trail that reaches the individual decision

Every evaluation records which rule fired, under which policy version, approved by whom, tracing to which clause. Combined with git-like version control - branches, diffs, approval workflows - the AI audit trail runs unbroken from a regulation article through your policy clause to decision DEC-48311 on a Tuesday morning. That chain is the Article 12 record, the dispute answer, and the model governance evidence, all the same lookup.

Keep your governance platform.
Add the enforcement.

GoRules does not replace Credo AI, watsonx.governance, or whatever inventories and monitors your AI estate. They document and observe; GoRules executes the policy those documents describe.

01

Codify the clauses that matter

Take the enforceable sentences out of the policy document - review thresholds, prohibited uses, segment restrictions, model allowlists - and model each one as decision table rows with a clause reference in the output. The governance board reads the table in natural language and confirms it says what the policy says, before it ever touches production.

02

Wire enforcement into the decision path

Call GoRules over REST between the model or agent and the system that acts on its output, or embed the MIT-licensed open-source ZEN Engine with SDKs for Node.js, Python, Java, Go, C#, and Rust. The payload carries the score or proposed action, model version, decision type, and customer attributes; the response carries the action and the clause. Your governance platform keeps its inventory and monitoring role alongside.

03

Replay history to find the gaps

Run the last 90 days of model and agent decisions through the codified policy before it goes live. The replay tells you what the documentation never could: which decisions would have routed differently, whether any prohibited actions went through, and the exact size of the gap between the written threshold and the running one.

04

Operate and evolve with versioned releases

When the regulation or the policy changes, the update is a diff, not a project: edit the rule on a branch, replay history against it, collect the approvals, and promote through dev, staging, and production as an effective-dated release. Rollback is one click, and every version stays retrievable for the auditor asking about last March.

Built for production,
not proof of concept.

  • Sub-millisecond evaluation with the open-source ZEN engine (Rust core), fast enough to gate every model score and agent action inline without a felt latency cost
  • Git-like version control on every policy: branches, diffs, required approvals, and one-click rollback, so compliance changes ship with the same discipline as code
  • Deterministic by construction: the same decision inputs always produce the same outcome, the property regulators ask you to demonstrate and models cannot give you
  • Complete decision-level audit trail: which rule fired, under which version, approved by whom, tracing to which clause - retrievable for any historical decision. SSO, role-based access, SOC 2
  • Self-host with Docker or Kubernetes so decision data never leaves your infrastructure, or run on GoRules Cloud - and the core engine stays MIT-licensed open source, so the enforcement layer is never a black box

Questions, answered.

What is an AI governance platform, and how is enforcement different?

An AI governance platform manages the lifecycle around your AI systems: model inventories, risk assessments, policy documentation, bias and drift monitoring, and regulatory reporting. Those are records and observations about your AI. Enforcement is a different job: intercepting each individual model output or agent action at runtime and applying the policy to it - approve, escalate to a human, or block - before it takes effect. Governance tools tell you a model is high-risk and that a review policy exists; an enforcement layer is the mechanism that actually routes decision 48,311 to a reviewer because its score crossed 0.72. GoRules provides that layer as versioned decision tables evaluated in the decision path.

Does GoRules replace Credo AI, watsonx.governance, or our AI governance tools?

No, and it is not trying to. Platforms like Credo AI and watsonx.governance are the system of record for your AI estate: inventories, assessments, evidence packs, monitoring. GoRules sits in the runtime path they do not occupy, executing the policies those platforms document. The two are complementary by design - your governance platform holds the policy and the assessment trail, GoRules holds the executable version of the policy and the decision-level enforcement trail, and together they close the loop an auditor walks: from the documented control to proof it operated on every decision.

How does this help with EU AI Act compliance?

The EU AI Act asks for things that only exist at runtime. Article 14 requires effective human oversight of high-risk systems, which in practice means a systematic mechanism routing decisions to people, not a paragraph saying reviews happen. Article 12 requires automatic recording of events over the system lifetime, which means decision-level logs, not monthly summaries. Article 5 prohibits certain practices outright, which means a gate that refuses them, not a dashboard that flags them afterwards. GoRules gives you each mechanism as versioned, testable rules: review thresholds as decision table rows, prohibited uses as blocking rules, and a clause reference recorded on every decision. The legal obligations remain yours; GoRules supplies the enforcement mechanism and the evidence that it ran.

How do you govern AI agents, not just models?

Through the same gate. Agentic AI governance fails when agents get a separate, softer path than models, because an agent is just a decision-maker that acts on its own output. In GoRules, an agent's proposed action - send the letter, set the payment plan, adjust the limit - is evaluated by the same policy tables as a model score: inputs in, action and clause out, with the same thresholds, the same prohibited-use rules, and the same audit trail. The agent proposes and the rules dispose, which is the only posture that scales to systems acting at machine speed. Escalation rules put a human in the loop exactly where the policy says one belongs.

How deep does the audit trail go?

To the individual decision, and back up to the regulation. Each evaluation records the inputs, the model or agent version, the rule row that fired, the policy version it belonged to, and the clause reference carried in the output. Each policy version records its diff, its author, and its approvers. Chain those and you can answer the auditor's question as a lookup: this decision was routed to human review by row 3 of policy v4.2.0, approved by Jane Cooper, implementing clause 4.2, which implements Article 14. The same chain, replayed over history, is how you quantify a past gap instead of guessing at it.

Can we self-host for data residency and security review?

Yes. Deploy the full BRMS with Docker or Kubernetes inside your own network, so decision inputs, scores, and customer attributes never cross a vendor boundary - the deployment posture most banks and insurers require for anything in the credit decision path. The evaluation engine itself is the MIT-licensed open-source ZEN Engine, which your security team can read rather than take on faith, and it also embeds directly in your services via SDKs. SSO and role-based access control govern who can view, edit, and approve policies, and GoRules Cloud is available when managed hosting fits better.

The same engine,
next door.

One decision layer serves the whole institution - these use cases run on the same tables, versioning, and audit trail.

Deterministic AIRules where AI must not guessTransaction MonitoringAML rules on the same engineCredit DecisioningPolicy above your ML models

The model proposes.
Your rules dispose.

Codify one clause this week - your high-risk review threshold - wire it in front of one model, and replay 90 days of decisions to see exactly what your written policy would have changed.

Get started Book a demo