July 24, 2026, (Inside AI) — Most enterprise document extraction pipelines default to a single, expensive hosted flagship model for every field. It works, but the bill dominates running costs. A new cascade architecture flips that pattern: start cheap, verify rigorously, and escalate only on failure. The result is a generation brick that slashes cost while preserving correctness, backed by a real benchmark of twenty local models against a hosted GPT-4-class API.
The core insight is simple. Thousands of field-level calls—amounts, dates, coverage limits—don't all need a flagship. A small local model handles plain lookups fine. But blindly swapping in a small model backfires when it returns broken typed output or fumbles a transformation. The fix is not to guess; it's to build a loop that checks every answer and escalates deterministically.
This design, developed in the Enterprise Document Intelligence series, treats model selection as a brick decision. It leans on a dispatcher that picks a starting model by criteria, a validator that confirms correctness, and a bounded escalation loop. The approach echoes the series' adaptive parsing philosophy: pay for the expensive tool only on the cases that need it.
Size Doesn't Order Accuracy
A sweep of twenty local models on a raw one-shot extraction task upends conventional wisdom. The best performers were a 4B and a 7B model, not the larger ones. A 12B and a 14B sat below them. Two models from the same family, one twice the size, tied. Parameter count is a poor predictor; model family and training matter more.
There's a floor. Sub-2B models fell off a cliff, with one at 12% accuracy and another at 6%. A 0.5B model returned empty JSON on most fields. Starting there wastes a loop iteration. Criteria must place the starting rung above that floor.
Cost is not speed. The hosted flagship answered in about 1.4 seconds per field, faster than most local 7B-to-14B models (2.6 to 7.6 seconds each). The small-local play buys lower cost and data locality, not latency. If speed is the constraint, the cheap local model is often the wrong default.
The best small local model, run alone, got roughly a third of the fields right. It's viable only with a loop: a tight retrieval snippet, the right prompt content, validation on every field, and code handling hard formatting.
Vocabulary Is the Biggest Lever
The single largest accuracy jump came not from more parameters but from injecting the task's business glossary into the prompt. A small local model went from 38% to 62% correct. The flagship jumped from 62% to 100%. The flagship needed those definitions to finish the job.
This fixes vocabulary mismatches. A field labeled "deductible per claim" in one document is "retention" in another. Without the glossary, a small model guesses. Hand it the definition, synonyms, and units, and the guess turns into a read. This lifts every rung at once and is cheaper than any model upgrade.
The cascade works in three moves. First, pick a starting model by criteria: confidentiality forces a local model; typed-output reliability demands validation for small models; transformation complexity flags hard one-shot steps. The dispatcher pins the best local model and sets a validation flag.
Second, run the model, validate with checks from Article 8C (typed shape, cited spans, quoted text), and escalate only on failure. A bounded loop ensures a pathological field can't spin forever; it escalates to the strongest model and, if that fails, returns a typed "not answered."
Third, split the task when the failure is a hard transformation, not a weak model. For example, let the model point at a source line, and let deterministic code format the value. This keeps raw documents local but has a cost: pointing at the right line is itself hard, and accuracy dropped in the benchmark compared to one-shot extraction. Decomposition is a tool with a trade-off, not a universal win.
The cascade reconciles with the series' question-side dispatch and validation. Article 6C proposes a starting tier from the parsed question; generation attempts it; Article 8C's validation confirms or triggers escalation. The loop closes a feedback cycle: suggest, attempt, judge, escalate.
In practice, most fields never leave the cheap rung. Cost drops dramatically. Correctness holds because the ones that need more get it, on evidence, not a hunch. The sweep proves the shape works and warns against shortcuts: size doesn't order accuracy, and the biggest lever is the vocabulary in the prompt, not the parameter count you pay for. The runnable notebook, available on GitHub, demonstrates the cascade in action, showing per-field cost and validation verdicts at each rung.
