An underwriting pipeline that doesn't hallucinate

Underwriting punishes confidence. A model that hedges is annoying. A model that hallucinates a number into a credit decision — fluently, no visible seam — is a liability that shows up months later, in someone else's balance sheet.

So the design question was never how good the model is. It was: the moment it's wrong, does anything catch it before it becomes a decision.

We built this as a pipeline of narrow, specialised agents with explicit handoffs. Not one model asked to do everything end to end.

Extract. RAG-grounded extraction from messy source documents — bank statements, financials, PDFs never meant to be machine-read. Every figure is grounded in a retrievable source passage. Nothing is generated from memory.

Verify. A second pass cross-checks figures against each other and against the source. Low-confidence extractions get flagged, not silently passed downstream.

Assess. The model proposes risk signals from the verified data. Rules can veto. Nothing it proposes reaches a decision without going through logic a human wrote and can audit.

Decide. A deterministic policy layer has final word. Not final say most of the time — final, full stop. The model informs the decision. It never is the decision.

Every step logged, explainable, replayable. A decision from six months ago can be reconstructed exactly, with the evidence that produced it.

# pipeline: underwriting-decision
stages:
  extract:
    method: rag_grounded_extraction
    output: [figures, source_spans]
  verify:
    method: cross_check + confidence_scoring
    on_low_confidence: flag_for_review
  assess:
    method: ai_proposed_risk_signals
    veto: rule_engine
  decide:
    method: deterministic_policy_layer   # final word, always
    output: decision + full_evidence_trail
audit:
  every_decision: replayable_from(source_spans, verify_log, policy_version)

Turnaround went from days to hours, without loosening the bar on rigor. Every decision carries a replayable evidence trail. The rule engine — not the model — owns the final disposition, every time.

For any AI sitting in a critical path, there's one question worth asking before anything else: what happens when it's confidently wrong. If the honest answer isn't "a deterministic layer catches it, and the whole thing stays explainable," the design isn't done yet — no matter how good the demo looked in the room.