From a policy document to a callable, governed decision API — and how it stays honest as the rules change. One flow, three phases: build once, run anywhere, and change with confidence.
AI where it helps. Determinism where it counts.
The whole model rests on one split. AI assists when you build a decision package — reading source, drafting rules, generating tests. But once it’s published, running it involves no model inference at all: every decision is pure, reproducible computation. That is why decisions are deterministic, traceable, fast, and safe — and why your case data is never sent to a model to decide.
Drop in the policy documents, regulations, contracts, or rate tables that govern the decision — PDF, DOCX, or text. This is the authority the package will be built from.
Sertainly reads the source and proposes structured rules, each one mapped to the exact section and page it came from. AI does the heavy lifting of turning prose into logic.
You check the rules against the source, edit anything, and approve. Nothing ships that a human hasn’t signed off — AI assists, it never decides unattended. Every rule stays traceable to its clause.
Scenarios are generated to exercise the rules and run against the compiled package, so you see exactly how it behaves — and catch gaps — before anything goes live.
The approved rules compile into a decision package that’s hashed, signed, and version-pinned. Tampered artifacts never execute; every build is provably the one you approved.
Agents and systems call evaluate_case with a case. No SDK required, no model in the loop — just a single request your existing stack can make.
Every call returns a status, channel-shaped outputs (tags, reason codes, routes, evidence needed, facts), and a trace that shows exactly which rules fired and why — with zero LLM inference at decision time.
A new version is an effective-dated release. Diff it against the current one, simulate the blast radius over real history before you promote — or roll back instantly.
Every case routes to the version that was live on its business date. A decision made in 2024 replays identically in a 2030 audit — and if a version was wrong, replay finds every decision it touched.
A system sends a case; Sertainly returns a decision, the reasons behind it, and a trace id to pull the full rule-by-rule breakdown.
POST /api/public/v1/packages/claims_adjudication/evaluate
{
"case": {
"claim": {
"type": "AUTO_COLLISION",
"amount": 18400,
"incident_date": "2026-06-02"
},
"policy": { "status": "ACTIVE", "deductible": 1000 }
}
}{
"status": "ok",
"outputs": {
"tags": ["MANUAL_REVIEW"],
"reason_codes": [
"COVERAGE_ACTIVE",
"AMOUNT_ABOVE_FASTTRACK"
],
"routes": [ { "to": "senior_adjuster" } ],
"facts": { "covered_amount": 17400 }
},
"trace_id": "trc_clm_9d2e...a17"
}The coverage was confirmed, but the amount is over the fast-track limit, so the package routed it to a senior adjuster and computed the covered amount — every output tied to a rule, every rule tied to the source. Pull trace_id to see the full rule-by-rule breakdown.
Where the decision layer sits between business intent and execution, and the deployment models.
Enterprise →Why zero AI at runtime is a security property — plus encryption, deployment, and the trust checklist.
Security →The CLI, local authoring in open BDL, testing, and the publish-to-runtime workflow.
Developers →Bring a policy document; we’ll show you the path from source to a signed, callable decision API with a full trace.