Your decision logic should be an artifact you can hand to an auditor — not logic locked inside systems that can't explain themselves.

LogicPearl compiles the conditional logic in your codebase into deterministic artifacts that explain every outcome and show exactly what would change it.

See how it works Talk to us

Star on GitHub — MIT Licensed Rust + Python Patent Pending

▶ See it in 60 seconds Watch LogicPearl learn rules, evaluate decisions, and explain outcomes → ✚ Explore a real healthcare use case Open the interactive prior-auth and revenue workflow demo built from representative healthcare cases →

One engine. Many decision domains.

Security Claims Approvals Compliance Agent Boundaries

This Is Already Costing You

Your last policy change broke production

Because the logic was scattered across 30 services and nobody could predict what a single rule change would affect. With LogicPearl, a policy change is a diff on one artifact. You review it, test it, deploy it. No archaeology.

Your last audit cost six figures

Because your compliance team couldn't trace how decisions were made. They hired consultants to reverse-engineer your own code. A pearl is the audit trail — every rule, every threshold, every version, diffable and signed.

A customer sued because you couldn't explain a denial

In healthcare, finance, insurance — "the system said no" is legal exposure. LogicPearl produces counterfactuals: not just why they were denied, but exactly what would change the outcome. A lawsuit becomes a conversation.

Your AI pipeline makes decisions nobody can reproduce

Your LLM returns a different answer every time. A regulator asks how your system decided. You can't say "the model thought so." A pearl is deterministic — same input, same output, every time, with a signed receipt.

Your security tools tell you what was blocked but not why

Your vendor shows the IP, the path, the action — but not which pattern matched or how to fix a false positive. They can't, because exposing match details to attackers is a risk. LogicPearl separates the two: blocked responses stay opaque to clients, but your team sees full explainability and counterfactuals in the operator view. You can finally debug your own rules.

Your decision logic runs in 200ms and you don't know why

A pearl evaluates in microseconds. Not milliseconds — microseconds. It's a compiled binary, not an interpreter reading config files. The entire evaluation is a handful of comparisons on a bitmask. There is nothing faster.

The Problem

Your codebase has ten years of conditionals.

Thousands of if/else branches across dozens of services. Approval logic in one repo, denial rules in another, override conditions in a config file someone wrote in 2019. Every quarter someone asks "why did this decision happen?" and the answer takes a two-week investigation across three teams.

A patient's claim is denied. They appeal. Your ops team traces through code, config, and tribal knowledge for hours. The best answer they can give is: "the system said no."

What It Looks Like With LogicPearl

Give LogicPearl the inputs and outputs of your existing system. It automatically discovers the minimal set of rules that perfectly reproduce every decision — then the thousands of conditionals in your codebase can be replaced by clean, human-readable rules:

✗ deny when diagnosis code is not in the approved list for this procedure

✗ deny when provider is out of network

✓ deny when patient age is outside coverage range

That's it. The entire decision codebase — thousands of lines across dozens of services — collapses into rules you can read in 30 seconds. Same outcomes, verified against your real data. And every time a rule fires, it produces a receipt.

Decision Receipt pearl: claims_adjudication_v3

DENIED

bit 0 diagnosis_code not in approved list for this procedure

→ submit with an approved diagnosis-procedure pairing, or request a medical necessity exception

bit 3 provider_network_status == out_of_network

→ use an in-network provider, or obtain a network exception authorization

This is a healthcare example. The same model works for any domain where decisions have consequences — see more below.

See It In Action

This is one proof surface, not the whole product: LogicPearl running as a web request decision layer. The same pattern applies to claims, approvals, compliance, and agent boundaries.

Most tools tell you what they blocked. LogicPearl shows your team why, what fired, and what would change the outcome. That is the difference between debugging a black box and shipping policy with confidence.

Current public WAF holdout: 92.8% attack catch with 85.5% benign pass. This is the live demo surface, not a mocked screenshot.

Held-out public WAF evaluation built from CSIC HTTP 2010 and ModSecurity/OWASP traffic.

Pick an example above or paste a request to evaluate.

Before

Blocked, flagged, or denied — but nobody on your team can explain the exact decision without days of investigation.

After

One compiled artifact. One operator-facing explanation. One clear counterfactual showing what to change or why the rule fired.

Fits Into What You're Already Building

AI handles the boundary

Using LLMs for intake, triage, or extraction? Let them handle the messy input. LogicPearl handles the deterministic decision. AI observes, the pearl decides.

Cheaper, faster, auditable

The decision step becomes a compiled artifact — not another model call. Your AI pipeline gets faster and cheaper, and every outcome is explainable.

The regulator's answer

When someone asks how your AI system made a decision, the pearl is your answer. Deterministic, diffable, signed. Not "the model thought so."

How It Works

Extract

Point LogicPearl at your existing decision data — past approvals, denials, flags. CSV or JSON. Your data is the source of truth; LogicPearl makes the logic visible so you can verify it, not hide it.

Compile

LogicPearl discovers the rules automatically and compiles them into a pearl bundle — a deployable artifact set with every rule, threshold, and counterfactual built in.

Deploy

Ship the pearl as a native binary, WASM module, or JSON artifact. No runtime dependencies. Runs anywhere.

Want the full technical deep dive? See the developer page with interactive demos and live WASM evaluation.

Beyond Healthcare

The claims example above is one application. LogicPearl works anywhere conditional logic has real consequences.

Compliance & Authorization

Policy enforcement as a portable artifact. Audit trails built in. Diffs show exactly what changed between policy versions.

Fraud & Trust

Deterministic risk gates where every denial cites the exact rules that fired. No black-box scores.

Agent Guardrails

AI agents making tool calls and accessing data need deterministic safety boundaries. A pearl is that boundary — fast, inspectable, no model in the loop.

Legacy Logic Migration

Extract the decision logic from the ten-year codebase, compile it into something readable, and ship it as a standalone binary. Then sunset the old code.

Where Teams Bring Us In

Legacy logic extraction

When decision behavior is buried across code, config, and tribal knowledge, we turn it into one artifact your team can inspect and deploy.

Policy modernization

When approvals, denials, or reviews need to be auditable, diffable, and testable, we compile the policy into something operators and compliance teams can actually read.

Deterministic boundaries around AI

When an LLM or automation system handles messy input, we add the deterministic decision layer that regulators, security teams, and operators can trust.

What Changes

Policy changes = prayer in production → Semantic diffs you can review before deploy

claims_adjudication.pearl.ir.json v2 → v3

  rule_000: deny when annual_income <= $26,000
  rule_001: deny when credit_score <= 500
- rule_002: deny when debt_ratio >= 55%
+ rule_002: deny when debt_ratio >= 50%
  rule_003: deny when employment_years <= 0
+ rule_004: deny when bankruptcy_flag == true

Logic scattered across 30 services → One artifact, deployable anywhere

Before

claims-api/src/rules/ eligibility-svc/config.yaml auth-gateway/policies/ billing/overrides.py shared-lib/validators/ ...12 more services

→

After

claims_adjudication.pearl

4 rules · 42KB binary · runs anywhere

2-week audit investigations → Instant decision receipts with every evaluation

"The system said no" → Exact rules that fired + what would change the outcome

Open Source Core, Expert Consulting

Open Source

Free

The full engine, CLI, runtime, and WASM compiler. Build pearls, run them, ship them. MIT licensed. No limits, no telemetry, no catch.

Get Started

Consulting

Let's talk

We work with your team on the hardest decision logic problems — healthcare adjudication, compliance systems, legacy migrations. We've done the ugly ones.

Talk to Us

Let's Talk About Your Decision Logic

Tell us what you're working on. We'll get back to you within a business day.