Rule-Bound Decisions,
Deterministic by Design.
Rules that evaluate symbolically — sub-millisecond, zero tokens, and identical every time. Constraints that block execution instead of annotating it. And a signed proof for every decision, so the answer holds up long after the conversation ends.
Free to start · No credit card required
Sub-10ms
Reflex evaluation
0 tokens
Per rule check
100%
Same input, same verdict
Signed
Per-decision proof
Decisions aren't a language problem
Some questions have a right answer that doesn't need a model to reason about it. Routing them through one anyway is where determinism, explainability, and margin all go missing.
The same case gets two different answers
Ask a model twice about the same applicant and you can get two verdicts. Nothing in the prompt pins the outcome, so a decision that should be reproducible isn't.
A decline you can't explain
When a customer asks why they were turned down, "the model said so" is not an answer your compliance team can sign, and it isn't one a regulator will accept.
A cost attached to every check
Every eligibility test, limit check, and threshold comparison routed through the model burns tokens. Rules that should be free are billed per evaluation.
Policy drift between prompt versions
Change a sentence in the system prompt and the effective policy quietly changes with it. There is no version number on a rule that lives in prose.
Rules nobody can find
The approval threshold exists somewhere — in a prompt, a spreadsheet, an engineer's memory. No one can list the rules that govern a given decision.
Guardrails that only advise
Prompt-level instructions to "never exceed $10,000" are a suggestion the model can reason its way past. A guardrail that can't stop execution isn't a guardrail.
Two cycles, one decision layer
Cognition splits in two. A cheap symbolic loop watches the rules continuously; the expensive neural loop fires only when a rule actually matches. Rules stay in charge of the answer — the model handles what rules can't express.
Reflex — symbolic
Runs every ~30 seconds
- Evaluates rule triggers against the live fact base
- Sub-10ms latency, zero token cost
- Deterministic — same facts, same verdict
- Runs forever without running up a bill
Reflection — neural
Fires only on a match
- Full agentic reasoning, on demand
- Triggered by a matched rule or a heartbeat
- Handles judgement, ambiguity, and exceptions
- Every reflection makes later reflexes smarter
How a governed call flows
logic.remember
Tool call asserts facts
logic.constrain
Triggers evaluated against the fact base
governor.status
Sub-10ms, zero tokens, deterministic
flow.into
Only on a match: full reasoning fires
What the rules layer is made of
Facts, constraints, and reusable rule modules — all queryable at symbolic speed, and all versioned as things you can point at rather than sentences inside a prompt.
Facts and namespaces
Store facts as natural language or structured triples. Every namespace is an isolated rule cell, so lending rules and pricing rules never see each other's facts.
Constraints that block
Define a constraint and it is checked before execution — a call that violates it is stopped, not annotated. Guardrails that can actually hold.
Installable rule modules
Pre-built rule packs install straight into a namespace and become queryable immediately, alongside your own facts. No schemas to write first.
Conditional routing
Route on the verdict — approve, decline, or escalate — with declarative predicates rather than branching logic scattered through application code.
Approval gates
Pause a workflow for human approval when a rule demands it. The decision waits; the trail records who cleared it and when.
Signed decision proof
Every validated workflow is sealed with a cryptographically signed certificate — proof the plan was cycle-free, type-safe, and policy-compliant before it ran.
A rule, end to end
The shape of it in practice — assert, constrain, query. No model in the path.
Assert the facts
{
"tool": "logic.remember",
"namespace": "lending-rules",
"facts": [
{ "applicant": "A-88213", "credit_score": 712, "dti": 0.34 },
{ "policy": "standard", "max_dti": 0.43, "min_score": 640 }
]
}Define the rule
{
"tool": "logic.constrain",
"namespace": "lending-rules",
"rule": "deny(approve(App)) :- dti(App, D), D > max_dti.",
"effect": "block"
}Query the verdict
{
"tool": "logic.query",
"namespace": "lending-rules",
"pattern": "eligible(App, standard)",
"result": {
"eligible": ["A-88213"],
"evaluated_ms": 0.8,
"tokens": 0
}
}Where rules do the deciding
Any decision with a right answer, a threshold, or an audit obligation — kept out of the model's path.
Eligibility and approval routing
Score, threshold, and policy checks decide the path; the model is called only for the cases that genuinely need judgement.
Coverage and underwriting rules
Eligibility tiers, exclusions, and risk bands evaluated the same way every time, with the rule that fired recorded against the decision.
Claims adjudication
Deterministic coverage checks first, exception handling second — so the routine majority never touches a token budget.
Transaction and spend limits
Hard ceilings enforced before execution, with an approval gate when a rule requires a human to clear it.
Discounting and pricing rules
Margin floors, approval tiers, and exception windows held as constraints rather than as instructions the model may reinterpret.
Fraud and risk thresholds
Fast symbolic screening on every event, escalating to reasoning only when a threshold is crossed.
Entitlement decisions
What a customer is entitled to, decided from facts and contract terms — not from a model's reading of the contract.
Regulatory and audit rules
Jurisdiction rules, reporting obligations, and disclosure requirements expressed once and enforced everywhere.
Rules that cost nothing to keep checking
Continuous vigilance is only affordable when the watching is symbolic. The model is reserved for the cases that earn it.
~$30
Symbolic reflex cycle
100 conditions over 8 hours
~$225
Pure-LLM equivalent
The same 100 conditions, reasoned every cycle
< 10ms
Rule evaluation
Per reflex pass
0
Tokens per rule check
No model in the path
Figures from the continuous-cognition model behind Governor and the AI cost optimization benchmarks.
Who it's for
The same layer, read four different ways.
Architect
A rules layer that composes with the systems already in place — versioned modules, isolated namespaces, and no rewrite of the engine you already own.
Engineering Manager
Deterministic behaviour stops being a property you hope for. The rule that decided is inspectable, so defects have an address.
GRC & CISO
Enforceable constraints, per-decision proof, and a trail that shows which rule fired — evidence rather than assurance-by-assertion.
Operations & Compliance Owner
Business policy changes land as a rule change, not a prompt rewrite — reviewable, attributable, and reversible.
Keep the engine you already run
If you already operate a decision-table or enterprise rules engine, this doesn't ask you to retire it. It gives the agent side of your estate the same discipline — facts, versioned rules, enforceable constraints — and hands the settled decisions to the engine you already trust.
Your existing engine
Alongside DataGrout
Rules over rows in a database
Rules over facts an agent just asserted
Decisions triggered by application events
Decisions triggered by agent tool calls and workflow steps
The engine owns the decision
The rules layer governs the decision; the model handles what rules can't express
Audit lives in the engine's own log
Every decision carries a signed certificate alongside the receipt
Migrate one rule set at a time
Namespaces are isolated, so a single decision domain — lending, pricing, entitlements — can move across and prove itself before anything else follows.
Keep your decision tables
Rules that are already settled and stable can stay where they are. The layer handles the decisions that sit next to agents and workflows.
Change rules without a release
Facts and constraints are data, not code — so policy changes land as versioned rule edits, attributable to whoever made them.
Decisions that hold up afterwards
The evidence is produced by the system as it runs, not assembled by hand when someone asks for it.
Encrypted at rest
Facts and extracted rule state are encrypted with AES-256-GCM, scoped per user and per namespace.
A receipt per call
Every evaluation returns a structured receipt — cost, component breakdown, and the cache reference — so spend is attributable to the decision that caused it.
Redaction on the boundary
PII is detected and masked before it reaches the agent, with per-field strategies and server-to-integration policy cascade.
Signed, not asserted
Validated workflows carry an Ed25519-signed certificate attesting the plan was cycle-free, type-safe, and policy-compliant before execution.
Facts come from the systems you already run
Every integration on the gateway can feed the rule base — so a decision can be made on live business data rather than on whatever happened to fit in a prompt.
Frequently Asked Questions
Common questions about running a rules layer next to your agents.
Keep going
Logic — symbolic memory
The tool underneath the rules layer: facts, namespaces, constraints, and goal-driven context assembly.
Batteries — rule modules
Pre-built rule packs that install into any namespace and become queryable immediately.
Governor — continuous cognition
The reflex and reflection cycles that keep rules watching without burning tokens.
Enterprise AI Agent Governance
Who may act, under what policy, with what approval — the layer above the decision itself.
Responsible AI Tools
Operational assurance for agent behaviour: guardrails, verification, and proof of safe execution.
AI Data Governance
Audit trails, lineage, and regulator-ready evidence across the data an agent touches.
See the rules layer decide
Walk through a governed decision end to end — facts asserted from your systems, constraints evaluated symbolically, the model called only when it earns the call, and a signed certificate at the end of it.
Book Your DataGrout Demo
See real-time cost visibility, budget controls, and audit trails — tailored to your enterprise stack.