Credit evaluation agent
We design, build and deploy an AI agent that reads and cross-checks loan documents, flags the discrepancies, and hands your credit officer a decision-ready summary — while the lending decision stays with a human.
What changes when it works
Time per application
Manual review today
~25–35 min
With the agent
~5–8 min
Time saved
≈ 20–25 minutes saved per application — about 100–125 hours a month at 300 applications, roughly half a full-time reviewer.
Indicative; actual time depends on the number of documents and case complexity.
Our agentic development process
Every use case follows the same seven stages — from framing the problem to production.
Our process, built on Anthropic's agent guidance and the Agent GPA eval framework: Building Effective Agents · Agent GPA
Stage 1 · Frame
The business problem
A Malaysian lender's credit team receives each application as a bundle — IC, payslips, bank statements, financing form, dealer quotation. Most of a reviewer's day goes to the mechanical part: checking that the documents agree with each other, not deciding whether to lend. It is slow, it drifts as fatigue sets in, and two officers apply slightly different diligence to the same file.
Stage 2 · Map
The manual workflow today
- 01Open the application bundle and each document
- 02Read and extract the key fields by eye
- 03Cross-check name, income and account across documents
- 04Chase missing months or mismatches
- 05Only then begin the real credit judgement
Where it breaks: The bottleneck is document matching, not decision-making — and it is exactly the part that fatigues and varies between officers.
Stage 3 · Design
The agentic workflow
We redesign the review as an evaluator-optimizer loop: the agent reads and reconciles the bundle, evaluates each check, and iterates until it can produce a clean, evidenced summary — escalating anything it cannot resolve to a human.
The evaluator re-checks and re-reads until the checks pass — the evaluator-optimizer loop.
Watch a case flow through the agent — it does the reading and matching; a human still makes the decision.
Step by step
- 1
Read the documents
The agent ingests every file in the bundle — IC, payslips, bank statements, financing form, dealer quotation — reading text and, for scans and phone photos, using vision to extract the content.
- 2
Extract structured fields
It pulls the fields that matter into a structured record — name, IC number, employer, declared income, bank account, monthly commitments — tagging the source document for each.
- 3
Cross-match across the bundle
It reconciles those fields against each other: name on IC vs payslip vs application; declared income vs the actual salary credits; the statement's account vs the form's; whether all required months are present.
- 4
Evaluate and iterate (the loop)
An evaluator step scores each check; where confidence is low or a check fails, the agent re-reads or requests the missing piece before finalising — the evaluator-optimizer loop.
- 5
Flag and summarise
It produces a one-page summary: the applicant, the checks that passed, and the two or three items to look at — each with the figure and the document it came from.
- 6
Hand to a human
The credit officer reviews the flagged items and makes the lending decision. Nothing is auto-approved.
Stage 4 · Build
How we build it with Claude
We build the agent on Claude using the standard loop — gather context (pull in the documents and case data), take action (extract and cross-match via tools connected through the Model Context Protocol), and verify work (re-check its own flags before surfacing them). Guardrails and a full audit trail are built in from day one, so every decision can be reconstructed.
Integrations
- Loan origination / core system
- Document store or intake inbox
- Optional: credit-bureau or bank-statement lookups
Under the hood
- The Claude Agent SDK runs the loop; tools are exposed to it via in-process MCP servers.
- Tools: a document-store reader, a vision/OCR extractor, a field-matcher, and (optional) a credit-bureau or bank-statement lookup.
- Guardrails: strict JSON-schema output, no write access to core systems, and PDPA-aligned handling of IC numbers, payslips and statements.
- Human-in-the-loop: the agent writes a structured review packet; the officer's decision is captured and logged for audit.
- Eval harness: a golden set of historical cases (including fraud) with deterministic checks; every change is regression-tested before it touches live applications.
Stage 5 · Architect
Single model or multi-agent?
Credit review is sequential and shares one case context, so a single well-instrumented model is the right call — reliable, cheaper, and easier to audit.
We reserve multi-agent designs (≈15× the tokens) for genuinely parallel, breadth-first work — not for a single, tightly-coupled case file.
Which model does what
Read & extract from documents (incl. scans)
Reliable vision and structured extraction on messy, real-world documents.
Cross-match & reason across the bundle
The workhorse — strong reasoning at moderate cost; handles the bulk of cases.
Resolve ambiguous / borderline cases
Invoked only when Sonnet flags low confidence — a small fraction of applications.
High-volume simple checks
Cheapest and fastest for bulk yes/no checks that don't need full reasoning.
What it costs — an estimate
AI usage — per application
input documents + reasoning + output summary, at Claude Sonnet token rates
~RM 0.60–1.20
AI usage — at 300 applications/month
roughly half with the Batch API for overnight, non-urgent runs
~RM 180–360 / month
Build (one-off)
a focused single-product agent is a few weeks of engineering; we quote fixed after a short discovery
scoped per integration
Ongoing
small next to the manual-review time it removes
monitoring + support
Indicative only, shown in Ringgit at roughly RM 4.70 to the USD; per-token rates follow Anthropic's published pricing (confirm current figures). Actual AI usage depends on document sizes and monthly volume.
Stage 6 · Evaluate
How we measure success
- Deterministic checks first — field matches, required months present, account consistency
- Self-verification — the agent re-checks its own flags before surfacing them
- Business KPIs — reviewer time per file, consistency, throughput, and misses caught
We score the agent with the Agent GPA framework — Goal, Plan, Action, a current standard for agent reliability — on top of the human baseline. (reference)
Setting the baseline
First we measure the current manual process on a sample — time per file, how consistently two reviewers reach the same conclusion, and how many issues slip through. That human baseline is what every agent metric is measured against, so the lift is provable rather than assumed.
What we test — Goal · Plan · Action
Agreement with a senior reviewer
Its summary, flags and recommended checks match an expert's on held-out cases
Required checks executed
Every mandated check is run — nothing skipped
No wasteful loops
It re-reads only when a check genuinely fails, not needlessly
Field extraction accuracy
Did it read each field — name, income, account — correctly?
Discrepancy recall (catch rate)
Of the real mismatches in the golden set, how many it flags
False-flag rate
How often it flags something that isn't actually a problem
No hallucinated figures
Every number in the summary traces to a source document
The go-live gate
The agent does not touch a live application until it beats the human baseline and clears these GPA targets on a golden set of historical cases — including known fraud. Every change is regression-tested against the same set before it ships.
Stage 7 · Deliver
How we'd deliver it
We start with a proof-of-concept on your real historical files — including the messy and fraudulent ones — and prove reliability before it touches live applications. A focused single-product rollout is a matter of weeks.
Free consultation
Is your credit team matching documents by hand?
Tell us your product line and volumes and we'll tell you honestly whether a credit evaluation agent is worth building — and what it would take.
Related use cases
Frequently asked questions
- Does the agent approve or reject loans?
- No. It reads, matches and flags; a human credit officer makes the approve or decline decision. Human-in-the-loop is essential for regulated lending in Malaysia.
- How is it kept compliant with BNM and PDPA?
- With a full audit trail so decisions can be reconstructed, and built around PDPA requirements for where credit data is processed, stored and accessed. Treat this as a starting point for your compliance team, not legal advice.
- How long does it take to deploy?
- A proof-of-concept for one focused product line is usually a matter of weeks; a full rollout takes longer, mostly because of integration and getting reviewers comfortable, not the AI.
Examples are based on real, anonymised engagements; details are generalised. Anchor Sprint is a member of the Anthropic Claude Partner Network — a deployment and rollout partner, not a reseller. This is general information, not legal or compliance advice.