Millennium and Anthropic just partnered to build an AI-powered Digital Risk Analyst.

A TLDR of what it does: Anthropic's forward-deployed engineers will work with Millennium's technology and risk teams to build, pilot, and optimize a supervised AI teammate.

The stated goal is specific: interrogate risk data, explain daily changes, surface insights across asset classes, and retain context across follow-up questions.

There's 2 huge benefits of AI-powered risk systems (vs traditional manual systems):

1. LLMs can explain the WHY not just the what.
2. AI agents can more easily run autonomously

Which ultimately leads to improved systems for protecting capital:

• What changed in the portfolio?
• Which positions and factors caused it?
• Is the change real, or is the data stale?
• Did several apparently different positions become the same trade?
• Which market event matters?
• What happens if today’s move continues?

Today I'll show you how you can go about designing a risk system using AI agents. Note: This is based only on public interviews and public Github documentation from Millennium / Anthropic and combining it with my experience advising funds on their AI builds.

How the whole system works

Most funds already have systems that calculate positions, P&L, exposure, concentration, factors, sensitivities, and stress scenarios.

The missing layer is often the investigation around those numbers (explaining the WHY).

A dashboard can tell you that risk increased.

It rarely completes the next six steps:

• identify the driver
• trace it to positions
• connect it to market events
• test the relevant scenario
• detect contradictory data
• and write a useful explanation.

That is the job of the agent system.

The cleanest design has three layers:

The separation is important.

The truth layer calculates. The reasoning layer investigates. The decision layer decides.

If the LLM starts estimating risk numbers from prose, the architecture is already broken. Every material number should come from an authoritative function or system with an as-of time, units, methodology, and evidence ID.

The multi-agent architecture

Now that you understand how each of the silos fit in with each other (data vs AI vs human), let's dive deeper on the multi-agent architecture.

Here is what each component does:

1. Supervising orchestrator

This agent owns the investigation.

It receives a scheduled or event-driven trigger, checks the authorized portfolio scope, builds the plan, dispatches work, tracks state, and decides when the investigation is complete.

It also controls budgets:

→ Which agents can run

→ Which tools they can call

→ How many retries they get

→ How long the workflow can continue

→ What requires human review

The orchestrator should not perform every analysis itself. Its job is coordination.

2. Risk-delta agent

This agent establishes what changed.

It compares authoritative snapshots and calls deterministic tools for:

→ Position changes

→ P&L and drawdown

→ Exposure and sensitivity changes

→ Concentration

→ Limit utilization

→ Liquidity

Its output is structured, not narrative: the largest changes, their magnitude, the affected positions, and evidence IDs.

3. Exposure agent

Ticker symbols can hide the real portfolio.

Five different holdings might all depend on the same rate path, commodity, customer, geography, or volatility regime.

The exposure agent looks for:

→ Factor and beta changes

→ Correlated positions

→ Sector and geographic concentration

→ Currency and rates sensitivity

→ Crowded or duplicated exposures

→ Hedges that stopped offsetting the book

This is where a list of positions becomes a view of the portfolio’s actual economic bets.

4. Market-context agent

This agent investigates what changed outside the portfolio.

It searches filings, earnings transcripts, company announcements, macro releases, industry developments, and relevant news. It receives a bounded list of companies, factors, and questions from the orchestrator.

It should be isolated from portfolio write access. External documents are inputs to analyze, not instructions for the system to follow.

The output is a short evidence bundle: event, timestamp, affected entity, likely transmission path, and source.

5. Scenario agent

The first four agents explain the present. The scenario agent tests the next move.

It can ask:

→ What if the largest position falls another 10%?

→ What if rates move 50 basis points?

→ What if volatility rises across the book?

→ What if the hedge ratio breaks?

→ What if correlated positions sell off together?

The scenario calculations should come from approved code or an existing scenario engine. The agent chooses the relevant test and interprets the result. It does not silently invent the calculation.

6. Deterministic validation

Before another model reviews the findings, ordinary code should validate them.

This gate checks totals, units, signs, dates, currencies, data freshness, and whether the underlying tool calls completed successfully. These checks are cheaper and more reliable in code than in another LLM call.

Only validated outputs move to the critic.

7. Reconciliation critic

This is the component most people leave out.

The critic tries to disprove the first answer.

It checks:

→ Are the largest movements actually explained?

→ Does the cited market event affect this portfolio?

→ Did two agents reach contradictory conclusions?

→ Is a stale position or price creating a false alarm?

→ Which statements lack evidence?

When it finds a gap, it sends a targeted request back through the orchestrator. It does not restart the entire workflow or let the agents debate forever.

8. Risk brief composer

The composer receives the reconciled evidence and creates one ranked output:

1. What changed
2. Why it changed
3. Which positions and factors matter
4. How material it is
5. What the scenarios show
6. What remains uncertain
7. What the investor should investigate next

It should not produce 40 alerts.

It should decide which three issues deserve attention now.

9. Reviewed memory

The useful memory is not every conclusion the model has ever produced.

It is the information the investor reviewed and accepted:

→ Portfolio thresholds

→ Known data quirks

→ Recurring exposures

→ Thesis and kill criteria

→ Preferred scenarios

→ Corrections from prior reviews

That memory improves the next investigation without turning yesterday’s model mistake into today’s assumed fact.

How it runs in the background

The system can wake up on a schedule:

→ Pre-market review

→ Intraday portfolio scan

→ Post-close attribution

Or it can wake up because something happened:

→ A position moved beyond a threshold

→ Portfolio volatility changed

→ A concentration limit was approached

→ A company filed results

→ A macro release affected a material exposure

→ A hedge stopped behaving as expected

Imagine a major holding falls 9% before the open.

The risk-delta agent measures the position-level effect. The exposure agent finds three additional holdings tied to the same underlying factor. The context agent identifies a supplier warning and a macro release. The scenario agent tests another leg down. The critic discovers that part of the apparent currency exposure came from a stale conversion rate.

The investor does not receive five disconnected alerts.

They receive one brief separating:

→ The real loss

→ The hidden correlated exposure

→ The relevant external events

→ The stale-data problem

→ The scenario that now matters

That is what “running in the background” should mean. The system investigates before it interrupts.

Where you start your AI risk system buildout

Start with the data you already have:

→ Positions from your broker, custodian, database, or spreadsheet

→ Prices, returns, volume, and volatility

→ Basic factor and concentration calculations

→ Filings, earnings transcripts, and news

→ A small library of deterministic stress scenarios

Then build only three agents:

1. Portfolio monitor: What changed?
2. Context investigator: What might explain it?
3. Reconciliation critic: Does the explanation survive review?

Run the workflow before the open and after the close. Add event-driven scans only after the scheduled briefs are consistently useful.

The first assignment should be painfully specific:

Once that works, add the exposure agent. Then scenarios. Then reviewed memory. Then intraday triggers.

Millennium is building the institutional version with Anthropic’s engineers, frontier models, proprietary data, and a huge technology organization.

Your version can be much smaller.

The architecture is still the same:

→ Deterministic tools produce the numbers

→ Specialist agents investigate different dimensions of risk

→ A critic reconciles the work

→ A human makes the decision

Two final tips I'll leave you with:

1. Start small then expand. Make sure the foundations are correct.
2. Before you build anything, make sure you data pipes are clean and solid. The system will only be as good as your data!

Personal

As you saw, I'm hosting an AI for Excel modeling live training session August 24-26. If you want to learn how to build LBOs, 3 Statement Models, and Public Equities Earnings Models using AI, I'm teaching my same framework I have taught many other buyside funds in the past.

More details in the link below: