AI Rule Engine turns your business logic into governed, auditable workflows — authored in a decision table, powered by any AI model you choose, and safe for AI agents to trigger. Explore the full feature set below, from forward-chaining inference and explainable run traces to human approvals, an expression language, and an MCP server for AI agents.
Every run can produce a full inference trace: which rules fired, in what order, why each condition matched on the actual values it saw, and every context change from old to new. Decisions are pinned to the published version that produced them, and each publish is signed so the logic in force on a date can be proven unchanged.
Rules run the same way every time. There is no now() or random() in expressions, re-evaluation keys off real value changes, and AI results are remembered for unchanged inputs, so tests, audits, and billing all stay trustworthy.
AI Rule Engine is the control layer between AI intent and real execution. Pause a workflow for human approval, scope exactly what each AI agent may do, and keep a logged history of every decision.
Mix Anthropic, OpenAI, Azure OpenAI, Google Gemini, and xAI Grok inside one workflow, using your own provider keys. AI turns unstructured input into facts. Rules you wrote decide what those facts mean, so no model ever applies a threshold or picks an outcome.
See exactly why a run produced its result, test rules safely before production, and simulate how a change would ripple through your logic.
A complete, readable account of a run: a timeline of every firing with iteration badges and "triggered by" chips, a green/red "why it matched" condition tree showing the real values each clause saw, a table of every context change, and derived-fact and event sections.
A goal-driven run records how each answer was reached: the goal, every candidate rule considered for it, what came of each one, and the sub-goals their premises spawned nested underneath. Read down, it answers how a value came to be. When a goal cannot be established the tree turns red and the deepest node names the input that was actually missing, so a run that produced nothing explains itself instead of leaving you to guess.
Turn any trace into a plain-language explanation. Pick a provider and model, optionally ask a specific question, and get an answer grounded in the actual trace rather than a guess.
Open the What-if panel seeded with a run’s inputs, edit them, and compare. See which rules now fire or stop firing, which conclusions changed, and a "why it changed" provenance chain traced back to the input you edited.
Tests and what-if runs execute in a sandbox: no external actions fire, nothing is written to real systems, runs are unmetered, and AI-prompt conditions can use mocks or opt in to live AI.
Test runs are always traced for fast debugging while you author. Enable Record run traces to capture the same detail on production runs, visible in run history and what-if comparisons.
Because runs are reproducible, a passing test is a durable statement about behavior you can gate a release on — regression testing for business rules.
See how often every rule actually fires in production, ranked, as a share of the runs that evaluated it. Fired, evaluated, skipped, and total activation counts sit beside each rule, so a rule at 0% tells you whether its condition never matched or the rule was switched off or outside its date window.
Name the context keys that hold a RuleSet outcome and see how often each value comes out, as a chart plus a written breakdown of value, count, and share. A RuleSet exposed as an MCP tool uses the outputs it already declares, so its decisions are charted with no setup. Secret values are never recorded.
A per-environment Analytics page with run counts by day split by outcome, success rate, duration range, and how many rules never fired. Filter by project, RuleSet, and a window of the last 7 to 90 days. Counters are rolled up as runs finish rather than scraped from logs, so the numbers stay fast and exact.
An opt-in production rule engine where rules react to their own results, cascading small decisions into a final one without you scripting the order. Run it in the other direction too: name the answer you want and it works backwards, firing only the rules that answer actually needs.
Turn on inference per ruleset and rules re-fire as their actions change the facts other rules read. It is the classic production-rule-engine model — a modern, decision-table-authored alternative to tools like Drools — with the ordering handled for you.
Name the context keys a run should establish and the engine works backwards from them, firing only the rules needed to produce the answer. A rule that cannot contribute to a goal is never evaluated, so it never runs and its conditions are never billed. Leave the goals blank and your decision keys are used. Turn on the follow-on cascade and the run continues into normal forward chaining once its goals are resolved, sharing one trace, one activation cap and one firing history so nothing fires or bills twice.
The goals set on a ruleset are a default, not a commitment. Override them for a single run from the runner or from an API parameter, so one set of rules can answer eligibility for one caller and pricing for another without being edited or duplicated.
Give any rule an integer priority so the most important rules fire first under inference. Ties break by row position, and salience is shown as a row badge and ignored outside inference.
The engine re-evaluates only the rules that read keys which actually changed, and a rule will not re-fire unless its inputs changed. Cascades converge on a stable, repeatable state instead of looping forever.
Every inference run has a maximum activation count (default 500, configurable) that halts runaway write/read loops with a clear warning.
Mark a rule as retractable and its conclusions hold only while the rule still matches. When the facts behind a decision move, the decision is withdrawn automatically, and anything derived from it is withdrawn too, so a conclusion never outlives the inputs that produced it. Support is counted, so a value backed by two rules survives losing one, and every withdrawal appears in the trace beside the firing it undoes.
An entire cascade of firings counts as a single metered run, and AI-prompt conditions are not re-billed when their inputs have not changed — so billing stays predictable.
Keep people in control of automated decisions with review checkpoints, approvals, versioning, and audit trails.
Pause an automated workflow, present a custom form to a person, and collect their response before continuing. The response becomes a first-class part of the automation you can route on — approvals, rejections, rationale, or missing details.
Standardize approval flows — pricing exceptions, policy changes, vendor onboarding, escalations — with the right conditions, routing, and follow-up actions, reusable through templates and extensions.
An approval form is answered by a signed-in member of your organization, in the environment that raised the request, and the decision is recorded against the person who made it. A forwarded link no longer lets an outsider sign off on anything, and the run history still names the approver months later without anyone hunting for the email that carried the link.
Version management, logged execution history, and audit trails give you accountability and real-time insight for compliance and efficiency.
Control who can do what with role-based user access, included on every plan.
Bring your own identity provider, decide exactly who can see and do what, and keep a tamper-evident record of every change. Everything a security or compliance review asks for is built in, from sign-in policy through to approval-gated releases, backups, and long-term evidence.
Connect your own OpenID Connect or SAML 2.0 identity provider so members sign in with corporate credentials instead of personal social logins. Domain ownership is verified through DNS before enforcement can be switched on, so nobody can claim a domain they do not control. SAML accepts multiple signing certificates at once, which means you can rotate a certificate with zero downtime.
A filterable, exportable record of every change to rules, releases, access, and credentials across your organization, including the attempts that were refused. Export to CSV or JSON, or stream events to your own security tooling such as Splunk in near real time. When an auditor or an incident asks what happened, the answer is already recorded.
Define fine-grained, additive roles beyond the built-in set, including a separate "View PII values" permission so an operator can see exactly which rules fired without ever seeing the underlying customer data. A point-in-time access review, exportable as CSV or JSON, answers "who could access what, and when" without anyone assembling a spreadsheet by hand.
Require multi-factor authentication, cap idle timeout and total session length, and limit how long an API key or MCP token may live before it must be renewed. Enterprise organizations can restrict the control plane to an IP allowlist, with a built-in safeguard that stops an administrator from locking themselves out while configuring it.
Issue scoped machine credentials for CI pipelines and services, managed separately from project-level API keys. Each key can be pinned to a single environment, granted only the permissions it actually needs, and given an expiration that the organization credential lifetime policy enforces. Automation gets exactly the access it needs and nothing more.
Snapshot a project into an immutable, numbered release and promote it stage by stage across environments through an approval-gated pipeline you define. Four-eyes enforcement means no single person pushes to production alone, and an organization-wide dashboard shows at a glance which stage every project is sitting on so nothing silently falls behind.
Nightly backups of your entire organization - projects, rulesets, conditions, action sets, and tests - written to storage you own. Restore on demand when you need to, with a safeguard that refuses to silently overwrite a project already running in production.
Removing someone’s account clears their name and email address and unlinks every way they signed in, without touching what they did. Their past approvals, edits, and runs stay exactly where they were and read as a deleted user from then on. A right-to-erasure request and an unbroken audit trail stop being a choice between two obligations.
A daily, write-once copy of the audit trail and release evidence, written to immutable storage you control and retained for seven years. It is built to be shown to an auditor rather than restored from, so the retention guarantee comes from your own storage policy instead of a promise from a vendor.
A DMN-style decision table where every rule is a row and every context key is a column, so the whole ruleset is readable at a glance.
Author rules as rows and conditions as columns, IF on the left and THEN on the right, with the entire ruleset visible at once and no dialogs required for most edits.
Type conditions directly in a cell in plain shorthand — >= 1000, not empty, contains "priority", starts with "INV-", > 5 and <= 20, or a regex — with in-place validation. Complex logic opens a full condition editor.
Set Match First, Match N, Match All, Inference, or Goal-driven from a toolbar badge, with shuffle and parallel toggles alongside it and the goals box appearing where it applies.
The editor flags duplicate rules and rules that can never fire under a First policy with row icons and toolbar summaries — advisory linting that never blocks you.
A Verify tab that reads your ruleset instead of running it and reports what is wrong: rules that can never fire, conditions that contradict themselves, rules made unreachable by the match limit, duplicates recognized by meaning rather than wording, two rules writing the same key different values, missing references, and context keys nothing supplies. Findings are ranked Error, Warning, or Info, they reflect your unsaved edits, and any check that cannot answer honestly reports itself as skipped instead of passing quietly. Nothing executes and nothing is metered.
Verification also answers the question a decision table invites: have I handled every case? It works out which combinations of input values no rule matches, describes each one in your own vocabulary, and shows them in the table as the "Not covered" rows you are missing, right where they would sit.
Verification understands goal-driven rulesets too. It reports a goal nothing can establish as an error, because every run would come back with it unproven, and warns about a rule whose written keys cannot be known without running it, since the backwards search cannot see it. It also catches a goal-driven ruleset with no goals at all, and retractable rules whose conclusions can never be taken back.
Drag to reorder, move to top or bottom, enable or disable a rule without deleting it, duplicate a row, rename inline, and set per-rule execution options like randomized or parallel actions.
Give any rule an active date window so a policy switches on or off by itself - schedule a price change weeks ahead, or retire a promotion at midnight on its last day. Set either bound or both; outside the window the rule is skipped exactly like a disabled one, and the rule list flags what is scheduled, live, or expired.
Match a condition with a natural-language AI prompt instead of only standard operators, usable in rules and derived-fact guards and mockable in tests and what-if.
Model sophisticated decisions — loan eligibility, cashback tiers, engagement programs — with nested if-then logic and reusable named condition sets.
Compute values, define shared business terms once, and reason about whole arrays in a single clause.
A small, deterministic expression language you can use anywhere a value goes — condition compares, derived facts, add-to-context, action inputs. Read context with ctx.key, use $variables, arithmetic, logic, and ternaries, with live inline validation.
String, math, date, array, and conversion functions — len, round, dateAdd, sum, coalesce, and more — with null-safety so missing values propagate cleanly instead of crashing a run.
Compute context values on demand from other values instead of supplying them as input. Each fact has a source (context, env var, constant, or expression) and an optional guard, is resolved lazily, and is re-derived automatically under inference when inputs change.
Reason about an entire array in one clause. Aggregates (count, sum, average, min, max) reduce an array to a scalar before comparison; quantifiers (any, all, no element) test every element — one clause instead of a loop.
Compose rulesets, actions, and AI steps into workflows visually, and generate a working project from a prompt.
Open a workflow branch as an interactive canvas of rulesets, rules, action sets, and downstream rulesets. Pan, zoom, re-layout, focus a nested ruleset as root, and edit nodes in place with draft-first saving.
Describe what you want to automate in natural language and the AI generates a complete project — rulesets, rules with conditions, and actions — as a standard project or a reusable template. No blank canvas.
Build structured JSON or XML payloads — roots, elements, attributes, namespaces — inside a rule flow and save them to context for downstream steps, partner interfaces, and legacy integrations.
Actions, expressions, and derived facts can write values to the workflow context so later rules can read them — the shared state that drives chained decisions.
Rules depend on named, reusable action sets, and nested rulesets branch into downstream logic — composable building blocks you assemble across a workflow.
Call a ruleset synchronously and get the decision back in the same HTTP request, so a checkout, an application screen, or a fraud check can act on it immediately instead of polling for a result. You declare the inputs callers may send and the outputs they get back, and everything else the run computed stays internal. Static verification confirms up front that nothing in the ruleset pauses for a human or an external callback, and the engine refuses to hand back a half-finished answer if one is ever reached. Synchronous calls are recorded in run history and analytics like any other run. For consistent low latency, run them on a dedicated environment.
First-class support for the major AI providers, with rule-driven model routing to balance quality, speed, and cost.
Select a model directly when configuring an AI step — Anthropic Claude, OpenAI ChatGPT, Azure OpenAI, Google Gemini, and xAI Grok are supported natively, with no custom connector to build.
Mix multiple models and providers inside a single workflow, choosing the best-fit model for each step. Rules decide which model handles which task, enabling hybrid and fallback paths and avoiding vendor lock-in.
Route simple, structured tasks to smaller, cheaper, faster models and reserve flagship models for complex reasoning — so you stop paying for tokens you don’t need.
Paired with dedicated Azure hosting, Azure OpenAI calls go to your own resource under your tenant’s networking, identity, and compliance — prompts and outputs never leave your cloud boundary.
Let AI assistants trigger your governed workflows through a Model Context Protocol server — with least-privilege permissions per agent.
Stand up your own Model Context Protocol server in minutes so AI assistants like Claude, Cursor, and ChatGPT can initiate workflows, read approved files, and inspect run logs — a controlled bridge from natural-language requests to real automation. Included on every plan.
Scope each AI instance individually — which workflows it can start, which files it can read, whether it can see run logs, and which tools it can use — so every assistant runs with least privilege.
When a workflow pauses for human review, an assistant connected over MCP can read the pending form and submit your answers on your behalf — you decide in the conversation, the agent carries it the last mile, and the workflow resumes with the result. A per-action switch keeps web-link-only approvals available for decisions that must be made in person.
Connect to databases, APIs, and cloud platforms for real-time decisioning, and reach modern APIs, legacy platforms, and partner systems through actions.
Trigger and manage workflows programmatically through secure APIs, included on every plan.
Package reusable logic into no-code building blocks, standardize how projects start, and share it all through the marketplace.
Package validations, shared workflow steps, common integrations, and repeatable decision logic into building blocks you create, apply, and share across projects and teams — no code required.
Design an extension’s experience with a rich-text editor: formatted instructions, embedded screenshots and diagrams that travel with the extension, input fields, and conditional visibility.
Capture input with text fields, dropdowns, radio buttons, checkboxes, and sliders, and show or hide groups of fields based on a user’s selection so one extension handles multiple modes.
Save a proven project as a reusable template, create new projects from it with the workflow already in place, and publish templates to the marketplace to standardize how work starts.
Publish and discover templates and extensions, organized by the owning organization so you can browse a team’s entire published ecosystem in one place.
Start free on a shared host with no cloud setup, or run a dedicated host inside your own Azure subscription.
Run your virtual environments on AI Rule Engine’s managed infrastructure with no Azure subscription required. Free, Pro, Team, and Enterprise plans scale by ruleset run volume, and run overage is auto-billed via credits so automations never hard-stop.
Deploy AI Rule Engine into your own Azure subscription with automated provisioning. The Enterprise plan lets you run up to 3 of your 50 environments as dedicated hosts, with network isolation, unlimited file storage, data that never leaves your cloud boundary, and runs that are never metered.
Organizations own projects, templates, and extensions, and environments live at the organization level so multiple projects can share one — reducing environment sprawl and cost.
Hand an organization to another member without losing continuity. The current owner picks a member who has signed in, confirms, and ownership moves immediately; the outgoing owner stays on as an admin. People leave teams, and an organization should never be stranded behind an account nobody uses any more.
Business users can read decision tables and author rules in minutes, while power users reach for expressions, inference, and the API — no coding required to get started.
AI Rule Engine is a no-code/low-code platform for building governed, auditable business-logic workflows. You author rules in a decision table, optionally call AI models inside those workflows, and let AI agents trigger them through MCP with the exact permissions you grant.
Yes. Business users can build and read rules in a decision-table editor without writing code. Power users can add computed expressions, forward-chaining inference, derived facts, and programmatic API access when they need more.
AI Rule Engine natively supports Anthropic Claude, OpenAI ChatGPT, Azure OpenAI, Google Gemini, and xAI Grok. You can mix multiple models and providers in a single workflow and route each step to the best-fit model.
Forward-chaining inference is an opt-in mode where rules re-fire as their actions change the facts other rules read, cascading small decisions into a final result without you scripting the order. Salience sets rule priority, and the engine converges on a stable, repeatable state.
Yes. Every plan includes a Model Context Protocol (MCP) server so AI assistants can initiate workflows, read approved files, and inspect run logs. You scope each agent with least-privilege permissions.
Yes. When a workflow pauses for human review, an assistant connected over MCP can read the pending form and submit your answers on your behalf, resuming the workflow. Each human intervention step has an "Allow AI agents to submit" switch (on by default), and agent submissions honor the form link’s expiry and use limits.
Yes. Any run can produce a full inference trace showing which rules fired, why each condition matched on the actual values, and every context change. You can turn a trace into a plain-language explanation with AI, and version management plus audit trails keep a logged history.
Yes. Tests and what-if simulations run in a sandbox with no side effects and no metering. Because runs are deterministic and reproducible, a passing test is a reliable release gate.
Open the Verify tab. It reads the ruleset without running it and reports rules that can never fire, duplicated rules, two rules writing the same key different values, references that no longer resolve, context keys nothing supplies, and combinations of inputs no rule covers. Findings are ranked by severity, and any check that cannot answer honestly reports itself as skipped rather than passing quietly. Verification catches the contradictions a passing test cannot see, so use it alongside test cases rather than instead of them.
Yes. Each environment has an Analytics page showing how often every rule fires as a share of the runs that evaluated it, alongside how many runs were skipped because a rule was disabled or outside its date window. Name the context key holding a ruleset outcome and you also get the distribution of that decision across every run, plus run volume, success rate, and duration by day. Counters are rolled up as runs finish, so the numbers are exact rather than sampled from logs.
Yes. Connect your own OpenID Connect or SAML 2.0 identity provider so members sign in with corporate credentials. You verify domain ownership through DNS before enforcement can be switched on, and SAML accepts multiple signing certificates so you can rotate one without downtime.
Yes. Every change to rules, releases, access, and credentials is recorded, including refused attempts, and the log is filterable and exportable to CSV or JSON. You can also stream events to your own security tooling, such as Splunk, in near real time.
Shared environments run on AI Rule Engine’s managed infrastructure. The Enterprise plan can deploy up to 3 of your environments as dedicated hosts into your own Azure subscription, where Azure OpenAI calls and your data never leave your cloud boundary.
Start free on a shared host, or deploy a dedicated environment in your own Azure subscription. No credit card required to begin.