RIC legality demo

Deterministic legality gate in front of any decision engine.

This demo shows RIC running as a legality gate in front of a stochastic text model. The model can propose anything; RIC applies hard rules and either lets an answer emit or halts it, with a replayable proof of what happened.

The downstream model (Anthropic, OpenAI, or another provider) is swappable. For the same inputs, the legality decision stays fixed and replayable bit-for-bit.

Open legality demoTry RIC-STEM engine

1. What the user sees

In the UI you type a prompt: a legal question, a policy request, or any free-text query.

  • You write a question and hit send.
  • The underlying text model proposes one or more draft answers (its normal stochastic behavior).
  • RIC evaluates those drafts against a set of rules and returns:
    • a PASS banner with hashes and a run ID, or
    • a HALT banner with a deterministic explanation.

2. What RIC does under the hood

The legality demo runs on the same Q32 deterministic substrate as RIC-STEM:

  • The app sends the model’s candidate answer to RIC via POST /run.
  • RIC runs its legality stack: claim structure checks, contradiction tests, and temporal rules (for example, policy or case-law cut-off dates).
  • If the answer passes, RIC emits it together with a deterministic proof bundle; if not, RIC halts and no model output is allowed through.

No floats. No timestamps. No randomness. Same request + same model output → same legality decision and bundle, across machines.

3. Why this matters

  • Auditability: every decision is stored as a bundle with trace steps, legality reasons, and hashes. You can replay it later and get the same result.
  • Separation of powers: stochastic generation stays on the model. Deterministic legality stays on RIC, with a provable boundary between them.
  • Safety & compliance: encode rules that must never be violated (coverage windows, timing, jurisdiction limits, red-line clauses).
  • Control: wrap your existing model in a deterministic gate you own, version, and test like any other critical service.

4. Integration sketch

The same pattern can be wired into your product:

  1. Your app calls your text model as usual.
  2. Instead of returning that answer directly, your backend wraps it in a RIC /run call with your legality rules.
  3. RIC returns either:
    • a legal answer + proof bundle, or
    • a halt signal with a deterministic explanation.

This demo shows a narrow, text-focused surface of a broader legality stack that can govern other decision channels as well.