The Decision Layer for
Your Enterprise Architecture
Business logic is scattered across code, documents, spreadsheets, and AI prompts. Sertainly compiles it into governed, auditable decision infrastructure — with zero AI at runtime.
Zero AI at runtime. Deterministic. Auditable. Governed.
SOC 2 Type II
Audit in progress. Encryption in transit and at rest across every deployment model.
Enterprise SSO
SAML, OIDC, and SCIM. RBAC with environment-scoped permissions and approval workflows.
Signed artifacts
Every published decision package is hashed and signed. Tampered artifacts never execute.
Data residency
Deploy in our cloud, your VPC, or fully air-gapped on-prem. Data stays inside your boundary.
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”: [“AMOUNT_ABOVE_FASTTRACK”],
“routes”: [ { “to”: “senior_adjuster” } ],
“facts”: { “covered_amount”: 17400 }
},
“trace_id”: “trc_clm_9d2e...a17”
}{
“trace_id”: “trc_clm_9d2e...a17”,
“applied_rules”: [{
“id”: “route_above_fasttrack”,
“phase”: “route”,
“emitted”: { “tag”: “MANUAL_REVIEW”, “route”: “senior_adjuster” }
}],
“skipped_rules”: [{ “id”: “auto_approve”, “reason”: “when=false” }]
}Compile with AI. Execute deterministically.
AI assists at compile time — extracting rules from documents, generating test scenarios, diagnosing failures. At runtime, every decision is pure computation. Same input, same output, every time. No model inference, no probabilistic reasoning, no prompt variability.
From document to decision API
Sertainly compiles natural-language business logic into a deterministic execution layer — no runtime interpretation, full audit trail.
Upload
Drop in PDFs, handbooks, or compliance docs. AI extracts rules, thresholds, and routing conditions into formal decision rules.
Review & test
Inspect every extracted rule. Run AI-generated test scenarios. Approve before anything reaches production.
Publish
Package as a versioned, immutable decision artifact with full provenance. One click to production.
Operate
Deploy to shared or dedicated runtimes. Every decision is traced, auditable, and deterministic.
The decision layer in your architecture
A dedicated layer between business intent and execution. Integrates with your existing systems — does not replace them.
One engine. Three deployment models.
Whether you call the shared API, run a dedicated instance, or embed the engine in your own stack — every decision is compiled once and executed identically.
Managed Multi-Tenant Runtime
Fully managed by Sertainly with per-tenant isolation, encryption in transit and at rest, and RBAC — operated within our SOC 2-scoped environment.
Dedicated Runtime
Single-tenant instance in Sertainly's cloud or your VPC. Full network isolation, custom scaling, SLA guarantees.
Embedded Runtime
Run the engine as a sidecar, Lambda, or library inside your own services. Decisions stay on-prem — no external calls.
Artifact signing & verification
Every published artifact is hashed and signed. Runtimes verify integrity before loading — tampered artifacts never execute.
Our cloud. Your cloud. Or on-prem.
Sertainly Cloud
Fully managed infrastructure. Zero ops overhead. SOC 2 Type II in progress.
Your Cloud (VPC)
Deploy into your own AWS, Azure, or GCP account. Data never leaves your network boundary.
On-Prem
Air-gapped deployments for regulated industries. Full control over hardware, networking, and data residency.
Built for systems and agents
REST APIsystem-level
- Evaluate decisions with a single POST
- API-key scoped to environment & policy
- Batch evaluation endpoint for bulk processing
- OpenAPI spec & SDKs (Python, Node, Go)
MCP Serveragents
- Model Context Protocol for LLM tool-use
- Agents call
evaluate_caseas a native tool - Deterministic guardrails inside agentic workflows
- Works with Claude, GPT, Gemini, open-source models
This is decision infrastructure, not a chatbot
Deterministic execution
No AI at runtime. Compiled business logic evaluates the same way every time — across environments, runtimes, and versions.
Full trace + citations
Every decision includes the rules that fired, the source document sections they came from, and the data that matched.
Version control & diffs
Semantic versioning for decision packages. Diff any two versions to see exactly what changed — rules added, removed, or modified.
Execution profiles
Configure enforcement levels, field defaults, and overrides per environment without recompiling.
Simulation & impact analysis
Run historical data against new versions before promoting. See how many decisions would change and why — and the same engine runs retroactively to size the blast radius of a correction.
Enterprise controls
RBAC, SSO (SAML/OIDC), approval workflows, environment promotion gates, and signed audit exports.
Agentic patterns. Deterministic control.
Deterministic Action Gates
Before an agent executes a high-stakes action, it calls Sertainly to get a deterministic allow/deny verdict — no prompt-level guardrails required.
Case Completion Contracts
Define what “done” looks like for a case. The agent checks its work against the policy before closing — ensuring nothing is missed.
Canonical Derived Fields
Let the policy compute risk scores, tiers, or classifications deterministically — so every agent in a swarm uses the same derived values.
Risk Lanes & Escalation
Route cases to human review when policy conditions are met. Agents handle the happy path; humans handle the exceptions.
Tool-Use Policy Enforcement
Control which tools an agent can invoke based on context, role, and case attributes — enforced by policy, not by prompt engineering.
Replayable Decisions for Swarms
Every decision is traced and replayable. When multiple agents collaborate, you get a single, auditable decision log across the entire swarm.
Validated vs Certified
Validatedbring-your-own rules
- Upload hand-written rules or generate them externally
- Sertainly validates syntax, schema, and determinism
- Full runtime execution with trace & audit
- No source-document provenance (declared origin)
Certifiedsource-backed
- Compiled from uploaded source documents via guided pipeline
- Every rule traced to a source section & page number
- Full provenance chain: document → extraction → compilation
- Highest assurance for regulated environments
Versioning and lifecycle, built for the record
Every source, snapshot, version, and release forms an immutable lineage. A case is judged by the rules in force on its business date — reproducible forever, even re-run years later in an audit.
Effective-dated releases
A release binds a version to a date window. Date-based routing sends each case to the rules that were in force on its business date — so a 2024 decision replays identically in a 2030 audit.
Editions vs corrections
A Retired version stays valid history — the rules changed, but its past decisions were correct. A Withdrawn version is a correction: it was wrong, and everything it touched is flagged for remediation.
Replay & remediation
Mark a version wrong and Sertainly re-runs every decision it made, then hands you the blast-radius worklist — the exact list of affected people and cases to remediate.
Rollback
Promote a prior version back into force in one step. The lineage is preserved — nothing is overwritten, and the rollback itself is dated and traceable.
Contract-impact checks
Every change is classified — breaking, additive, or internal — before it ships, so integrators know exactly what a new version means for their inputs and outputs. Pairs with version control & diffs.
Reproducible by design
Snapshots and versions are immutable and signed. Any decision, from any point in the timeline, can be reconstructed exactly — no guesswork, no drift.
How date-based routing, editions, and remediation work in practice.
Read: When the Rules Change →Governance and audit, by design
Audit — trace everything
- Every decision logged with full input, output, and trace
- Source-document citations on every rule that fired
- Exportable audit trails (JSON, CSV, PDF)
- Configurable retention (7-day to unlimited)
- Signed exports for regulatory submission
Control — operate safely
- RBAC with environment-scoped permissions
- Approval workflows for production promotions
- Environment gates (Dev → Staging → Prod)
- SSO via SAML & OIDC
- API key rotation & scope management
Use Cases
By Industry
Financial Services
Automate lending decisions, transaction monitoring, and regulatory compliance with deterministic, auditable policy.
- Credit decisioning & underwriting
- AML / KYC rule enforcement
- Fee & rate determination
- Regulatory reporting controls
Insurance
Enforce underwriting guidelines, automate claims adjudication, and maintain compliance across jurisdictions.
- Automated claims triage & adjudication
- Underwriting rule enforcement
- Rate & eligibility determination
- Regulatory compliance by jurisdiction
Healthcare
Codify clinical protocols, prior-auth rules, and compliance requirements into executable, traceable policy.
- Prior authorization decisioning
- Clinical protocol enforcement
- Billing & coding compliance
- HIPAA access-control rules
Government & Public Sector
Determine eligibility and enforce compliance deterministically, with statute-linked reason codes and a defensible audit trail.
- Benefits eligibility determination
- Licensing & permitting
- Program & grant eligibility
- Appeals & audit defensibility
Enterprise SaaS & Technology
Embed policy-driven guardrails into AI products, platform features, and multi-tenant access control.
- AI agent guardrails & tool-use policies
- Entitlement & feature-flag enforcement
- Usage-based billing rules
- Multi-tenant data access policies
Manufacturing & Procurement
Enforce procurement rules, supplier compliance, and quality-control policies across supply chains.
- Procurement approval thresholds
- Supplier qualification rules
- Quality-control gate enforcement
- Expense & travel policy automation
Government & Public Sector
Digitize regulatory frameworks, benefits eligibility, and permitting rules with full transparency and audit.
- Benefits eligibility determination
- Permit & license adjudication
- Grant compliance enforcement
- Regulatory inspection rules
By Role
Enterprise Architects
Standardize decision logic across the org. Replace scattered rule engines with a single, governed decision layer.
Developers
Integrate decisions via REST API or SDK. No more hard-coding business rules in application logic.
Agent Builders
Give AI agents deterministic guardrails via MCP. Policy enforcement without prompt engineering.
Auditors & Risk
Full decision traces with source citations. Export audit logs for regulatory review — no reconstruction needed.
Business logic is infrastructure.
Make decisions a governed system in your architecture.