Autocallable Notes

An autocallable is a structured note that promises a high coupon, redeems early if the underlying stays above a trigger level on observation dates, and exposes the investor to downside losses only if the underlying drops below a knock-in barrier at maturity. They are everywhere in retail structured products — Korea, Hong Kong, Switzerland, and increasingly the US — because they look like a high-yielding bond that almost always autocalls in the first year. The "almost always" is doing a lot of work, and the pricing is what tells you whether the marketing copy holds up. This page builds a Monte Carlo pricer for a classic 1-year autocallable, runs it, and reads the result.

The structure

A typical 1-year autocallable on a single underlying:

• Notional: $100, paid by the investor at issue.
• Coupon: 8% annualized, accrued from issue date and paid only on redemption.
• Observation dates: quarterly — 3, 6, 9, and 12 months.
• Autocall trigger: 100% of the initial level $S_0$. If on any observation the underlying is at or above $S_0$, the note redeems early at par plus accrued coupon.
• Downside barrier: 70% of $S_0$. Only checked at maturity, only if the note never autocalled. If the spot finishes above the barrier, the investor gets back par. If below, the investor takes the equity loss one-for-one: payout is $\text{notional}\times S_T/S_0$.

Put together: in most scenarios the note autocalls early, the investor gets back par plus a coupon they wouldn't have earned in a deposit account, and everyone walks away pleased. In a small fraction of scenarios the underlying drifts down, the note survives all autocall dates without ever crossing back above the trigger, and at maturity the spot is below the barrier — at which point the investor eats the equity drop. That tail scenario is where the dealer's profit lives.

Why this is hard to price

Three features stack:

1. Multi-event path dependence. The payoff depends on the spot at each observation date AND on the terminal level. No closed form: knowing the terminal distribution of $S_T$ is nowhere near enough.
2. Conditional early redemption. The note autocalls if the spot is above the trigger AT THE FIRST observation date it does so — not at the highest level reached over the life. This is a "first-touch from below" condition that defies the kind of static replication we used for variance swaps.
3. Knock-in put at maturity. The downside leg is structurally a short put — barrier-conditional — that's only "activated" if the note survives all the autocalls. This couples the autocall dynamics to the terminal payoff.

Monte Carlo handles all of it cleanly. Simulate paths under risk-neutral GBM, walk through the observations in time order, mark each path as auto-called (with the corresponding payoff and time) or surviving, and discount appropriately. The pricing function is forty lines.

The pricer

"""
Autocallable note pricing via Monte Carlo.

Classic 1-year structure:
  - Notional $100, paid by the investor at issue.
  - 4 quarterly observation dates: 0.25, 0.50, 0.75, 1.00 yr.
  - Autocall trigger: 100% of initial level S0.
  - On each observation, if S_t >= trigger, the note redeems early
    paying back notional + accumulated coupons (8% annualized).
  - If never autocalled, at maturity:
      if S_T >= barrier (70% of S0): pay back notional
      if S_T <  barrier: pay back notional * (S_T / S0)
                          -- investor takes the equity drop one-for-one.
"""
import numpy as np

S0       = 100.0
r        = 0.05
sigma    = 0.20
T        = 1.0
n_paths  = 200_000
n_steps  = 252

NOTIONAL    = 100.0
TRIGGER     = 100.0   # autocall threshold (% of spot)
BARRIER     = 70.0    # downside knock-in level
COUPON_RATE = 0.08    # annualized
OBS_TIMES   = [0.25, 0.50, 0.75, 1.00]


def gbm_paths(S0, r, sigma, T, n_paths, n_steps, seed=42):
    rng = np.random.default_rng(seed)
    dt = T / n_steps
    Z = rng.standard_normal((n_paths, n_steps))
    inc = (r - 0.5 * sigma**2) * dt + sigma * np.sqrt(dt) * Z
    paths = S0 * np.exp(np.cumsum(inc, axis=1))
    return np.concatenate([np.full((n_paths, 1), S0), paths], axis=1)


def price_autocallable(paths, obs_times, trigger, barrier,
                       coupon_rate, notional, r, T):
    n_paths, n_pts = paths.shape
    n_steps = n_pts - 1
    obs_idx = [int(round(t * n_steps / T)) for t in obs_times]

    payoffs   = np.zeros(n_paths)
    pay_times = np.zeros(n_paths)
    autocall  = np.full(n_paths, -1, dtype=int)

    # Walk through observations in time order
    for k, (t_obs, idx) in enumerate(zip(obs_times, obs_idx)):
        not_yet = (autocall < 0)
        trig = not_yet & (paths[:, idx] >= trigger)
        coupon_accrued = coupon_rate * t_obs * notional
        payoffs[trig]   = notional + coupon_accrued
        pay_times[trig] = t_obs
        autocall[trig]  = k

    # Paths that never auto-called
    survived = (autocall < 0)
    S_T = paths[survived, -1]
    above = S_T >= barrier
    payoffs_terminal = np.where(above, notional, notional * S_T / S0)
    payoffs[survived]   = payoffs_terminal
    pay_times[survived] = T

    pv = np.exp(-r * pay_times) * payoffs
    return pv.mean(), pv.std() / np.sqrt(n_paths), autocall


# ---- Price and report ------------------------------------------------------
paths = gbm_paths(S0, r, sigma, T, n_paths, n_steps)
price, se, autocall = price_autocallable(
    paths, OBS_TIMES, TRIGGER, BARRIER, COUPON_RATE, NOTIONAL, r, T
)

print(f"Fair value:            ${price:.4f}   (SE = ${se:.4f})")
print(f"Premium / discount:    ${price - NOTIONAL:.4f} versus par")
print()
print("Probability of autocall at each observation:")
for k, t_obs in enumerate(OBS_TIMES):
    p = (autocall == k).mean()
    print(f"  Obs {k+1} at t={t_obs:.2f}:  {p*100:5.2f}%")
survived = (autocall < 0).mean()
breach   = ((autocall < 0) & (paths[:, -1] < BARRIER)).mean()
print(f"Survives to maturity:   {survived*100:5.2f}%")
print(f"  ... above barrier:    {(survived-breach)*100:5.2f}%   (pays back par)")
print(f"  ... below barrier:    {breach*100:5.2f}%   (knock-in loss)")

Output

Fair value:            $98.8940   (SE = $0.0141)
Premium / discount:    $-1.1060 versus par

Probability of autocall at each observation:
  Obs 1 at t=0.25:  52.92%
  Obs 2 at t=0.50:  13.01%
  Obs 3 at t=0.75:   6.53%
  Obs 4 at t=1.00:   4.08%
Survives to maturity:   23.46%
  ... above barrier:    21.10%   (pays back par)
  ... below barrier:     2.35%   (knock-in loss)

The fair value comes out at $98.89, a $1.11 discount to par. That discount is what the dealer charges for the structure — it's the fair compensation for the downside risk the investor is taking, less the time value of the coupons they earn in expectation.

Reading the knockout probabilities

The observation-by-observation probabilities tell most of the story:

52.9% autocall at observation 1. Just three months in, with 20% vol and an ATM trigger, more than half the paths drift back above the starting level and the note redeems. The investor gets $102 (notional plus 8% × 0.25 = $2 of coupon) and the trade is over after 90 days. From the investor's perspective this is the happy case — an 8% return for taking equity-shaped risk for one quarter.

23.5% survive to maturity. Of those, the great majority (21.1%) end up above the barrier and get back par with no coupon — they took the equity risk for a year and got nothing for it, because the autocall never happened and the structure doesn't pay coupons at maturity. From the investor's perspective this is the disappointing case: a year of equity-shaped exposure with zero return.

2.35% breach the barrier. Path drifted down to 70% of spot or below and stayed there at maturity. These investors take an equity-style loss — averaging roughly $40 lost per $100 invested in this scenario. This is the dealer's profit driver: the rare tail eats the expected value that funds the headline coupon.

The dealer's edge isn't the spread on each leg. It's that the headline 8% coupon looks generous compared to the deposit rate, but on average the investor receives roughly the risk-free return (and in expectation a bit less, which is the $1.11 discount). The whole structure is calibrated so the dealer can hedge the option-like exposure with vanilla puts and the autocall feature with forwards, and the residual is the profit margin.

Why they sell so well

Three reasons:

• Headline coupon. "8% annualized" is much more legible than "20% chance of finishing back at par with no coupon, 2% chance of losing 30 cents on the dollar, 60% chance of an early 2% return." Retail buyers gravitate to the coupon number.
• Implicit equity put-selling. The investor is short a barrier put. Selling puts has positive expected return on average — the same reason "covered call" funds attract money. Autocallables wrap that strategy in a note format with a coupon, which is easier to market than "sell an OTM put every year."
• Probability of early redemption is high in normal markets. The 53% autocall-at-first-observation in our example is typical: in vol-20% markets without strong drift, an at-the-money trigger gets hit early most of the time. Investors see early returns, recommend the structure, and the desk sells more.

What kills them

Autocallables sell well during calm markets and blow up when those calm markets turn. The autocall feature only fires when the spot returns to or above the initial level. If the underlying gaps down (Korean equity in March 2020, Chinese tech in 2022) and never recovers, every outstanding autocallable note from that vintage survives all observation dates, breaches the barrier at maturity, and pays back fractional notional. The losses are correlated across investors in the same vintage of notes, and dealer books with concentrated exposure can take serious losses too. The 2008 and 2020 episodes are textbook examples of this dynamic — when the trigger is at-the-money and a sustained drawdown happens, the entire vintage of notes loses money simultaneously.

Practical notes

• Vol and skew sensitivity. The note is short volatility on the downside (the short put leg) and long the trigger-hitting probability (which is also vol-sensitive). Net, the note tends to be SHORT vega on average but the exact sign depends on time-to-next-observation. With skew, the embedded put is priced off downside vol — meaning autocallable pricing is highly skew-sensitive, and a Black-Scholes flat-vol pricer like the one above will mispice a real-world structure unless calibrated to the smile.
• Correlation in basket autocallables. Many real autocallables are on baskets (worst-of two or three underlyings). The "worst-of" feature makes the trigger HARDER to hit (any single weak underlying knocks you out of autocalling) and the barrier EASIER to breach. Basket autocallables are correlation-short — they get more expensive in a correlation crisis.
• Hedging is delta-gamma-vega messy. Around each observation date the delta of the note has a discontinuity (the autocall flips state). Dealer books typically warehouse this and re-hedge through the observation rather than dynamically hedging through the discontinuity itself.
• Greeks blow up near the trigger. The gamma is concentrated around the trigger on observation dates. A near-trigger spot just before an observation is the most dangerous risk profile for the dealer — small spot moves change the payoff regime entirely.
• Pricing dependencies. A serious autocallable pricer needs: a local-vol or stochastic-vol surface (not Black-Scholes flat vol), a dividend-discount model (these notes are usually on dividend-paying indices), a correlation surface for baskets, and either Monte Carlo with millions of paths or a tree/PDE method for the multi-observation embedded options. Production systems often use Longstaff-Schwartz-style regression for the early-redemption decision, even though the autocall rule is technically deterministic, to support more complex variants (Bermudan callable, conditional coupons).

Related on this site

Exotic options covers the building blocks (barriers, digitals) that an autocallable composes. Variance swaps are the opposite extreme — a structured payoff that DOES admit clean static replication. Heston model is the natural step up from flat Black-Scholes vol that's used in production for these notes. American options and Longstaff-Schwartz is the related machinery for early-exercise / early-redemption rules.