# Asian option: arithmetic average

PricingLab by Raganel Consulting, powered by MatLogica AADC

## What it values

An Asian option pays out on the average price of the underlying over the option's life, not on its price on the last day. A call pays the amount by which that average ends above the strike. Averaging smooths out the effect of one bad day, so Asian options are cheaper than ordinary options and suit buyers who are exposed to an average price anyway, such as a company that buys fuel or a commodity every day of the year. This model prices an arithmetic-average Asian call and returns how the price moves with the underlying price (delta), volatility (vega) and the interest rate (rho).

## Who uses this kind of number

Commodity and energy traders, corporate treasurers hedging a stream of purchases or sales, currency desks, and risk and validation teams checking dealer quotes.

## Inputs

| Name | Unit | Default | Meaning |
|---|---|---|---|
| `spot` | price | 100 | Current underlying price |
| `strike` | price | 100 | Strike on the average |
| `vol` | fraction/yr | 0.20 | Volatility |
| `rate` | fraction/yr | 0.05 | Risk-free rate, continuously compounded |
| `maturity` | years | 1.0 | Time to expiry |
| `fixings` | count | 252 | Number of equally spaced averaging dates (252 at most on the free hosted service) |
| `n_paths` | count | 131,072 | Monte Carlo paths (262,144 at most on the free hosted service) |

Every input has a supported range; `describe_model` lists it. Any input you leave out takes its default.

## Outputs

- **Value**: the option price, in the same currency as the spot price.
- **delta**: change in price per 1.00 change in the spot price.
- **vega**: change in price per 1.00 change in volatility (per 0.01, divide by 100).
- **rho**: change in price per 1.00 change in the interest rate (per 0.01, divide by 100).
- **Timing** of the calculation in milliseconds.

## How the sensitivities are computed

The model simulates the underlying price along many paths, records it on each averaging date, and pays the call on the average. Delta, vega and rho come from that same run, in one forward pass and one backward pass over the calculation (adjoint algorithmic differentiation).

## How they are checked

**Against bump-and-revalue.** The `check_against_bumping` tool nudges each input up and down, re-prices on the same random paths, and reports the gaps. Measured on 5 November 2026 at the default inputs, 131,072 paths and 252 fixings, on two cores of an Intel Xeon 8280L:

| Sensitivity | One pass | Bump-and-revalue | Gap (relative to the largest sensitivity) |
|---|---|---|---|
| delta | 0.58917 | 0.58911 | 0.0002% |
| vega | 21.7060 | 21.7064 | 0.001% |
| rho | 24.5823 | 24.5804 | 0.008% |

All agree within the 2% tolerance the check applies. The one-pass calculation took 213 ms; bump-and-revalue needed 6 valuations and took 880 ms.

**Against an independent pricer.** There is no exact formula for an arithmetic-average Asian option, so the price is compared with QuantLib, the open-source pricing library. Its Monte Carlo engine for discrete arithmetic averages (200,000 samples with a control variate) gives 5.78269 ± 0.00079 for a one-year at-the-money call with spot and strike 100, volatility 20%, rate 5% and 252 daily fixings. This model gives 5.78297 with 262,144 paths, with a Monte Carlo standard error of about 0.013, so the two agree within one standard error.

## What the model includes

- One arithmetic-average call, European exercise, with equally spaced averaging dates.
- The underlying follows the Black–Scholes model: lognormal, with constant volatility and interest rate and no dividend yield.

It is designed to price standard arithmetic-average Asian calls and their hedge sensitivities, with every number checkable against bumping and against an independent pricer.

## Worked example (default inputs)

A one-year at-the-money Asian call, spot and strike 100, volatility 20%, rate 5%, 252 daily fixings. Run on 5 November 2026 with 131,072 paths:

| Output | Result |
|---|---|
| Price | 5.7749 |
| delta | 0.5892 |
| vega | 21.71 per 1.00 of volatility (about 0.217 per volatility point) |
| rho | 24.58 per 1.00 of rate (about 0.246 per percentage point) |

The price is a Monte Carlo estimate; the reference value above is 5.78269. The value with all three sensitivities took 182 ms.

## Three ways to use it

**1. From an AI tool, through the hosted MCP endpoint.** In any MCP client, add a remote server with this address and no authentication:

```
https://mypricinglab.com/lab/mcp
```

Then ask, for example: "Price the Asian option with 30% volatility and compare its vega with the defaults." The tools are `list_models`, `describe_model`, `price_model`, `check_against_bumping` and `run_model_function`. The hosted service is free, needs no login, and caps the number of paths and fixings.

**2. In Excel.** Install the PricingLab add-in and open the workbook `PricingLab_AsianOption.xlsx`. Instructions and downloads: https://mypricinglab.com/excel

**3. On your own machine.** The local install runs the same tools with no size caps, and your inputs never leave your machine. It is sent on request (Linux x86-64 today; ask about Mac and Windows): write to info@mypricinglab.com. Once installed:

```
pricinglab mcp      # MCP server for a local MCP client
pricinglab serve    # local web server for the Excel workbook
```

Details: https://mypricinglab.com/install

## With login

A private hosted service, with your own trades and larger runs, is available. Contact us.

## Contact

PricingLab by Raganel Consulting, powered by MatLogica AADC. To run this on your own book, inside your own network, write to info@mypricinglab.com.