Deterministic judgment engine

Ark Logos turns explicit rulebooks into replayable verdicts.

Ark Sovereign governs AI actions. Ark Logos is the deterministic rulebook-to-verdict layer underneath it: facts enter, rules are applied, a reason-coded verdict is produced, and the result can be replayed later.

Back to Sovereign ClaimsGov audit View case studies Open proof matrix

ark-logos - rulebook verdict trace

node demos/run_logos_case_replay.mjs

"engine": "ark_logos",

"enforcement_path": "deterministic",

"llm_calls_in_judgment": 0

sanctions_screeningDENY

claims_reviewREQUIRE_REVIEW

lending_criteriaALLOW

batch_qa_exceptionREQUIRE_REVIEW

These are engine validations and case studies, not live production customer deployments.

Rulebook-to-verdict layer

Domain rulebook / SKO -> deterministic judgment -> reason-coded verdict -> replayable evidence packet.

A model may propose an action. Ark Sovereign asks whether the action is allowed. Ark Logos supplies the deterministic judgment layer that makes the decision explainable, repeatable, and auditable.

input_envelope.json

facts:structured

rulebook:explicit_sko

domain:bounded_logic

judgment_path

predicate_eval:deterministic

reason_codes:emitted

audit_hash:bound

Facts are normalized into a reviewable envelope.

INPUT_STRUCTURED

Explicit rulebook predicates are applied in sequence.

RULEBOOK_EVALUATED

Verdict, reason codes, controls, and replay reference are emitted.

EVIDENCE_PACKET_READY

Policy decides. The model does not self-authorize.

ClaimsGov: Offline Claims Decision Audit

Deterministic claims review for insurers, brokers, reinsurers, and claims operations teams.

ClaimsGov is an Ark Logos workflow for offline review of historical claims. It compares anonymized claim records against explicit company policy rules and produces repeatable decision records, reason codes, disagreement queues, and audit-ready evidence.

It is designed for Phase 0 claims audits where the insurer wants management visibility without touching production systems.

offline audit historical anonymized claims explicit policy rules decision consistency missing evidence possible leakage indicators human review boundaries 0 LLM calls in enforcement path

Phase 0 only: no production integration, no payment authority, no denial authority, and no changes to existing claims workflow.

Audit workflow outputs

Rules-based handlingClaims that may be suitable for explicit policy routing.

Human review queueClaims that should remain with reviewers or policy owners.

Missing evidenceDocumentation and field patterns that block clear handling.

Decision consistencySimilar claims that appear to receive inconsistent treatment.

Leakage indicatorsPossible avoidable leakage signals for management review.

Audit packetsReplayable verdict records, reason codes, and hashes.

Required inputs

Anonymized historical claims export
Selected policy rules or claims handling criteria
Historical claim outcomes for comparison
Optional processing timestamps and escalation fields
CSV, Excel, or JSON exports

Audit outputs

Import and field-mapping report
Routing distribution by reason code
Missing-evidence pattern report
Possible leakage indicator report
Disagreement queue for policy-owner review
Replayable audit packet hashes

Operational boundaries

No live customer access
No production API keys
No production integration
No payment authority
No denial authority
No fraud determinations

does not approve claims

does not deny claims

does not authorize payment

does not alter reserves

Deterministic by design: for the same claim facts and rule version, ClaimsGov is designed to produce the same verdict, reason code, and audit record. There are no LLM calls in the enforcement path and no black-box decision logic.

Case study domains

Rulebook-heavy domains. Same deterministic shape.

Ark Logos has been exercised against structured decision patterns where explicit criteria, audit trails, and repeatable verdicts matter. These examples are validations and case studies only.

LOGOS-01

Sanctions screening

Entity and list logic converted into reason-coded verdict paths with replayable evidence.

LOGOS-02

Medical billing logic

Coverage gates, documentation constraints, exception handling, and reviewable denial reasons.

LOGOS-03

Insurance claims logic

Claim facts, policy conditions, escalation reasons, and deterministic review records.

LOGOS-04

Mortgage / loan criteria

Approval and exception criteria packaged into repeatable verdicts and evidence fields.

LOGOS-05

Bank compliance

Operational policy constraints for review queues, transactions, instructions, and action boundaries.

LOGOS-06

Batch QA

Dataset-level sweeps where each row receives a deterministic verdict and replay reference.

Claim boundary: Ark Logos is not a substitute for auditors, counsel, compliance teams, or domain experts. It packages explicit rules and facts into deterministic review artifacts so Ark Sovereign can govern AI actions with replayable evidence.

Open the synthetic rulebook-validation matrix for case-level verdicts, reason codes, controls, and audit hashes. Open Logos proof report ->

LegalGov and relationship to Ark Sovereign

Ark Sovereign is not prompt filtering. LegalGov applies the same deterministic pattern to legal and policy rulebooks.

Ark Sovereign governs high-risk AI actions before execution. Ark Logos is the deterministic judgment engine underneath it: explicit rules enter the judgment layer, and the result is reason-coded evidence that can be replayed later.

LEGALGOV-01

Clause and authority review

Explicit legal or policy criteria are evaluated as bounded predicates with reason-coded review outcomes.

LEGALGOV-02

Human expert boundary

LegalGov produces review artifacts and disagreement queues. It does not replace counsel, auditors, compliance teams, or policy owners.

LEGALGOV-03

Replayable evidence

The same facts and rule version are designed to replay to the same result, reason codes, and audit hash.