v2.0

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

Watch the launch videoWatch

A decision engine that
shows its reasoning.

A decision engine takes your rules and your data and returns a decision with the reasons that produced it. GoRules is that engine on an open-source core: visual decision tables the policy owners edit themselves, sub-millisecond evaluation, and a versioned trail behind every outcome.

From waiting on approval
to approved on submit.

Watch one $240,000 renewal move through a live decision graph: request in, knockouts, the discount table, pricing, response out in 0.6 ms. Then a one-cell change to that table, a replay over the quarter's 940 quotes, a signed release, and the same request coming back auto-approved.

scroll to play
One request

A quote hits the engine.

Meridian Health, a $240,000 enterprise renewal at 18 percent off, arrives as one JSON payload and enters the decision graph that every channel calls.

First pass

Answered in 0.6 ms. Still parked.

Knockouts clear, the discount table matches row 2, pricing holds - and the response comes back requires VP approval. The margin is 68 percent, six points clear of the floor. The table only knows that 18 is more than 15.

One cell

The node that decided opens.

The rule named in the response is the rule you edit. Enterprise auto-approve moves from 15 to 20 percent on a branch, and the 62 percent margin floor stays exactly where it was.

Proof before production

The quarter's 940 quotes replay.

Every quote booked this quarter re-runs against the draft while you watch: 210 would have auto-approved, none below the margin floor, non-standard terms still routed to the deal desk.

Sign-off

Revenue ops approves. v1.4.0 ships.

Jane Cooper signs the release, it promotes through staging to production with the full trail recorded. Rollback stays one click away.

Same request

Same graph. Different answer.

The identical payload replays, the path lights all the way through, and the response comes back auto-approved in 0.6 ms with the reasons attached. Live traffic follows: 210 quotes flip, and the one asking 28 percent still stops at the margin floor.

The logic is everywhere.
The reasons are nowhere.

A decision engine is easy to describe and hard to find inside a real codebase. Rules and data go in, a decision and the reasons behind it come out. In most products that shape exists only on the whiteboard: the eligibility cutoff sits in one service, the pricing rule sits in another, the exceptions live in a spreadsheet somebody maintains by hand, and nobody can point at the thing that decided.

Hardcoded logic is fine right up until the logic starts changing. Then every threshold move becomes a ticket, a sprint, and a release window, and the people who own the policy, risk, pricing, operations, compliance, are the only people who cannot touch it. The same rule gets copied into a batch job, a mobile backend, and a partner API, and the three copies drift apart quietly.

The market's answer has been the enterprise decisioning platform. Those suites work, but they arrive as six to eighteen month implementations, bundle data marketplaces and bureau connectors you already pay for elsewhere, and mostly run only in the vendor's cloud, which is an awkward conversation when the decisions touch regulated customer data.

And the questions that actually matter still go unanswered. Why did this customer get referred instead of approved? What happens to volume if we move the cutoff five points? Who approved the version that was live last March, and can you reproduce it on demand?

One place where
the deciding happens.

A decision engine pulls decision logic out of application code. Your services send data, the engine returns the outcome and the rules that produced it.

01

Rules and data in, a decision and its reasons out

Every decision has the same shape: a structured request carrying an application, a transaction, a cart, or a claim, and a structured response carrying an outcome plus how it was reached. In GoRules you model that as a decision graph. Decision tables cover the spreadsheet-shaped parts, Policies model shared definitions as ordered blocks the engine sequences for you, ZEN expressions handle derived values like ratios and rolling windows, and typed TypeScript function nodes cover anything genuinely custom. Model scores, screening hits, and third-party data enter as plain inputs, so the outcome stays a readable rule result instead of a number nobody can defend.

02

The people who own the policy own the rules

Decision tables are spreadsheet-shaped on purpose, and natural-language rendering makes each row read the way the policy document does, so an analyst can write a rule an auditor can check. Every change lands in git-like version control with branches, commit history, change requests, approvals, and one-click rollback, then moves through dev, staging, and production as an explicit release. GoRules AI can draft a rule change, run the tests, create graphs, and explain what a decision did. Releasing stays a human decision with a name on it.

03

Runs where your data already lives

The evaluation core is the open-source ZEN Engine, MIT licensed with a Rust core, embeddable through SDKs for Node.js, Python, Java, Go, C#, Rust, Kotlin, Swift, and WebAssembly. Run the full BRMS self-hosted with Docker or Kubernetes on AWS, Azure, or Google Cloud, put the Agent in front of it as a hot-reloading REST endpoint, drop the engine into a serverless function, or use GoRules Cloud. Decision data never has to cross a boundary you did not choose.

From hardcoded to
governed, in four moves.

Nothing about your data platform, your models, or your product changes. Only the place where decisions are made moves.

01

Connect

Call GoRules over the REST API from whichever service holds the logic today, run the Agent next to it for hot-reloading evaluation, or embed the engine in-process with an SDK when you want zero network hops. One decision at a time is a fine migration path, and the request payload is simply whatever your rules need to see.

02

Model

Rebuild the decision as a graph instead of a branch tree: knockouts first, then the tables that carry the real matrix, then the calculations. If you have not modeled decisions this way before, the business rules engine primer covers the vocabulary, and the template library gives you a working starting point per industry.

03

Test and simulate

Run historical cases through the simulator, check test coverage and static analysis before anyone signs off, and branch a challenger to compare it against the live policy on the same inputs. Stakeholders review the natural-language rendering of each rule, not the JSON underneath it.

04

Operate

Promote through environments with approvals recorded at each step, evaluate in production in well under a millisecond, and keep every decision linked to the rules that fired. When conditions move, the policy owner edits a cell and ships the same day, and rolls back in one click if the numbers disagree.

Built for production,
not proof of concept.

  • Sub-millisecond evaluation on the open-source ZEN Engine (Rust core), embedded in your services or called over REST, fast enough to sit inline in a checkout or a payment path
  • Git-like version control on every decision: branches, commit history, change requests with approvals, and one-click rollback across dev, staging, and production
  • Self-host with Docker or Kubernetes on AWS, Azure, or Google Cloud so regulated data stays inside your perimeter, or run GoRules Cloud when managed hosting is simpler
  • A complete audit trail: which rules fired on any decision, and who changed what, when, and with whose approval. SSO, role-based access control, SOC 2
  • No lock-in: an MIT-licensed core, SDKs across eleven languages, and 70+ industry templates covering lending, insurance, healthcare, retail, and public sector decisions

Questions, answered.

What is a decision engine?

A decision engine is software that evaluates rules against data and returns a decision, usually with the reasons that produced it. The shape is always the same: a request goes in carrying whatever the decision needs, the engine applies logic that lives outside your application code, and an outcome comes back in real time, typically approve, decline, refer, price, or route. What makes it an engine rather than a function is that the logic is a managed asset: versioned, testable, editable by the people who own the policy, and auditable long after the fact. GoRules provides that as visual decision graphs and decision tables running on an open-source evaluation core.

What is the difference between a decision engine and a rules engine?

In practice the terms overlap, and vendors use them interchangeably. The distinction people usually mean is one of scope: a rules engine executes a set of if/then rules, while a decision engine or decisioning platform is the system around it, orchestrating several rule sets and data sources with simulation, versioning, environments, approvals, and an audit trail. GoRules is both halves, and they are separable. The MIT-licensed ZEN Engine does the evaluating and embeds on its own, while the BRMS around it handles authoring, testing, version control, and multi-environment releases.

When do you need a decision engine instead of hardcoded logic?

Hardcoded logic is the right answer when the rules are few, stable, and owned by the engineers who wrote them. You have outgrown it when the same rule is copied across more than one service and the copies drift, when business teams file tickets to change thresholds they own, when you cannot explain why an individual case got the outcome it did, or when you cannot show who approved the version that was live on a given date. The clearest tell is cadence: if policy changes weekly and your deploys are quarterly, the logic belongs outside the code. Moving one decision out is usually enough to prove the point.

How does a decision engine work with machine learning models?

Model output enters the decision as an input, not as the decision itself. Your model emits a score, a probability, or a classification, and the engine decides what to do about it: where the cutoff sits, which cases are knocked out before the score is consulted, who gets referred to a person, what price or limit applies. That separation is what keeps the outcome explainable, because it traces to readable rules rather than to a score alone, which matters under GDPR Article 22, the EU AI Act's high-risk classifications, and internal model risk review. GoRules supplies the traceability; the compliance obligations remain yours.

Can a decision engine run in our own infrastructure?

Yes. Run the BRMS self-hosted with Docker or Kubernetes on AWS, Azure, or Google Cloud, and put the Agent in front of it for a high-performance REST endpoint with hot rule reloading. If you want evaluation in-process with no network hop at all, embed the open-source ZEN Engine directly through the Node.js, Python, Java, Go, C#, Rust, Kotlin, Swift, or WebAssembly SDKs, so decision data never crosses a vendor boundary. SSO and role-based access control govern who can read or change rules in either setup, and GoRules Cloud is there when managed hosting is the simpler answer.

The same engine,
next door.

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

Rules in. Decisions out.
Reasons attached.

Pick the one decision that changes most often, model it as a table in the visual editor, and point the service that owns it at the REST API this week.