Interest Rate Model Families

Selecting an interest rate model is like choosing an engine for different aircraft—short-rate models power simple products with reliable speed, HJM handles complex term structure dynamics with flexible thrust, and market models excel for benchmark rates where precision matters most. Pick the wrong engine and you get either unnecessary complexity that slows your desk down or inadequate dynamics that misprice your book.

The point is: model selection isn't about sophistication. It's about matching calibration cost and runtime to the product you're actually pricing. A rates desk running Hull-White for Bermudan swaptions is leaving money on the table. A desk running full LMM for vanilla caps is burning compute for no edge.

Model Family Overview (The Landscape)

Three families dominate production rates desks. Each models a different state variable, which determines what you can calibrate to and what you can price efficiently.

The core principle: these families aren't competing alternatives—they're nested. HJM is the theoretical umbrella, short-rate models are a special case of HJM (with specific volatility structures), and the LIBOR Market Model is an HJM model where the state variables are discrete forward rates rather than instantaneous ones. Understanding this hierarchy prevents you from treating model selection as arbitrary.

Why this matters: when a structurer asks "which model should we use?", the real question is what instruments do you need to calibrate to, and what's your runtime budget? Everything flows from those two constraints.

Short-Rate Models (The Workhorse Family)

Short-rate models describe the evolution of the instantaneous short rate r(t). Everything else—bond prices, forward rates, swap rates—derives from this single state variable. That simplicity is both the advantage and the limitation.

Hull-White One-Factor (Where Most Desks Start)

The dynamics:

dr = [θ(t) − κr] dt + σ dW

Three parameters control everything:

• κ (kappa) ≈ 0.02–0.10: Mean reversion speed. Higher κ means rates snap back to the long-run level faster. For USD rates, κ ≈ 0.03–0.05 fits historical data well (implying a half-life of roughly 15–25 years for rate shocks).
• σ (sigma) ≈ 0.005–0.02: Volatility of the short rate. This drives option prices directly. Typical values correspond to 50–200 basis points of annualized rate volatility.
• θ(t): Time-dependent drift, calibrated exactly to the current yield curve. This is what makes Hull-White "no-arbitrage"—the model reprices every zero-coupon bond on the curve by construction.

Calibration inputs:

• Current yield curve → determines θ(t) analytically (you invert the curve to extract the drift function)
• Cap/floor volatilities → determines σ and κ via least-squares fit to at-the-money cap prices

Why practitioners like it: Hull-White gives you closed-form solutions for zero-coupon bonds and European options on bonds. You can build a trinomial tree in seconds and price a Bermudan swaption in ~10 milliseconds. For a trading desk that needs real-time pricing, that speed matters enormously.

Where it breaks down: One factor means the entire yield curve shifts in parallel (up or down, with some mean reversion). You can't capture curve steepening, flattening, or butterfly moves with a single factor. And the model produces a symmetric (normal) distribution for rates, which means no skew and no smile—fine for ATM pricing, inadequate for OTM swaptions.

The practical point: Hull-White 1F is the right choice when you're pricing vanilla caps, floors, and simple European swaptions where smile isn't critical and speed matters. It's wrong for anything where curve shape dynamics or skew drive the value.

Two-Factor Extensions (When Curve Dynamics Matter)

Adding a second factor dramatically improves curve dynamics. The G2++ model (two correlated Gaussian short-rate factors) is the standard extension:

dr(t) = [x(t) + y(t) + φ(t)] dt

where x(t) and y(t) follow correlated Ornstein-Uhlenbeck processes with different mean reversion speeds.

The point is: one factor controls short-end moves, the other controls long-end moves, and the correlation between them determines whether the curve tends to steepen or flatten. This captures the two dominant principal components of yield curve movement (which explain ~95% of curve variation historically).

The trade-off: G2++ doubles your calibration parameters (two κ values, two σ values, plus correlation ρ), but you still get analytical bond prices and fast tree-based pricing. Calibration takes ~5 seconds instead of sub-second, and Bermudan pricing runs at ~50 milliseconds—still fast enough for real-time use.

Use G2++ when: curve steepening or flattening trades are in your book, or when you need better swaption fit across multiple expiry-tenor pairs without going to full Monte Carlo.

HJM Framework (The Theoretical Foundation)

The Heath-Jarrow-Morton framework models the entire forward rate curve f(t,T) simultaneously. Instead of deriving the curve from a short rate, you model every point on the curve directly.

The dynamics:

df(t,T) = α(t,T) dt + σ(t,T) dW(t)

where f(t,T) is the instantaneous forward rate at time t for maturity T.

The key insight (and why HJM is elegant): Under no-arbitrage, the drift α(t,T) is completely determined by the volatility function σ(t,T):

α(t,T) = σ(t,T) × ∫[t to T] σ(t,s) ds

This is the HJM drift condition. It means you only need to specify volatility—the drift takes care of itself. One function (volatility) fully specifies the model. Everything else follows from no-arbitrage.

Calibration inputs:

• Yield curve (initial condition for f(0,T))
• Cap/swaption volatility surface → determines σ(t,T)
• Correlation structure for multi-factor versions

Why this matters for practitioners: HJM is the theoretical umbrella that proves short-rate models and market models are all consistent. But in its general form, HJM is non-Markovian (the evolution of forward rates depends on their entire history, not just current state), which makes implementation painful. You can't build a recombining tree. You need Monte Carlo simulation with path storage.

When to deploy HJM directly: path-dependent rate derivatives where the payoff depends on the full evolution of the curve—ratchet caps, range accruals, CMS spread options. If the payoff is path-dependent and the volatility structure is exotic (not captured by standard parametric forms), HJM gives you the flexibility to specify whatever σ(t,T) the market data demands.

The real play isn't avoiding HJM complexity entirely. It's recognizing that specific choices of σ(t,T) reduce HJM to simpler models. If σ(t,T) = σe^{−κ(T−t)}, you recover Hull-White. If you model discrete forward rates instead of instantaneous ones, you get the LIBOR Market Model. HJM is the theory; the other families are practical implementations.

Market Models: BGM/LMM (The Swaption Engine)

The LIBOR Market Model (also called Brace-Gatarek-Musiela or BGM) models discrete forward rates—the actual rates quoted in the market—rather than abstract instantaneous quantities.

The dynamics:

dL_i(t) / L_i(t) = μ_i dt + σ_i(t) dW_i

where L_i is the forward LIBOR rate for period [T_i, T_{i+1}].

Parameters:

• σ_i(t): Volatility of each forward rate. Typical values range from 15–30% (lognormal vol) depending on tenor and market regime. Often parametrized as exponentially decaying: σ_i(t) = (a + b(T_i − t))e^{−c(T_i − t)} + d
• ρ_ij: Correlation between forward rates. A full correlation matrix for 10 tenors means 45 parameters (that's why parametric forms like ρ_ij = e^{−β|i−j|} are essential)

Calibration inputs:

• Caplet volatilities → pin down individual σ_i (each caplet depends on exactly one forward rate)
• Swaption volatilities → constrain correlations ρ_ij (a swaption depends on multiple forward rates, so its price is correlation-sensitive)
• Skew/smile data → require extensions like shifted lognormal or SABR-LMM

The key insight: LMM's power comes from modeling market-observable quantities directly. When your calibration instruments are caps and swaptions (which they always are on a rates desk), having the state variables match the instruments eliminates a layer of abstraction. Caplet calibration is essentially exact—each caplet maps to one forward rate's volatility.

Where LMM earns its keep: Bermudan swaption pricing. A Bermudan swaption gives the holder the right to exercise into a swap on multiple dates. Pricing this requires modeling the joint evolution of all relevant forward rates and making an optimal exercise decision at each date. LMM handles this naturally because the swap rate at each exercise date is a function of the forward rates (which are the state variables).

The cost: LMM is high-dimensional. Modeling 10 forward rates means 10 correlated stochastic factors. No recombining tree exists. You need Monte Carlo simulation with Longstaff-Schwartz (or similar) for early exercise. Pricing a single Bermudan takes 2–5 seconds with adequate accuracy (vs. 10 ms for Hull-White on a tree).

Comparison Matrix (Side by Side)

Model Selection Triggers (The Decision Checklist)

Use these triggers to match model to product. Don't over-engineer—pick the simplest model that captures the economics of your payoff.

• Use Hull-White 1F when: you're pricing caps, floors, or simple European swaptions; smile is not critical to the value; you need sub-second calibration and millisecond pricing (real-time trading desk). This covers ~60% of vanilla rates products.

• Use G2++ when: curve dynamics drive the payoff—steepener trades, CMS spread notes, or when you need accurate swaption pricing across multiple expiry-tenor pairs simultaneously. The incremental calibration cost (~5 seconds) buys meaningfully better curve behavior.

• Use HJM when: you're pricing path-dependent rate exotics (ratchet caps, range accruals, snowball coupons) where custom volatility structures are needed. Accept the Monte Carlo runtime and implementation complexity because the payoff structure demands it.

• Use LMM when: you're pricing Bermudan swaptions or callable rate structures where matching the swaption volatility surface is critical to accurate exercise boundary determination. Deploy when your infrastructure supports Monte Carlo with Longstaff-Schwartz and you can tolerate 2–5 second pricing times.

The test: if you can price your product accurately with Hull-White, don't use LMM. Every step up in model complexity adds calibration risk (more parameters to fit means more ways to overfit) and operational risk (more code paths, more failure modes).

Operational Complexity (What It Actually Costs to Run)

Model sophistication has real infrastructure costs. Here's what each family demands in production:

For real-time trading desks (where you need prices in < 100 ms), Hull-White and G2++ dominate. Traders can't wait seconds for a quote.

For end-of-day risk (where you run overnight batch valuations), LMM accuracy justifies the runtime. A 5-second price multiplied by 10,000 positions means ~14 hours of compute—parallelizable, but it requires proper infrastructure.

For structured product desks (where you price a deal once, then hedge daily), calibrate LMM for the initial pricing, then use Hull-White with frozen parameters for daily risk sensitivities. This hybrid approach captures the best of both: accurate initial pricing plus fast daily Greeks.

Calibration Tenor Range (What You Actually Fit To)

LMM calibration requires a grid of swaption prices spanning the expiry-tenor space. Here's a representative calibration grid:

Calibrate to this grid, interpolate between points using a smooth parametric volatility surface, and validate out-of-sample by pricing swaptions not in the calibration set. If your out-of-sample errors exceed 1–2 vols, your parametric form is too restrictive (or your data has stale quotes).

Why this matters: the tenor range you calibrate to determines which products your model prices accurately. Calibrating only to the 1Y–5Y block and then pricing a 30-year callable will produce unreliable results because the model has no information about ultra-long dynamics.

Model Selection Takeaways

The pattern is clear: model families form a complexity spectrum, and the right choice depends on your product, your runtime budget, and your infrastructure.

• Start simple. Hull-White 1F handles the majority of vanilla rates products with minimal infrastructure and fast calibration. Don't upgrade until Hull-White demonstrably fails for your book.
• Upgrade for curve dynamics. When steepening/flattening matters (and it often does for structured notes), G2++ adds meaningful accuracy at modest cost.
• Deploy HJM for path-dependent exotics where you need custom volatility specifications that don't fit parametric short-rate forms.
• Reserve LMM for Bermudan swaptions and products where matching the full swaption surface is essential. Accept the operational cost because mispricing exercise boundaries on a large Bermudan book is more expensive than compute.
• Validate relentlessly. Whichever model you choose, test out-of-sample. A well-calibrated simple model beats an overfitted complex one every time.

For calibration and validation procedures across these model families, see Model Calibration and Validation. For the underlying swap products these models price, review Interest Rate Swaps: Fixed vs. Floating.