Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/sputhenofficial/claimjumper/llms.txt

Use this file to discover all available pages before exploring further.

After GPT-5.6 Sol produces a triage decision, enforceInvariants() runs synchronously and may escalate the line to human_review. These rules exist in code — not just in prompts — and are covered by regression tests. No configuration option, model instruction, or prompt can disable them. If any invariant fires, the lane is set to human_review and the exact override reason is recorded for the billing team to read.

​
The three invariants

​
CO + patient_bill invariant

A CO (Contractual Obligation) group code means the provider has already absorbed the adjustment amount by contract with the payer. That obligation belongs to the provider, not the patient. Billing a patient for a contractually obligated amount is a billing compliance violation and can constitute an improper balance-billing practice. Because of this, the CO + patient_bill combination is absolutely prohibited. If the model returns patient_bill for a line whose group code is CO, enforceInvariants() immediately escalates the line:
"CO is a contractual obligation the provider absorbs, so it can't be billed to the patient."
The billing team must examine the line manually to determine the correct action — typically a write-off or a deeper investigation of the contract terms.

​
CARC 197 + write_off invariant

CARC 197 indicates a payer-responsibility denial: the payer is asserting that the amount should be the responsibility of another payer or coordination-of-benefits arrangement. This is not a routine contractual adjustment. Abandoning revenue on a payer-responsibility denial is a deliberate business decision that requires human judgment — it cannot be automated. If the model returns write_off for a line where carc === "197", enforceInvariants() escalates the line:
"CARC 197 is a payer-responsibility denial — abandoning this revenue is a human's decision, not an automated write-off."
The billing team must review the coordination-of-benefits situation and decide whether to pursue the correct payer or follow the organization’s adjustment policy.

​
Low-confidence invariant

When GPT-5.6 Sol is uncertain about the correct lane, it expresses that uncertainty as a confidence score below 0.6. ClaimJumper treats sub-threshold confidence as a signal that the line is not safe to route automatically. Rather than proceeding with a potentially incorrect lane assignment, enforceInvariants() escalates the line:
"Routing confidence is below the automation threshold — flagged for a human to confirm."
This is an intentional design choice: under-claiming certainty is correct. The billing team sees the model’s initial rationale and evidence assessment alongside the override reason so they can make an informed decision.

​
enforceInvariants source

All three checks are implemented in a single synchronous function. The entire function is reproduced below for transparency: 
// lib/pipeline/invariants.ts
import type { AdjustmentLine, DenialTriage } from "@/lib/schemas";

export function enforceInvariants(
  line: AdjustmentLine,
  triage: DenialTriage,
): DenialTriage {
  const overrides: string[] = [];

  if (line.group_code === "CO" && triage.lane === "patient_bill") {
    overrides.push("CO is a contractual obligation the provider absorbs, so it can't be billed to the patient.");
  }

  if (line.carc === "197" && triage.lane === "write_off") {
    overrides.push("CARC 197 is a payer-responsibility denial — abandoning this revenue is a human's decision, not an automated write-off.");
  }

  if (triage.confidence < 0.6) {
    overrides.push("Routing confidence is below the automation threshold — flagged for a human to confirm.");
  }

  return {
    ...triage,
    lane: overrides.length > 0 ? "human_review" : triage.lane,
    overrides,
  };
}
The function takes the parsed AdjustmentLine and the model’s initial DenialTriage result (with an empty overrides array), evaluates all three checks independently, then returns a new DenialTriage with lane set to human_review if any override fired, and the full list of override messages in overrides. Multiple invariants can fire on the same line — all reasons are collected and surfaced together.

​
Human-review brief

When one or more invariants fire, the drafting step produces a deterministic reviewBrief() artifact rather than calling the model. The brief is assembled directly from the validated pipeline data and takes this form: 
HUMAN REVIEW REQUIRED — Review Brief (not submission-ready)
Claim: <claim_id>; Patient: <patient_name>; Line: <line_number>
Service: <service_date>; Procedure: <procedure_code>; Denial: <group_code> / CARC <carc>[/ RARC <rarc>]
Rationale: <triage.rationale>
Evidence needed: <evidence_needed item 1> | <evidence_needed item 2>
Overrides:
- <override reason 1>
- <override reason 2>
The brief includes:
  • Claim ID and patient — so the reviewer can locate the record
  • Service line — procedure code, service date, and the full denial code combination
  • Rationale — the model’s original reasoning, even though the lane was overridden
  • Evidence needed — what the model identified as necessary to act on the denial
  • Override reasons — the exact messages from enforceInvariants(), one per bullet
Because the brief is deterministic and does not involve the model, it is reproducible and inspectable. It is classified with lane: "human_review" and title: "Human Review Required". It is not approvable and not exportable.

​
Override reasons in the UI

The overrides array from enforceInvariants() is preserved through the entire pipeline. The triage() function is the only place in the pipeline that calls enforceInvariants(): 
// lib/pipeline/triage.ts (relevant excerpt)
export async function triage(line: AdjustmentLine): Promise<DenialTriage> {
  // ...model call...
  return enforceInvariants(line, { ...modelOutput, overrides: [] });
}
The API route trusts the already-enforced result from triage() and does not call enforceInvariants() again. enforceInvariants() is called exactly once, in triage(). Any downstream step that re-processes the DenialTriage must treat overrides as read-only.
Invariants cannot be disabled or bypassed through configuration, prompt engineering, or environment settings. They are the code-level boundary between model-assisted routing and actions that always require human judgment.

Build docs developers (and LLMs) love

Get started for freeTalk to us