The rule, applied to the case.

Praxis interprets a conditional rule of law, traces it through the chain of modifiers that govern it, applies the facts of a specific case, and produces a defensible, citable computation.

STATUS — IN DEVELOPMENT

The Problem

The law is not a lookup.

A rule rarely gives one fixed answer. What it produces depends on a chain of conditions — how a matter is classified, what has already happened, which exceptions apply, which periods count and which are set aside — and on the specific record of the case in front of you. The same statute yields a different result for two cases that differ in a single fact.

The usual way to handle this in software is to write the rules directly into the code, as nested conditions. That makes the rules hard to see, hard to change, and hard to trust: when the law changes, an engineer has to find and rewrite the logic, and no one outside the codebase can check whether it is right. Working the chain by hand has the opposite problem — it is slow, and easy to get wrong in ways that are hard to catch.

Either way, the answer still has to be defensible: not just a date or a number, but a result that can be traced back to the rule and the facts it was computed from, and stood behind under scrutiny. That is the problem Praxis exists to solve.

What It Does

Conditional rules, applied to an individual case.

Praxis takes a rule expressed as a formal set of conditions, the modifiers that can change its result, and the record of a specific case. It traces the rule through those conditions against the facts of the case and computes the result the rule produces — with the path from rule and facts to result preserved.

The rules are an input, not part of the code. They are written and maintained as a configurable, readable layer, separate from the engine that runs them — so when a rule changes, the rule is what changes, not the software.

Fig. 03 — Praxis pathRULE + CASE → TRACE → COMPUTE → RESULT

The result has three properties a hand computation usually cannot guarantee.

It is conditional, in full.

The complete chain of modifiers is applied — classifications, exceptions, set-asides, the periods that do and do not count — not approximated or shortcut.

It is individualized.

The computation runs against the record of a specific case, not a generic template. Two cases that differ in one fact get two correct, different results.

It is defensible.

The output is not just an answer. The rule it applied and the facts it relied on travel with the result, so the computation can be cited and checked.

Guarantees

What the core guarantees.

Traceable to the rule.

Every result carries the rule it applied and the facts it relied on. A result that cannot be traced back to both is not emitted.

The full conditional chain.

The modifiers that govern a rule are applied completely, not approximated. Where a condition cannot be resolved from the case record, that is surfaced rather than assumed.

Individualized, not templated.

The computation is performed against a specific case record. The engine does not return a generic answer dressed up as a specific one.

Domain-agnostic by construction.

The core computes from rules and facts, not from any one body of law. The rules it applies are an input, which is what lets the same engine serve different legal and regulatory domains.

Integration

Where the core begins and ends.

Praxis begins with a rule already expressed as a formal set of conditions, and a case record to apply it to. How a body of law is interpreted and encoded into those rules, and what a product then does with the result — the interface, the workflow, the document it produces — are separate concerns, and they belong to the system built around the core.

That line is deliberate. Encoding a domain's rules is expert work that differs from one body of law to the next. Computing a rule's result against a specific case — completely, traceably, and the same way every time — is the general problem, and the general problem is what the lab builds. Because the core computes from rules rather than from any one statute, the same engine can serve court deadlines, statutes of limitation, payroll and overtime rules, eligibility and benefit determinations, and regulatory compliance windows without being rebuilt for each.

Applications

Where it applies.

Praxis applies wherever complex, conditional rules have to be computed against an individual case — the same engine, different rulesets:

Court deadlines and procedural calendaring
Statutes of limitation
Payroll and overtime computation
Immigration timeline and eligibility calculation
Benefit and pension determinations
Regulatory compliance windows

Its first application is in court deadlines; the domains above share the same computational shape.

Disclosure

What we don't publish.

How Praxis represents conditional rules, how it traces them against a case record, and how it preserves the path from rule and facts to result are proprietary. We describe what the core does and what it guarantees. How it is implemented stays in the lab.

The core is built for results that can be checked against the rule and the record they came from. As it moves toward deployment, that correctness is what it will be measured on, and any figures will be published only after independent review.

Status

In development.

Praxis is in development. It is not yet deployed, and no application has been built on it.

Its first intended application is the computation of court deadlines — the rules that govern when a matter must proceed, how long a person may be held, and when a clock starts, stops, or is set aside. A first application is identified; nothing is deployed yet. As with the other cores, the product built on Praxis will be owned by the company that builds it; the core is developed and maintained here at the lab.

→

Licensing

Build on Praxis.

Praxis is in development. If you are building in a domain where complex rules have to be applied to individual cases, the lab is open to early conversations.

Talk to the lab