Decision Layer · Deterministic · Governed

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.

Talk to usSee how it works

Zero AI at runtime. Deterministic. Auditable. Governed.

Deterministic decision execution
Request
POST /evaluate

“package_id”: “expense_policy”,
“version”: “3.2.0”,
“case”: {
  “category”: “MEAL”,
  “amount”: 185
}
Response
{
  “verdict”: “non_compliant”,
  “reason_codes”: [“MEAL_OVER_LIMIT”],
  “trace_id”: “tr_8f2a...c3d1”
}
Trace
{
  “evaluated”: 5 statements,
  “id”: “Meal_Spend_Limit”,
  “type”: “LIMIT”,
  “rule_result”: “violation”,
  “reason_code”: “MEAL_OVER_LIMIT”
}

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.

Deterministic Decision Pipeline — from document upload through compilation, testing, and production deployment.

See it in action

Explore a working AP invoice processing system powered by 38 business rules compiled into a single Sertainly decision package. Every invoice evaluated deterministically with full audit trail.

Launch VIMS Demo →

The decision layer in your architecture

A dedicated layer between business intent and execution. Integrates with your existing systems — does not replace them.

Source Documents & Business RulesPDFs, handbooks, compliance docs, spreadsheets
↓ compile (AI-assisted, one-time)
Sertainly — Deterministic Decision LayerVersioned decision packages · No AI at runtime
↓ evaluate (deterministic, sub-ms)
AI Agents · Applications · Workflows · ERP / CRM / HRISREST API · MCP · SDK · CLI

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.

Shared Runtime

Multi-tenant API managed by Sertainly. Fastest path to production — zero infrastructure to manage.

Included in Professional plan

Dedicated Runtime

Single-tenant instance in Sertainly's cloud or your VPC. Full network isolation, custom scaling, SLA guarantees.

Enterprise plan

Embedded Runtime

Run the engine as a sidecar, Lambda, or library inside your own services. Decisions stay on-prem — no external calls.

Enterprise plan

Artifact signing & verification

Every published artifact is hashed and signed. Runtimes verify integrity before loading — tampered artifacts never execute.

All plans
Decision PackageCompiled, versioned, signed
↓
Runtime ModelShared · Dedicated · Embedded
↓
ConsumptionREST API · MCP · SDK · CLI

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_case as a native tool
  • Deterministic guardrails inside agentic workflows
  • Works with Claude, GPT, Gemini, open-source models
Probabilistic reasoningLLMs, agents, copilots
↓
Deterministic executionSertainly runtime — same input, same output
↓
Systems of recordERP, CRM, claims, payments

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.

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

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
Learn more →

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
Learn more →

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
Learn more →

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.

By Company Size

Startups & Scale-Ups

Start free. Ship policy-driven features without building a rules engine from scratch. Graduate to Pro as you scale.

Mid-Market

Replace spreadsheet-driven decisions with auditable, versioned policy. RBAC and environment controls keep teams aligned.

Large Enterprises

Governance workflows, SSO, dedicated environments, and SLAs. Deploy on our cloud, yours, or on-prem.

Plans

Decisions are billed per evaluation. AI features use separate credits. Governance and certified builds are enterprise only.

Free

Shared runtime. No governance. For individual developers exploring BDL.

$0

10,000 decisions / month

  • 1 decision package
  • Shared runtime
  • CLI + REST + MCP
  • 7-day trace retention
  • 200 AI credits / month
  • Community support
Start FreeNo credit card required. Buy more AI credits anytime.
Most popular

Professional

Shared runtime with team access. No governance or certified builds.

$49/ month

250,000 decisions / month

  • Unlimited packages
  • Dev / Staging / Prod environments
  • Team access + CI publish tokens
  • 30-day trace retention
  • Replay + export
  • 500 AI credits / month
  • Email support
$0.005 per additional decision.Upgrade to ProfessionalBuy more AI credits anytime.

Enterprise

Private runtime, governance, certified builds, and full audit controls.

Custom

Custom decision volume

  • Dedicated / private runtime
  • Governance workflows + certified builds
  • Signed artifacts + audit export
  • SSO / RBAC
  • Custom retention + VPC / on-prem
  • Included AI build capacity
  • SLA + priority support
Talk to SalesAdditional AI usage billed per contract.
AI features such as document extraction, rule generation, and test creation use AI credits. Every plan includes monthly AI usage. Free and Professional can purchase more anytime; Enterprise usage is handled through contracted capacity.

Business logic is infrastructure.

Make decisions a governed system in your architecture.

Talk to usSee how it works