The problem
At a large regulated enterprise, most consumer and commercial credit is auto-decisioned by a deterministic decision engine. The residual cases it refers fall to reviewers, and the economics of that residual are upside down: a reviewer spends several minutes per case gathering data across six systems, while the judgment itself takes seconds. Meanwhile the memo-writing end of commercial lending had the same shape at larger scale, with credit packs assembled by hand from statements, registries and internal systems over weeks of elapsed time.
I led the architecture and design for the agentic adjudication work inside the enterprise's credit platform, from discovery through to a board-ready proof of concept. Compress the gathering; never touch the judgment. That rule survived every review.
Why it was hard
Re-running the decision engine's logic adds nothing, because the engine is deterministic and already had its chance. The only lever is new information the engine never had: a document it could not read, a reconciliation across sources it does not query, a fact that arrived by email instead of through the workflow. So the system had to create information, not second-guess a decision.
The constraints were real. The enterprise's AI acceptable-use policy barred external cloud models from touching customer data, which forced a deterministic core with small models running on the enterprise's own platform. Documents arrive through a shared mailbox as often as through the content store, so a single tidy ingestion path was a fantasy. Parts of the surrounding estate were being decommissioned, so anything built against them would inherit a death date. And model risk requirements meant the system needed statistical evidence of its accuracy before any reviewer could see a recommendation.
Key decisions
The pipeline is an explicit state machine, not a free agent loop: gather, normalise, ground, propose, gate. Each stage has a contract and a defined failure mode, which is what makes the whole thing replayable for a reviewer.
Both ingestion paths, mailbox and content store, converge on a single normalised evidence schema before any model sees a document. The model reasons over structure, never over formats.
Deterministic rules carry the majority of cases at no model cost. A small fine-tuned model handles only the residual that genuinely needs judgment, sized to the triage task rather than a frontier model on every case.
Evaluation was built before the pipeline: a golden set of historical referred cases with known outcomes, graded on agreement with the reviewer's actual decision. That decision converted weeks of shadow running into committee evidence rather than anecdote.
Integration was anchored on the platforms that will survive the current re-engineering, never on the systems being retired.
Architecture
Gatherer agents pull from the six systems in parallel over defined tool contracts. A grounding agent normalises what they return into the evidence schema. Financial reasoning runs over that structure, spreading figures and checking them against arithmetic invariants, so a balance sheet that does not balance is rejected rather than narrated. Risk signals and policy checks feed a proposed disposition and a drafted decision memo in which every material figure cites its source. A reviewer agent checks the proposal against policy, and only then does the case reach the human gate.
The same gather, ground, propose, gate grammar extends across the credit lifecycle: financial spreading from client statements, credit-policy search for analysts, automated memo packs, obligations monitoring and pre-eligibility checks that understand a borrower before a decision is asked for. The refer-back build was designed as the entry point into that wider estate, not as a one-off.
Trade-offs
An explicit state machine gives up the flexibility of a free agent loop, and that was the point: a loop that can improvise is a loop a reviewer cannot replay. The small-model choice trades peak capability for ownership, cost and policy compliance, and it holds because the hard reasoning was pushed into deterministic structure before the model ever runs. Shadow mode delayed visible value by weeks, which is uncomfortable in a programme hungry for demos, but it is what turned the system from a promising prototype into something a risk committee could sign.
Governance
The system ran in shadow mode first, with recommendations logged but never shown, producing the accuracy, precision and recall evidence the model risk committee required before any assistant went live. Every claim in a memo maps to a source; unsupported figures are stripped or force regeneration. Customer data never leaves the enterprise's own platform. The reviewer decides every case, and each gated decision is auditable end to end, replayable from the case record alone.
Outcome
The proof of concept collapsed several minutes of per-case gathering to well under a minute, and the business case behind it scored well over a hundred referral use cases across three lending domains, a large subset modelled down to activity level and cost per case. On the commercial side, the same pattern took memo preparation from weeks of elapsed time to hours, with agents recommending and reviewers deciding. The design was accepted as the template for re-engineering lending origination as the legacy platform is replaced.
What I learned
The most useful sentence in the whole engagement was the constraint: the only lever is information the engine never had. It killed a dozen seductive ideas about second-guessing the decision engine and focused the build on evidence. I also learned to build the evaluation before the pipeline; a golden set of historical cases with known outcomes is worth more than any architecture diagram when the audience is a risk committee. Boring pipelines defend better than clever ones.