MCP-ready engine
Give your AI agent a specialized engine for loan package review.
Loan Intelligence ingests complete or partial loan packages through MCP, API, or the workspace, runs deterministic extraction and calculation, evaluates them against your uploaded credit policy, and returns review-ready facts, missing-item lists, policy compliance status, and source-linked outputs.
New accounts start with credits. No payment details required.
The real bottleneck
AI agents can only carry so much in one session.
A real loan package has 10–30 source documents. Pasting them into a single agent run exceeds practical context windows, forces chunked hand-offs, and degrades accuracy. Cross-document relationships get lost. Items get missed. The same work gets rebuilt every session.
Enterprise models are expensive and still fragile. Teams pay premium per-token rates, then re-verify outputs, then re-process when a missing document arrives. The cost compounds.
Agents lose track across 10–30 source documents.
Each session rebuilds the methodology from scratch.
Token costs scale with every re-prompt and re-run.
Manual review is slow, inconsistent, and hard to benchmark.
Why a specialized engine
A system that checks, not a tool you prompt.
Generic AI can review a pasted document. Loan Intelligence treats the loan package as the central object and returns the same methodology, every run.
| Capability | Manual review | Generic AI | Enterprise LOS | Loan Intelligence |
|---|---|---|---|---|
| Handles 10–30 document packages reliably | ||||
| Reproducible methodology across runs | ||||
| Source-linked outputs | ||||
| Missing-item checklist | ||||
| Deterministic DSCR / LTV / payment calculations | ||||
| Quoted cost before work starts | ||||
| Native MCP + API + workspace access | ||||
| Credit policy compliance |
What Loan Intelligence does
Built around the document, the policy, and the calculation.
MCP-ready for agents
Connect Claude, Cursor, Codex, or any MCP client to the Loan Intelligence engine. Agents can quote, submit, and retrieve results through a single JSON-RPC endpoint.
The package is the object
PDFs, uploads, and Drive folders become extractable source documents with checksums, page counts, and source-linked outputs. Not a chat thread. A package.
See what is missing before the underwriter does
Every package returns a missing-item checklist and deterministic calculations where inputs allow, so review teams know exactly what still needs attention.
Evaluate against your credit policy
Upload your policy and the engine extracts your LTV, DSCR, FICO, eligibility, and document rules. Each package gets a clear inside_box / conditional / outside_box status.
Credit policy compliance
Your policy, your rules, your inside_box / outside_box status.
Generic checklists force reviewers to map every loan to a one-size-fits-all template. Loan Intelligence reads your actual credit policy and evaluates each package against the thresholds, exclusions, and document requirements you define.
Numeric rules like LTV, DSCR, and FICO are evaluated deterministically. Eligibility rules, exclusions, and document-checklist completeness are evaluated with those numeric results locked, so the assessment is grounded in extracted facts, not prompt drift.
Upload your policy
PDF, Markdown, or structured spec. The engine extracts numeric rules, eligibility, exclusions, and required documents.
Evaluate every package
The best-matching active policy is applied. Numeric rules run in code; AI evaluates eligibility and exclusions with locked numeric inputs.
Review clear outputs
inside_box, conditional, or outside_box status; compliance score; per-rule results with citations; and a remediation plan.
How it works
From files to review-ready in three steps.
Upload or connect
Drop PDFs, call the API, or connect a Drive folder. The quote is shown before any work starts.
Engine processes
The engine extracts facts, runs deterministic calculations, flags missing items, and evaluates the package against your uploaded credit policy.
Review and act
Download reports, spreadsheets, and task lists — all source-linked for human or agent review.
Trust & control
Designed for regulated work.
Loan Intelligence provides decision support and does not make credit decisions. Source documents are processed ephemerally with zero retention. Deterministic DSCR, LTV, and payment metrics are calculated when required inputs are present.
MCP endpoint
/api/plugins/mcp/mcpDecision support only
No credit decisions, no autonomous approvals.
Starter credits
Start processing before entering payment details.
Agent-native
MCP, API, and workspace share one engine.
Deterministic output
Same methodology, same result, every run.
FAQ
Questions a lending team or agent operator should ask first.
The most important product questions are about what the engine actually does, how agents use it, where credits are captured, and what data is kept out of the public contract.
Loan Intelligence is a purpose-built loan package intelligence engine. It accepts complete or partial packages through the workspace, API, or MCP; extracts borrower, property, income, collateral, and document facts; calculates deterministic metrics when the inputs exist; evaluates against uploaded credit policy; and returns source-linked review outputs. It is decision support, not an automated loan approval system.
A general AI model reviews whatever fits inside a session. Loan Intelligence treats the package as the object: source documents are staged for processing, quoted before work starts, run through a worker and engine adapter, and returned as durable status, result, source-reference, and credit records. The agent does not need to hold 10-30 documents in context or rebuild the review method every run.
Yes, after a human creates the workspace account and API key. An agent can use MCP or the HTTP API to quote a package, submit source documents, poll status, retrieve results, list prior packages, and read credit balance. Humans still control the account, key rotation, credit policy, and final lending decisions.
Start with the source documents that define the loan: application or request summary, borrower/entity documents, income or rent support, property and collateral files, and any lender checklist or credit policy. Complete packages produce richer outputs, but partial packages are useful because the engine returns a missing-item list instead of pretending the file is complete.
Inline source payloads are staged only so the worker and legacy engine can process them, then purged after durable billable outputs are captured. Durable records keep package metadata, status, source references, and generated outputs. Browser and MCP responses do not expose queue keys, staged payloads, AppData/cache heads, or internal idempotency details.
The product quotes the package first, reserves credits before processing, and captures credits only after durable billable outputs exist. If processing fails before capture, the reservation is released through the product ledger path. New accounts start with credits and no payment details are required for starter use.
Ready to give your agent a loan package engine?
Start with credits today. Upload files, call the API, or connect through MCP.
Open workspace