Risk node guide

What are flies in options volatility?

A volatility fly measures how rich the wings are relative to ATM. It turns smile curvature into a compact risk node.

Wing average / ATM volatility / convexity by expiry.

Updated July 7, 202625Δ flyCurvature metric

The core idea

Fly removes the skew direction and keeps the smile curvature.

Risk reversal asks which wing is richer. Fly asks whether the wings together are richer than the middle of the smile. That makes it useful for monitoring convexity, event premium, and wing quote quality across the volatility smile and volatility surface.

01

Measure both wings

Use same-expiry put and call nodes, commonly 25-delta or 10-delta.

02

Average the wings

The wing average removes the signed skew component and focuses on curvature.

03

Compare with ATM

Subtract ATM implied volatility to see how rich the wings are versus the smile body.

A positive fly means the average of the two wings is above ATM. A negative fly means the average wing volatility is below ATM under the chosen convention.

Formula

Average the put and call wings, then subtract ATM volatility.

The most common volatility fly quote uses the same delta on both wings and the same expiry. This guide uses 25-delta nodes.

Fly25Δ=IV25Δ put+IV25Δ call2IVATM

25-delta fly definition

A 25-delta fly is an expiry-matched wing average minus ATM volatility.

The useful definition is narrow because the metric is a risk node, not a loose description of curvature. Derivasys reads the 25-delta put, 25-delta call, and ATM level from the same fitted SVI smile, then publishes the fly beside risk reversalsand quote-through-fit diagnostics.

Same expiry

The put wing, call wing, and ATM point should all come from the same expiry slice.

Same delta bucket

A 25-delta fly uses the 25-delta put and 25-delta call. Mixing 10-delta and 25-delta wings changes the curvature node.

Explicit ATM source

The ATM level should come from the fitted smile or an agreed ATM convention, not an arbitrary listed strike.

Vol-point units

A fly is usually shown in volatility points, so the API and dashboard should not confuse it with premium or PnL.

Construction workflow

A fly node is reproducible only when delta bucket, ATM source, and smile fit are explicit.

A fly looks simple, but production systems need strict node definitions. The 25-delta put, 25-delta call, and ATM level should come from the same accepted smile, usually the fitted SVI slice. If one wing is interpolated or extrapolated, that quality flag should travel with the published fly.

Choose the delta bucket

A 25-delta fly and a 10-delta fly describe different wing regions, so the delta bucket has to be part of the node name.

Resolve the ATM level

ATM may come from the forward strike, a fitted smile value, or a fixed-tenor convention. The source changes the fly.

Read both wings from one fit

The put wing, call wing, and ATM value should come from the same accepted SVI smile state, not mixed quote snapshots.

Store provenance

The node should carry source expiry, fit timestamp, residual status, interpolation share, and whether either wing is extrapolated.

accepted smile -> delta bucket -> put wing + call wing -> ATM source -> fly risk node

Worked example

If the wings average 60.5% and ATM is 56%, the fly is 4.5 vol points.

With a 65% put, a 56% call, and 56% ATM volatility, the average wing is 60.5%. The fly is 60.5% - 56.0% = 4.5 volatility points.

25Δ put IV

65.0%

25Δ call IV

56.0%

Wing average

(65.0 + 56.0) / 2 = 60.5%

Fly

60.5 - 56.0 = 4.5 vol points

Interpretation

Fly and risk reversal together separate curvature from signed skew.

A fly should almost never be read alone. The same fly value can hide very different put-wing and call-wing shapes. Pairing it with the risk reversaland the underlying smilemakes it clear whether wings are rich together, one wing is moving directionally, or the SVI fit is reacting to sparse data.

Fly up, risk reversal stable

Both wings are getting richer relative to ATM. This often points to convexity demand or event risk rather than directional skew.

Fly down, risk reversal stable

Wings are cheapening relative to ATM, so smile curvature is flattening even if skew direction has not changed.

Risk reversal moves, fly stable

One wing is repricing against the other, but the average wing richness versus ATM is broadly unchanged.

Both fly and risk reversal move

The smile is changing in both curvature and signed skew, which should be checked against quote-through-fit residuals.

Term structure

A fly term structure separates short-dated event convexity from broad surface curvature.

One expiry fly is a smile curvature node. The fly term structure compares that node across maturities so a desk can see whether wing richness is concentrated around one event or is repricing the whole surface.

Front-expiry event convexity

A short-dated fly spike can mean the market is paying for event tails even when the risk reversal is stable.

Back-end curvature

Longer-tenor flies help show whether wing richness is a one-event phenomenon or a broader volatility-surface repricing.

Forward-vol context

Compare fly changes with forward volatility so event premium, skew, and term-structure moves are not confused.

Calendar sanity

A fly term structure should be checked against neighboring SVI or SSVI slices before it is treated as a market signal.

The same total-variance context used in forward volatilityhelps decide whether a fly move is local to one expiry or part of a broader term-structure change.

Dashboard usage

Flies help separate skew from curvature.

A surface can have the same risk reversal but a different fly. That distinction matters when traders are watching wing demand, event convexity, and whether an SVI fit is overreacting to sparse wing quotes. The risk reversal guide covers the signed-skew side of the same smile.

Wing richness

Fly shows whether out-of-the-money options are expensive or cheap relative to ATM volatility.

Curvature changes

A larger fly usually means the smile has more curvature, even if risk reversal is unchanged.

Term structure

Fly by expiry helps separate short-dated event convexity from longer-dated surface shape.

Fit quality

Unexpected fly jumps can point to real convexity demand, stale wing quotes, or model instability.

Dashboard workflow

Fly monitoring works best beside skew, SVI residuals, and quote quality.

A fly can move because both wings repriced, because ATM moved, because one wing quote went stale, or because the fitted smile changed shape. A production dashboard therefore treats flies as surface diagnostics, not just a static number.

Compare fly with risk reversal

Risk reversal says which wing is richer. Fly says whether both wings are rich versus ATM. The two should be displayed together.

Watch expiry-by-expiry movement

A front-end fly spike can reflect event convexity, while a broad move across tenors can indicate a surface-level repricing.

Trace back to quotes

A fly node should link back to the fitted SVI smile, wing quotes, ATM level, and residual diagnostics that produced it.

Flag interpolation-heavy nodes

If one wing is sparse and the node comes mostly from the fitted curve, the dashboard should make that visible.

Fly changes also matter for variance swap and Greek workflows because wing richness changes implied variance and vega distribution across the smile.

API conventions

Fly data needs delta, ATM, source, and quality labels.

A volatility fly API field should make the node reproducible: expiry, delta bucket, ATM source, units, source surface, timestamp, and whether the node used live quotes, interpolation, or extrapolation.

{
  "metric": "FLY25",
  "expiry": "2026-09-25",
  "deltaBucket": "25-delta",
  "atmSource": "fitted_svi_atm",
  "units": "vol_points",
  "value": 4.5,
  "source": "fitted_svi_surface",
  "sourceQuality": "live_quotes_plus_interpolation",
  "timestamp": "2026-07-03T12:00:00Z"
}

A volatility fly API should also expose fly interpolation share, fly replay id, and risk-node age so API consumers can decide whether the curvature node is quote-supported or model-heavy.

Monitoring

25-delta fly monitoring should track node age, wing support, residuals, and replay state.

A fly can look current while one wing is stale or extrapolated. Production monitoring should therefore track the fly as its own risk node, with provenance from the accepted smile and the quote-state records behind each wing.

Risk-node age

A fly value should carry its own age, not only the headline surface timestamp, because one wing can be reused while the rest of the surface updates.

Wing support

The dashboard should show whether both 25-delta wings were quote-supported, interpolated, extrapolated, or held from a previous fit.

Residual gate

Fly publication should be downgraded when either wing has a large quote-through-fit residual or weak venue support.

Replay id

Each published fly node should point back to the smile state and quote-state records needed to reproduce it.

This is the same risk-node health pattern described in the production monitoring article and the order-book construction article.

Quote provenance

Fly moves should be traced back to wing quotes, interpolation, and delta remapping.

In crypto options, a fly can move because a wing traded, because the forward moved, or because the fitted curve remapped strikes into a different delta bucket. Derivasys keeps fly nodes tied to quote-through-fit diagnostics so curvature changes can be reviewed before they are used in risk or API workflows.

Wing quote freshness

A stale 25-delta wing can create a fly jump that looks like convexity demand but is really an input-quality issue.

Interpolation share

If the 25-delta node lands between listed strikes, the dashboard should show how much of the value comes from the fit.

ATM sensitivity

A small ATM convention change can move the fly even when both wing volatilities are unchanged.

Delta remapping

When the forward moves, listed strikes migrate across delta buckets, so sticky-strike and sticky-delta views can tell different stories.

Failure modes

Fly nodes fail when ATM source, delta mapping, wing support, or surface versions are hidden.

The most dangerous fly is a clean-looking number whose inputs cannot be reproduced. A dashboard should make the failure mode visible before the node feeds risk, variance, or API workflows.

ATM convention drift

Changing the ATM source can move the fly even if both wings are unchanged, so the API must label the ATM convention.

Delta remapping after a forward move

When the forward moves, the listed strikes behind a 25-delta node can change and make a fly jump look like wing demand.

Sparse wing extrapolation

A fitted wing with little quote support can make curvature look rich or cheap unless interpolation share is visible.

Mixed surface versions

Combining ATM, put wing, and call wing values from different accepted smiles creates a fly that cannot be audited.

Dashboard screenshots

Derivasys shows flies beside risk reversals and surface diagnostics.

Fly panels are most useful when they stay connected to the fitted smile and quote diagnostics. The same dashboard context explains whether a fly move reflects real convexity demand or a weak wing quote.

Derivasys dashboard panels showing volatility flies and risk reversals for crypto options
Fly panels show wing richness while risk reversal panels show signed skew, making curvature and skew separable.
Derivasys dashboard showing volatility surface diagnostics for fly monitoring
Surface diagnostics keep fly nodes connected to fitted smiles, quote-through-fit state, and fixed-tenor rows.
Derivasys through-fit matrix showing quote residuals behind volatility fly risk nodes
Through-fit diagnostics show whether the wing marks behind a fly came from live quotes, interpolation, or a weak fit.

Reading path

Move from smile curvature into the full risk-node workflow.

FAQ

Common questions about flies.

What is a volatility fly?

A volatility fly is the average of same-delta put and call implied volatility minus ATM implied volatility. It measures wing richness or smile curvature.

Is this the same as an options butterfly trade?

It is related but not identical. This page focuses on the volatility quote or risk metric, not the payoff diagram of a listed options butterfly.

Can fly be negative?

Yes. A negative fly means the average wing volatility is below ATM volatility under the chosen quote convention.

How is fly different from risk reversal?

Risk reversal measures signed skew between call and put wings. Fly averages both wings first, so it measures curvature around ATM.

What is the formula for a 25-delta volatility fly?

Using the convention on this page, the 25-delta fly equals the average of 25-delta put IV and 25-delta call IV, minus ATM implied volatility for the same expiry.

How should a fly be labelled in an API?

A fly API field should include expiry, delta bucket, ATM source, units, source surface, timestamp, and whether the value came from live quotes, interpolation, or extrapolation.

Why monitor fly and risk reversal together?

Risk reversal measures signed skew, while fly measures average wing richness versus ATM. Together they separate directional skew from smile curvature.

Why can a fly move when the market has not traded?

The node can move if the forward changes, the delta mapping changes, the ATM convention changes, or the fitted SVI smile changes because neighboring quotes were updated.

What is a fly term structure?

A fly term structure compares the fly value across expiries, helping distinguish short-dated event convexity from broader surface curvature.

What should a volatility fly API include?

A volatility fly API should include expiry, delta bucket, ATM source, put and call wing source, surface version, interpolation share, risk-node age, replay id, and publish status.

Why can a volatility fly be misleading?

A fly can be misleading when the ATM convention changes, one wing is stale, delta remapping moved the source strikes, or the value mixes different smile versions.

References

Related Derivasys guides.

Monitor live fly curves in Derivasys.

Use the dashboard for flies, risk reversals, fitted smiles, quote-through-fit checks, and API-ready surface state.