Auto-adjudicate the easy claims. Escalate the rest. Log every decision.
We integrate Claude, GPT-4 class models, and RAG into Guidewire, Duck Creek, Epic, and custom claims platforms — with deterministic rules engines, dollar-threshold human review, and audit logs that hold up in a DOI exam or CMS review.
Most claims AI projects pay claims they shouldn't and can't explain why.
The pattern is familiar. A vendor demos an LLM that summarizes a claim file in 30 seconds and the room cheers. Six months later, the pilot is parked because the model occasionally pays $40K claims that should have been denied, the compliance team can't reconstruct individual decisions for a DOI inquiry, and adjudicators don't trust the recommendations because confidence scores are uncalibrated. The core mistake is letting a probabilistic system make binding payment decisions instead of using it as a structured-extraction and triage layer in front of a deterministic rules engine.
- ▸ LLM directly issues pay/deny decisions with no rules-engine gate, so a single bad extraction becomes a paid fraudulent claim.
- ▸ No dollar-threshold routing — a $250 dental cleaning and a $180K surgical bundle take the same automated path.
- ▸ Audit logs capture the final disposition but not the prompt, retrieved context, or model version used, making regulatory reconstruction impossible.
- ▸ Adjudicator override decisions never feed back into the system, so the same misclassifications recur for months without correction.
Adjudicate with models, decide with rules, log everything.
- STEP-01
Map the adjudication decision tree
Before any model touches a claim, we document the existing decision logic with your adjudicators — CPT/ICD-10 edits, plan limits, COB rules, fraud flags. The LLM accelerates extraction and reasoning; deterministic rules still own the final yes/no on payment.
- STEP-02
Extract structured data with RAG
Claim documents (HCFA-1500, UB-04, FNOL PDFs, repair invoices) get parsed with a vision model plus RAG over your policy and coverage manuals. Output is strict JSON with field-level confidence scores and source citations back to the document page and policy clause.
- STEP-03
Set human-review thresholds
We define dollar thresholds, confidence floors, and risk flags that route to adjudicators. Typical config: auto-pay under $2.5K with >0.92 confidence and zero fraud flags; everything else queues for review with the model's reasoning pre-loaded in the UI.
- STEP-04
Wire immutable audit logging
Every model call writes to an append-only log: prompt, model version, retrieved context hashes, output, rule-engine result, reviewer ID, final disposition. Logs land in S3 with Object Lock and stream to your SIEM. This is what survives a DOI exam or CMS audit.
- STEP-05
Shadow-run before cutover
We run the pipeline in shadow mode for 4–8 weeks against live claims, comparing model recommendations to human adjudicator decisions. We tune thresholds against measured precision/recall before a single claim is auto-adjudicated in production.
from pydantic import BaseModel, Field
from typing import Literal
class ClaimDecision(BaseModel):
claim_id: str
line_items: list[dict]
extracted_confidence: float = Field(ge=0, le=1)
fraud_flags: list[str]
policy_citations: list[str] # e.g. ["HB-2024 §4.2.1"]
recommended_action: Literal["auto_pay", "deny", "review"]
reasoning: str
def route(decision: ClaimDecision, billed_amount: float) -> str:
# Deterministic gate — model never decides alone
if decision.fraud_flags:
return "review:fraud"
if billed_amount >= 2500:
return "review:high_value"
if decision.extracted_confidence < 0.92:
return "review:low_confidence"
if decision.recommended_action == "deny":
return "review:denial" # denials always get human eyes
return "auto_pay"
# Every call to route() is logged with model version,
# retrieval hashes, and reviewer ID downstream.Pydantic-validated model output feeds a deterministic router — the LLM recommends, rules decide, and denials always escalate to a human.
Field FAQ.
→ Will an LLM hallucinate a coverage decision and pay claims it shouldn't?
Not in a correctly built pipeline. The model never issues payment directly. It extracts structured data and proposes a recommendation with citations back to specific policy clauses. A deterministic rules engine — your existing adjudication logic — makes the binding decision. We also enforce strict JSON schemas with Pydantic or Zod, reject malformed outputs, and require retrieval citations before any auto-pay path is eligible. The LLM is a fast clerk, not the adjudicator.
→ How do you handle HIPAA, PHI, and PII when calling Claude or GPT?
We deploy on HIPAA-eligible infrastructure: AWS Bedrock with a signed BAA for Claude, Azure OpenAI with a BAA for GPT-4 class models, or self-hosted Llama/Mistral for the most sensitive workloads. PHI never leaves your VPC boundary. We strip or tokenize identifiers where the model doesn't need them, and we log every prompt and completion to satisfy 45 CFR §164.312 audit controls. No training on your data, ever.
→ What's a realistic accuracy target for auto-adjudication?
It depends on claim complexity. For clean, low-dollar claims (auto warranty, simple medical office visits, basic property FNOL) we typically see 70–85% straight-through processing at adjudicator-equivalent accuracy after tuning. Complex claims — surgical bundles, BI liability, large commercial property — should stay human-led with AI assist. We measure precision and recall against a held-out set of adjudicator decisions before setting thresholds, and we publish those numbers to your compliance team.
→ How do you set the human-review threshold for high-value claims?
Three inputs: dollar exposure, model confidence, and risk flags. A typical starting config routes to human review on any of: billed amount above your SIU or supervisor authority limit (often $2.5K–$10K depending on line of business), extraction confidence below 0.90–0.92, presence of any fraud indicator, denials of any size, or first-party claims from new policyholders. Thresholds are tunable per product line and tightened during the shadow-run phase.
→ What does the audit log actually contain?
For every claim touched by the pipeline: claim ID, timestamp, model name and version, full prompt, retrieved document chunks with source hashes, raw model output, parsed structured output, rules-engine inputs and result, final disposition, reviewer ID if escalated, and any overrides with reason codes. Logs are written to S3 with Object Lock in compliance mode, retained per your record schedule (typically 7–10 years), and streamed to Splunk or your SIEM of choice.
→ Can this integrate with Guidewire, Duck Creek, or Epic?
Yes. We've integrated with Guidewire ClaimCenter via the Cloud API and integration gateway, Duck Creek via REST and message queues, and Epic via HL7 v2 and FHIR R4. The AI pipeline typically sits as a sidecar service: claims data flows in via the platform's standard integration layer, the pipeline returns recommendations and structured extractions, and the platform's existing workflow engine handles routing and payment. We don't replace the system of record.
→ We're a federal agency handling veterans' benefits claims. Can VooStack work with us?
Yes. VooStack is SDVOSB-certified through SBA's Veteran Small Business Certification program and registered in SAM.gov. We can contract directly via SDVOSB set-asides, sole-source up to the threshold, or as a sub on larger vehicles. We've architected systems against FedRAMP Moderate and High baselines and understand the documentation burden — SSP, POA&Ms, ATO support. For VA, DoL, or SSA claims work, the audit-logging patterns we use map cleanly to NIST 800-53 AU controls.
→ How long until we see real claims flowing through the pipeline?
A focused pilot on one claim type runs 8–12 weeks: 2 weeks of decision-tree mapping and data access, 3–4 weeks building extraction and the rules-engine integration, 4 weeks of shadow-mode running against live traffic, then a controlled cutover starting at 5–10% auto-adjudication volume. Full production rollout across multiple claim types typically takes 6–9 months depending on integration surface and regulatory review cycles.
→ What happens when regulators or plan sponsors ask how a specific claim was decided?
You hand them the audit record. For any claim, we can reconstruct the full decision: which document pages were read, which policy sections were retrieved, what the model proposed, which rules fired, what the human reviewer saw and decided. Output is a signed PDF or JSON bundle. This is the difference between an AI system you can defend in front of a state DOI examiner and one you quietly turn off when the subpoena arrives.
Continue recon.
AI Integration Services
How we wire Claude, GPT, and RAG into regulated production workflows.
REL-02Claims Pipeline Case Studies
Shadow-mode rollouts, threshold tuning, and measured straight-through rates.
REL-03Federal & SDVOSB Work
Claims and benefits adjudication for federal agencies under SDVOSB set-asides.
REL-04Scope a Pilot
8–12 week claims pilot on one product line. Talk to an engineer.
Ship claims automation that survives an audit. Let's scope it.
Talk to a VooStack operator. We respond within one business day.