This weekend I was on the couch with my family watching old Godzilla films from the 1960s — the ones, with rubber suits and miniature cities getting lovingly stomped to pieces. It crashed into something I’d been working on: a small personal experiment to integrate Open Source Risk Engine into an AI LLM Agent for stress testing, mostly to learn about LLM and AI agent design.

What would a kaiju attack do to a portfolio?

That question — which I accept is not entirely sane — became this post. What follows is equal parts risk management, coding and Saturday night movie session.

So picture this: It’s a Tuesday morning in Asia. The stock market is calm. Your risk dashboard shows a sea of reassuring greens. And then, from the depths of the ocean, it rises.

A giant lizard monster — let’s call it Macrozilla.

Within hours, a second creature appears: Volamoth, a giant moth-like kaiju, over a capital in Europe, apparently not wanting to miss out. Capital markets, as it turns out, are not designed for kaiju.

Now here’s my actual question: what would that do to a credit and equity portfolio?

This is the scenario I fed to my latest project: the Economic Scenario Stress Test Agent. And yes, the agent took it completely seriously.

What Is This Thing?

The idea is simple enough. Risk managers spend a lot of time running stress tests: “what if rates go up 200bp?”, “what if equities crash 30%?”. But how about translating a narrative scenario — the kind that comes out of a board room or a regulator’s imagination — into a concrete set of market shifts.

What if an LLM could do that translation for you?

That’s the core idea. You describe a scenario in plain English (or, as we’ll see, in slightly unhinged science fiction), and the agent:

1. Finds the closest historical analogues from a knowledge base of real market crises
2. Derives a weighted market shift across rates, FX, equities and credit
3. Generates the Open Source Risk Engine (ORE) stress test XML automatically
4. Runs the Open Source Risk Engine via its Python API
5. Produces a narrative P&L report explaining what happened and why
   

The whole thing runs in a single command. Here’s what that looks like:

python agent.py --scenario "Giant monsters emerge from the ocean and destroy Tokyo and London simultaneously, triggering martial law, insurance system collapse, and a global flight to safety"

This is an actual command used to run the scenario — slightly unconventional, but effective.

The Architecture

The agent is built as a linear pipeline, just four sequential steps that talk to each other via structured JSON and files.

  User describes scenario

           │.          

           ▼

┌─────────────────────────┐

│ 1. Scenario Analyzer    │ GPT-5.2 + 20-scenario knowledge base

│ (historical lookup)     │

└───────────┬─────────────┘

            │ structured JSON of market shifts

            ▼

┌─────────────────────────┐

│ 2. Stress Test Builder  │ generates agent_stress.xml for ORE

└───────────┬─────────────┘

            │ ore_agent.xml + Input/agent_stress.xml

            ▼

┌─────────────────────────┐

│ 3. ORE Runner           │ runs ORE (Python API)

└───────────┬─────────────┘

            │ Output/stresstest.csv

            ▼

┌─────────────────────────┐

│ 4. Impact Summarizer    │ Markdown report + LLM summary of the results

└─────────────────────────┘

The most interesting piece is step 1. The ScenarioAnalyzer loads a knowledge base of historical episodes — things like the 2008 Financial Crisis, the 2001 Dot-com Bust, the 2011 US Debt Ceiling Crisis — each annotated with structured market shifts across rates, FX, equities and credit. The LLM reads the user’s scenario, picks the closest matches, and returns a blended shift vector in JSON.

From scenario_analyzer.py — the LLM gets the scenario text and the

# full knowledge base, and returns something like this:

{

"matched_scenarios": ["2008 Financial Crisis", "9/11 Shock"],

"reasoning": "Simultaneous destruction of two major financial centres…",

"shifts": {

"fx": { "USDJPY": 15.0, "EURGBP": -0.05 },

"equity": { "JPY": -0.55, "EUR": -0.35, "USD": -0.20 },

"rates": {

"JPY": { "1Y": -0.015, "5Y": -0.012, "10Y": -0.010 },

"USD": { "1Y": -0.020, "5Y": -0.016, "10Y": -0.012 }

},

"credit": { "EUR": { "5Y": 0.012 }, "USD": { "5Y": 0.008 } }

}

}

Step 2 takes that JSON and writes it into a valid ORE StressTest XML. Step 3 calls the ORE Python bindings to run the actual risk calculation. Step 4 parses the output CSV and asks the LLM to narrate the results.

The whole thing — LLM calls, ORE run, report generation — takes a few seconds.

Running the Kaiju Scenario

Here’s a condensed version of what the agent actually produced:

 ══════════════════════════════════════════════════════════╗

║ Economic Scenario Stress Test Agent                      ║

╚══════════════════════════════════════════════════════════╝

Analyzing scenario: "Giant monsters emerge from the ocean and destroy two major capitals in Europe and Asia simultaneously, triggering martial law, insurance system collapse, and a global flight to safety"

 Step 1/5 Analyzing scenario with LLM …

✓ Scenario analysis complete

Matched scenarios:

• 2008 Global Financial Crisis (Sep 2008 – Mar 2009)

• 2020 COVID-19 Crash (Feb – Mar 2020)

• Eurozone Break-up (Tail Risk) (Hypothetical)

Reasoning: Simultaneous destruction of major capitals with martial law and insurance-system collapse implies an extreme, sudden global risk-off/liquidity shock (GFC/COVID-like) plus acute Europe-specific tail risk and EUR dislocation (Eurozone break-up proxy). Weighted blend emphasizes severe credit stress and safe-haven bid, with EUR underperformance; scaled up to reflect catastrophic severity beyond typical historical episodes.

Proposed market shifts:

FX EURUSD: -0.1875

Equity EUR: -63.7%

Equity USD: -48.0%

Rates EUR: 1Y -8bp 2Y -9bp 3Y -9bp 5Y -6bp 10Y -4bp 30Y -2bp

Rates USD: 1Y -225bp 2Y -240bp 3Y -240bp 5Y -225bp 10Y -180bp 30Y -135bp

Credit EUR: 1Y +270bp 2Y +375bp 3Y +435bp 5Y +495bp 10Y +465bp

Credit USD: 1Y +225bp 2Y +300bp 3Y +360bp 5Y +420bp 10Y +375bp

Credit Sovereign: 1Y +675bp 2Y +945bp 3Y +1080bp 5Y +1215bp 10Y +1080bp

‘…catastrophic severity beyond typical historical episodes…’, the LLM is telling us that Macrozilla and Volamoth are worse than 2008. Which is not an unreasonable conclusion.

The ORE stress test then ran against a small toy portfolio containing interest rate swaps, equity CFDs, a cross-currency swap and a CDS. The result:

════════════════════════════════════════════════════════════
  Portfolio Stress Test Impact Report
════════════════════════════════════════════════════════════

  TOTAL P&L: -20,452,247 EUR  [▼ LOSS]

┌───────────────┬────────────┬──────────────┬─────────────┐
│ Trade         │   Base NPV │ Stressed NPV │  P&L Impact │
├───────────────┼────────────┼──────────────┼─────────────┤
│ XccySwap      │    268,878 │  -18,241,162 │ -18,510,040 │
│ EquityCFD_USD │     76,647 │   -3,119,320 │  -3,195,967 │
│ EquityCFD_EUR │  1,263,244 │   -1,709,064 │  -2,972,308 │
│ EUR6MSwap     │  5,924,804 │    5,774,330 │    -150,474 │
│ CDS           │ -6,405,864 │   -2,029,322 │  +4,376,542 │
├═══════════════┼════════════┼══════════════┼═════════════┤
│ TOTAL         │  1,127,710 │  -19,324,538 │ -20,452,247 │
└───────────────┴────────────┴──────────────┴─────────────┘

A Quick Word on Open Source Risk Engine

If you’ve been following this blog you probably know QuantLib. ORE, the Open Source Risk Engine, is built on top of QuantLib and takes it a significant step further: it’s a full risk analytics platform and is extending the model and product coverage.

Where QuantLib gives you individual pricing functions, ORE gives you the whole pipeline: a portfolio loader, a market data layer (discount curves, index fixings, vol surfaces), a set of configured analytics, and structured output reports. You describe everything in XML — your trades, your market, your analytic configuration — and ORE runs the job and writes out results.

ORE provides Python bindings (from ORE import *), which is what this agent uses — alternatively, it could be run via a subprocess call to the CLI.

https://github.com/OpenSourceRisk/Engine

What I Learned (and What’s Broken)

I want to be upfront: this is a proof-of-concept I built to learn about AI agents and ORE integration. Several things are either shortcuts or outright wrong for production use.

The historical scenarios are fake. About 20 episodes in data/scenarios.json are AI-generated approximations of real market moves, not rigorously sourced data. For anything serious, you’d want auditable, vendor-sourced market shift data.

The LLM’s blending logic is a black box. Right now the model picks scenarios and returns a blended shift in a single step. That makes it non-reproducible — run the same prompt twice and you might get slightly different numbers. A proper architecture would separate the LLM’s qualitative judgement (which scenarios? how severe?) from the quantitative calculation (the actual shift), keeping the latter deterministic and auditable.

No volatility or correlation shifts. The agent only shocks spot rates and equity levels. A real stress test would also need to move implied volatility surfaces, correlations, and basis spreads. The day Macrozilla shows up, vol doesn’t just stay flat.

No sanity checks on the shifts. There is nothing stopping the LLM from proposing a equity move of -150%, or a negative FX spot rate. In practice, for this toy example, the outputs were reasonable — but I wouldn’t trust that for production.

Why I Built This

The honest answer is that I wanted to understand:

• How to build a multi-step LLM agent that integrates with Open-Source Risk Engine
  

Model Risk

A key model-risk question is: does the agent behave consistently under small changes in wording? If two descriptions are semantically identical, they should retrieve the same historical analogues, produce similar shock vectors, and land in the same P&L ballpark. That’s testable. That’s something worth exploring.

Next steps

Validation and model risk — testing whether the agent produces consistent results under small changes in wording or temperature. If two semantically identical scenarios produce materially different shock vectors, that’s a problem worth understanding.

LLM-as-judge loop — adding a second LLM call that acts as a critic, sanity-checking the proposed shifts before they reach ORE. Negative FX rates and equity moves beyond -100% shouldn’t make it through. A classic pattern in agent design, and an instructive one.

Separate LLM and stress scenario model — keeping the model’s role purely qualitative (which scenarios? how severe?) and letting deterministic, auditable code handle the actual shift calculations. Probably the most important architectural lesson in the whole project.

Extended configuration builder — supporting volatility surface shocks, correlation shifts, and commodity curves, rather than the current one-size-fits-all template.

Tool-calling and true agentic behaviour — rather than a fixed pipeline, expose more ORE analytics like NPV, stressed sensitivities, stressed cashflows, and stress tests as individual tools and let the agent decide which to invoke based on the user’s question. This is where it gets genuinely interesting: “how would my sensitivities change if this happens?” or “what does this scenario do to my cashflows?” become natural queries the agent can reason about and answer autonomously.

Conversational memory — can the agent maintain scenario context across follow-up questions? “Now make it more severe” or “what if only Europe is hit?”

The code is available on GitHub as part of my IPythonScripts repository. It is an early prototype — it relies on LLM calls that incur cost, and the portfolio is a small toy example — but it demonstrates the end-to-end integration of an LLM-driven workflow with ORE.

https://github.com/mgroncki/IPythonScripts

So long…

Illustration generated with AI, All scenarios, market shifts, and monster attacks in this post are fictional. The PnL losses, however, are computed by a real risk engine and are entirely the fault of the monster.