Inside Nagare’s Financial Modeling Methodology

Who this is for: CIOs, performance analysts, and quants who care about how the numbers are actually computed. If you just want to know “can I trust this?”, start with Getting the Math Right.

For the full formal mathematical specification, refer to our whitepaper: The Nagare Financial Engine: A Stochastic Cohort-Based Projection Model.

This post explains how Nagare models:

• Private funds (capital calls, distributions, fees, carry)
• Public holdings (stocks, bonds, ETFs)
• Portfolio companies
• Monte Carlo simulations

…and how all of this fits together into a single, auditable system.

We focus on intuition first, then show the structure behind the scenes. Full formal specifications live in our internal docs (/docs/financial-modeling, /docs/monte-carlo).

---

1. Cashflow Engine: How We Represent a Fund

At the core, every private fund in Nagare is represented as a time series of cashflows and NAV:

• Capital calls (negative flows)
• Distributions (positive flows)
• Fees (negative flows)
• NAV marks (state, not flows)

We work in periods (typically months or quarters) and keep cashflows normalized to a single currency with explicit FX treatment.

Conceptually, for each period t:

• CF_t = net cashflow to LPs (negative = call, positive = distribution)
• NAV_t = fair value of remaining assets

From (CF_t, NAV_t) we derive IRR, TVPI, DPI, RVPI using standard private markets definitions. The important part is how we generate those sequences in a way that matches real LPAs and fee schedules.

1.1 IRR Calculation: Robust Numerical Methods

IRR (Internal Rate of Return) is notoriously difficult to compute reliably. Many tools use simple iterative methods that fail on edge cases. We use a three-tier approach for guaranteed convergence:

Tier 1: Newton-Raphson (Fast Path) For well-behaved cashflows, Newton-Raphson converges in 5-10 iterations:

r_{n+1} = r_n - NPV(r_n) / NPV'(r_n)

Where NPV'(r) is the derivative of NPV with respect to discount rate.

Tier 2: Brent's Method (Guaranteed Convergence) If Newton-Raphson fails to converge (oscillation, divergence), we fall back to Brent's method—a bracketing algorithm that combines bisection with inverse quadratic interpolation. It's slower but mathematically guaranteed to find a root if one exists.

Tier 3: MIRR Fallback (Non-Conventional Cashflows) For cashflows with multiple sign changes (e.g., capital call → distribution → capital call → distribution), multiple IRRs may exist. We compute MIRR (Modified IRR) instead:

MIRR = (FV_positive / PV_negative)^(1/n) - 1

This always produces a single, meaningful result.

Date-Aware (XIRR) All IRR calculations are date-aware, using actual day counts (365.25 days/year) rather than period counts. This matches Excel's XIRR function.

---

2. Fees and Carry: Matching Real LPAs

2.1 Management Fees

Nagare supports fee schedules that change basis over time, which is standard in institutional LPAs:

• Years 1–4: % of committed capital
• Years 5+: % of invested cost or NAV

At each period t, we compute:

fee_t = rate_t × basis_t

Where:

• basis_t is chosen from {committed, invested_cost, nav} according to the configured schedule
• rate_t can step down over time (e.g., 2.0% → 1.5%)

We enforce basic invariants:

• Fees are never applied twice on the same notional for the same period
• Changing basis cannot increase cumulative fees for identical cashflows unless explicitly configured

2.2 European Waterfall and Carry

For European waterfalls (the dominant structure we see), distributions follow this sequence:

1. Return of capital (LP gets committed capital back)
2. Preferred return / hurdle (e.g., 8% IRR on drawn capital)
3. GP catch‑up (GP receives most of cashflows until sharing ratio is restored)
4. Residual split (e.g., 80/20 between LP / GP)

In code, we work period‑by‑period but conceptually the GP carry C is:

1. Compute LP IRR before carry
2. Allocate cashflows to LP until hurdle is met
3. Route incremental cashflows to GP (catch-up) until target split is achieved
4. Split all remaining cashflows pro‑rata

We test these flows against known examples for:

• Different commitment levels
• Different outcome paths (slow vs fast exits)
• Edge cases (never reaches hurdle, very high performance)

The goal is simple: when your auditor runs their own waterfall in Excel, our numbers should match.

---

3. Exit Timing and Growth: From TVPI Targets to Paths

For a given fund, users configure:

• Target TVPI / IRR
• Deployment curve (how capital is drawn)
• Exit model (e.g., Weibull, log‑logistic, or competing‑risks for company-level modeling)

3.1 Cohort-Level Exit Models

For standard funds, we use parametric exit models calibrated to industry data (Cambridge Associates, Preqin):

• Weibull or log‑logistic distributions for time‑to‑exit
• Different parameter sets for VC, growth equity, buyout, real estate, etc.

This gives a probability that value is realized in each future period. Combined with growth assumptions, we can generate expected distributions and NAV paths that hit the user’s target TVPI.

3.2 Competing-Risks (Company-Level) Models

For portfolios where you model company‑level outcomes, we support a competing‑risks engine:

• Each company has hazards for different outcomes (IPO, trade sale, write‑off, continuation, recap)
• Hazards depend on age, sector, and optionally macro variables (e.g., VIX, credit spreads)
• Exits cluster: multiple companies can exit in the same period, which better matches real portfolios

The result is a more realistic, lumpy distribution profile and cohort survival curves for each vintage.

---

4. Market-Linked Monte Carlo: Alpha + Beta, Not Isolation

Most tools simulate private funds as if they were independent of public markets. We don’t.

For funds with equity‑like exposure (VC, growth equity, public‑style mandates), we model returns as:

r_t = α + β × r_market,t + ε_t

Where:

• α = manager skill / structural alpha
• β = systematic exposure to a chosen benchmark
• r_market,t = benchmark return (e.g., S&P 500, Nasdaq)
• ε_t = idiosyncratic noise

We then:

1. Sample market paths from historical data (via the Market Data Platform)
2. Calibrate α so that the fund still hits its target TVPI / IRR in a “normal” environment
3. Preserve risk by keeping β and volatility consistent with the chosen strategy

This is layered on top of the deterministic engine:

• Deployment and exit timing still come from the configured curves
• Market shocks tilt outcomes up or down and change timing

The output is P10 / P50 / P90 paths that move sensibly with market conditions, not just with internal noise.

---

5. Public Holdings and FX: One Portfolio, Many Currencies

Public holdings (stocks, bonds, ETFs) are modeled as:

• Position size (quantity)
• Instrument price series (from institutional data providers via our Market Data Platform)
• Optional income (dividends, coupons)

We avoid double‑counting income by distinguishing:

• Price return series
• Total return series

FX is handled separately:

• Each cashflow is stored in its source currency
• For reporting, we convert to a reporting currency using either:
  • Point‑in‑time FX (for historical/current views)
  • Latest FX (for “if today’s FX persisted” projections)

This matches how auditors and LPs expect multi‑currency reporting to behave.

---

6. Validation and Test Coverage

All of this would be academic if it weren’t tested.

Across the modeling engine and Monte Carlo stack we have:

• Unit tests for each building block (fees, carry, exit timing, FX)
• Scenario tests that mirror real LPAs and market environments
• Statistical tests for Monte Carlo (mean, variance, correlation, convergence)

We continuously validate against:

• Industry benchmarks (Cambridge Associates, Preqin)
• Real anonymized client portfolios (with permission)
• Independent expert reviews (documented in our internal review notes)

---

7. How to Use This as a Client

If you are a quant, risk analyst, or skeptical CIO, this is how to get comfortable:

1. Start from a real fund. Configure its fees, carry, and deployment exactly as in the LPA.
2. Verify deterministic outputs. Compare Nagare’s IRR/TVPI/DPI to your Excel model using the same cashflows.
3. Layer in Monte Carlo. Check that P10 / P50 / P90 ranges make sense against your historic experience.
4. Review assumptions. Ensure market data windows, α/β choices, and volatilities match your views.
5. Document and lock. Use snapshots so that assumptions and outputs are frozen for IC and auditors.

If everything matches, you now have a repeatable, auditable engine instead of a fragile spreadsheet.

---

Where to Go Next

• For a narrative overview, read: Getting the Math Right
• For Monte Carlo specifics, see: How We Validate Our Monte Carlo Engine
• For market data details, visit: Market Data Platform

If you’d like us to walk through your specific fund or portfolio with your quant team, we’re happy to do a working session and reconcile numbers line‑by‑line.