I Watched an AI Agent Model a EUR 744M Auto ABS Deal from Scratch

Not Extraction. Execution.

We gave an AI agent a PDF. The offering circular for a EUR 744M auto ABS deal. No parameters, no templates, no pre-formatted inputs. Just the document.

The agent indexed it. Searched through it to find the deal structure, tranche details, pool characteristics, fee mechanics, and swap terms. Then it took those extracted data points, ran them through deterministic cashflow tools, built a 60-period waterfall model, and produced a complete payment schedule.

The deal: Mercedes-Benz Silver Arrow Compartment 20. Two tranches, sequential pay, floating rate senior notes at EURIBOR + 43bps. The output: Class A retiring by September 2029, Class B clearing by February 2030, with every interest payment, principal allocation, and balance recalculated period by period.

All of this happened inside the agent. No human in the loop between document and model.

The Deal

Silver Arrow Compartment 20 is a German auto loan securitization issued in October 2025. The structure is clean: two classes, sequential pay, with a fixed-floating swap layered in.

The capital structure:

Class B provides 6% credit enhancement through subordination. A swap at 1.9519% fixed converts the pool's fixed-rate receipts into floating-rate payments for the senior notes.

Standard structure. The kind of deal you've modeled dozens of times in Excel. But the modeling still takes hours when you're building from scratch.

What Happened Under the Hood

This wasn't a chatbot summarizing a document. It was a hybrid agent architecture: a language model for reasoning and document comprehension, connected to deterministic tools for the parts where precision matters.

The input was a 179-page offering circular. Nothing else. No pre-filled templates, no parameter sheets, no human curation. Here's what the agent did:

1. Document indexing and faceted search.

The agent ingested the PDF and indexed it across multiple dimensions — definitions, entities, dates, numerical values, and document sections. Then it ran targeted queries against each facet to locate the specific data points needed for modeling.

It didn't just keyword-search the document. It queried definitions to find "Issue Date means 30 October 2025" on page 167. It searched temporal facts to confirm the first payment date of November 17, 2025 across pages 6, 43, and 56. It found the swap fixed rate of 1.9519% buried on page 174. Each value was cross-referenced against multiple occurrences in the document to verify consistency.

2. The distinction that would have broken the model.

One of the more impressive moments: the agent correctly identified that interest accrues from the Issue Date (October 30, 2025), not the Closing Date (August 31, 2025). That's a two-month difference. Using the wrong date would have produced a first-period interest payment roughly 4x too high, and every subsequent calculation would have been off.

The agent caught this because it searched for the interest period definition and found the governing language: "commencing on (and including) the Issue Date and ending on (but excluding) such first Payment Date." Eighteen days. Not seventy-eight.

3. Verified vs. estimated: the agent knows what it doesn't know.

Not every parameter was in the offering circular. The agent verified tranche balances, coupon rates, payment dates, swap terms, pool balance, and the 14-step waterfall priority — all with page-level citations.

But it also flagged what it couldn't find: the servicing fee rate and trustee fee rate aren't specified in the OC. Rather than hallucinating values, the agent applied industry-standard estimates (75bps servicing, 5bps trustee) and explicitly marked them as assumptions, not document-sourced values. That transparency is the behavior you want in a production workflow.

4. Deterministic computation in its own execution environment.

Once the parameters were assembled, the agent handed them to cashflow calculation tools running in its own code execution environment. No LLM arithmetic. The waterfall mechanics, prepayment curves, day count calculations, and balance tracking were executed by code — deterministic, auditable, and reproducible.

5. Flexible output.

The agent produced the full payment schedule and cashflow report as a PDF. But the same pipeline could write to Excel, push to a database, or feed directly into an existing risk system. The output format is a configuration choice, not an architectural constraint.

The language model decides what to calculate. The tools execute how. That separation is what makes the output trustworthy: every number traces back to a deterministic function, not a token prediction.

The Mechanics

The agent's deterministic tools handled the standard plumbing — Actual/360 day count conventions across periods ranging from 18 to 31 days, CPR-to-SMM conversion (9% CPR → 0.7828% SMM), and period-specific floating rate recalculation for EURIBOR + 43bps — correctly across all 60 periods.

Two mechanics are worth highlighting:

Sequential Waterfall Mechanics

The priority is rigid: Class A receives all available principal until it reaches zero. Class B receives current interest throughout but no principal until Class A clears. The agent maintained this sequencing for 46 consecutive periods without deviation.

Transition Logic When Tranches Pay Off Mid-Period

This is where most Excel models break. In period 47, Class A has EUR 14.35M remaining, but total principal available exceeds that. The agent correctly allocated EUR 14.35M to retire Class A, redirected EUR 6.74M to begin paying down Class B, and stopped calculating Class A interest from period 48 onward. No manual override. No IF statement to debug. The waterfall just worked.

The Numbers

The agent produced projections using base case assumptions:

Class A retires by September 2029 with EUR 54.1M total interest paid and a weighted average life of approximately 2.4 years. Class B receives current interest for 47 periods, then amortizes rapidly — clearing by February 2030 with EUR 1.8M total interest paid. Both tranches clear well before legal final maturity in 2033.

What Changes When Modeling Takes Minutes

How many deals have you passed on — not because the credit was wrong, but because the model wasn't ready in time?

These aren't exotic calculations. They're the exact mechanics that consume hours when you're building models from scratch in Excel. And that's the point.

The hard part of structured finance analysis was never the math. It was the time cost of implementing the math correctly for each deal. When that cost drops from hours to minutes, three things change:

You run more scenarios. A base case with 9% CPR and 0% CDR is a starting point. What happens at 15% CPR? At 5%? What if defaults hit 2% with 40% recovery? When each scenario takes minutes to generate, you stop asking "is this worth modeling?" and start asking "what else should we test?"

You stress test more assumptions. EURIBOR at 3.50% is today's rate. What does the deal look like at 2%? At 5%? How does the WAL shift? When does subordination start to erode under loss scenarios? These are the questions that drive investment decisions, and they require a model that already works.

You spend analyst time on questions that matter. The agent won't tell you whether 9% CPR is the right assumption for current market conditions. It won't tell you whether the swap counterparty risk is adequately mitigated. It won't make the investment decision. But it removes the bottleneck that sits between "I have a deal" and "I have a model I can interrogate."

Why This Matters

Most AI tools in finance sit in one lane: they extract, or they summarize, or they chat. None of those alone get you from a 179-page offering circular to a working cashflow model.

An LLM running waterfall math would hallucinate numbers. A traditional model without the LLM would need a human to spend hours extracting parameters and keying them in. The hybrid architecture bridges both: the language model reads the document and reasons about what matters, the deterministic tools execute the math with precision.

The entire pipeline — from PDF to payment schedule — happens inside a single agent session. No manual parameter entry. No formula debugging. No copy-paste from document to spreadsheet. The hard part shifts upstream, from calculation to judgment: assumption-setting, scenario design, and interpretation. That's where it should have been all along.

This is the kind of system we build at Prospekto. Not chatbots. Not document summarizers. End-to-end agent pipelines that do the work — with the auditability that regulated finance demands.

The full 60-period payment schedule is available in the cashflow report (PDF).

Want to see this on one of your deals? Contact us and we'll run it through our agent with you.