How Call Prices and Remaining Duration Shape Callable Bond Coupons

# Pricing of Callable Bonds and Coupon Behavior


# Pricing of Callable Bonds and Coupon Behavior












Recently, I have heard that the pricing of callable bonds produces a strange relationship between coupons and the tenor of the call option.

I have always thought that for a callable bond, when rates fall, the issuer of the bond seizes the chance to exercise the call and payback the principal (buyback the bond), and reissues at a lower rate/yield. It is for this reason that a callable bond, as compared to its non-callable equivalent, offers higher coupons as a form of compensation for investors.

However, I chanced upon certain pricing algorithms that seem to suggest that for very long tenor call options (packaged with the bond), the coupons of the callable bonds may even decrease as compared to a callable bond but with a slightly shorter tenor.

For example, the pricing algorithm produces:

Coupon (5Y Call with 10Y Bond) > Coupon (3Y Call with 10Y Bond)

but

Coupon (9Y Call with 10Y Bond) < Coupon (8Y Call with 10Y Bond)

Question: Is the true? / Is the pricing algorithm working correctly? What is the rationale behind it?

## Answer by almost_surely_ (score 1, accepted)

https://quant.stackexchange.com/a/85810

Two different questions are hiding in your example, and they have different answers.

The 8Y→9Y decrease is guaranteed — it must happen in any correctly built model. The 3Y→5Y increase is not generic: with a call struck at par it never happens, under any parameterisation I could find. It appears only when the call price schedule starts above par and declines. So whether your algorithm is right turns on one input, and you can check it in a minute.

### The mental model to fix first

Your intuition "callable pays more than non-callable" is right and always holds. The step that misleads is "longer call tenor means more optionality."

Set the coupon so the callable bond prices at par. Then

$$\underbrace{c_{\text{callable}} - c_{\text{par, non-callable}}}_{\text{coupon spread}} \;\;\longleftrightarrow\;\; \text{value of the call you are short.}$$

And the call value has three drivers, not one:

- time until the call can be exercised — longer helps;

- duration of the bond that remains at exercise — longer call date leaves less bond to call, which hurts;

- the strike — a higher call price hurts.

Driver 2 is the one missing from your reasoning, and near maturity it dominates everything.

### Why the long end must fall

At a call date $T_c$, the issuer is buying back a bond with $10-T_c$ years left. As $T_c \to 10$ that bond's duration goes to zero, so its price becomes insensitive to rates, so the option on it becomes worthless — intrinsic and time value both vanish. The coupon spread must therefore collapse to zero and the callable coupon converges to the plain par coupon from above.

In the numbers below the non-callable 10Y par coupon is 4.081%. The 9Y-call structure prices at 4.17%, a spread of only 9bp. There is no configuration in which that spread widens as the call date walks into maturity. A model that produced Coupon(9Y) > Coupon(8Y) would be broken. Yours doesn't, so that half is fine.

### Why the short end normally falls too

Hull–White, 10Y annual bond, flat 4% curve, European call struck at par, coupon solved for par each time. Priced exactly by Jamshidian decomposition, so there's no simulation noise to blame:

| call date | 1Y | 2Y | 3Y | 4Y | 5Y | 6Y | 7Y | 8Y | 9Y |
| par coupon % | 4.84 | 4.82 | 4.75 | 4.66 | 4.56 | 4.46 | 4.37 | 4.27 | 4.17 |

Monotone. And it stays monotone when you move the parameters around — mean reversion 0.03 or 0.30, vol 100bp or 200bp, curve flat, steepening at 25bp/year, or inverted at −15bp/year. In every case the peak sits at the shortest call date and Coupon(5Y) < Coupon(3Y), the opposite of what you report.

The reason is that driver 2 bites immediately. Going from a 3Y to a 5Y call, you gain $\sqrt{5/3}\approx 1.29$ in diffusion time but lose roughly a third of the remaining bond's duration. The duration loss wins.

### What does produce your pattern

A declining call price schedule — early calls struck at a premium, stepping down to par. Same model, same everything, only the strike schedule changed:

| call date | 1Y | 2Y | 3Y | 4Y | 5Y | 6Y | 7Y | 8Y | 9Y |
| call price $K$ | 108.8 | 107.5 | 106.2 | 105.0 | 103.8 | 102.5 | 101.2 | 100.0 | 100.0 |
| par coupon % | 4.13 | 4.22 | 4.28 | 4.32 | 4.33 | 4.32 | 4.30 | 4.27 | 4.17 |

$$\text{3Y}\to\text{5Y}: \;+0.047 \qquad \text{8Y}\to\text{9Y}: \;-0.095$$

Exactly your reported pattern, with an interior peak at 5Y. The mechanism is clean: at the short end the issuer must pay a large premium to call, which suppresses the option and therefore the coupon; as the schedule steps down toward par the option gets cheaper to exercise and the coupon rises; once the schedule flattens at par, driver 2 takes over and the coupon falls away to the non-callable par coupon.

So the hump is not a numerical artefact. It is the call schedule and the duration run-off crossing over.

### The diagnostic

Look at the call price schedule your algorithm is using.

- Declining from a premium to par → the non-monotonicity is real and correctly priced. Nothing to fix.

- Flat at par across all four structures → something is wrong. There is no parameterisation of a par-struck callable that gives you Coupon(5Y) > Coupon(3Y).

If the structures are Bermudan (the "10NC5" convention — callable on any coupon date from year 5 to maturity) with a common strike schedule, you can go further and rule it out without any model at all. The exercise dates of 10NC3 strictly contain those of 10NC5, so for any fixed coupon the issuer's option is worth weakly more in 10NC3, so the callable price is weakly lower, so the par coupon must be weakly higher. A dominance argument, no dynamics required. If your algorithm reports otherwise on a common strike schedule, that's a bug, and I'd look at whether the exercise-date grid is being built correctly for short lockouts, or whether the schedule is silently different between the two structures.

That last possibility is worth checking specifically, because in real markets it usually is different. US high-yield 10NC3 and 10NC5 don't share a schedule — first call is typically struck at par plus roughly half the coupon, stepping to par over the following years, so the two structures have genuinely different strikes at genuinely different times. If your pricer is pulling real schedules rather than a flat par assumption, that alone can generate the pattern, and it's the first thing I'd confirm before touching the model.

### Code

```
import numpy as np
from scipy.stats import norm
from scipy.optimize import brentq
r0, a, sig, MAT = 0.04, 0.03, 0.010, 10.0

P0   = lambda T: np.exp(-r0*T)
B    = lambda t,T: (1-np.exp(-a*(T-t)))/a

def zbc(T, S, X):                       # call on P(T,S), strike X
    sp = sig*np.sqrt((1-np.exp(-2*a*T))/(2*a))*B(T,S)
    h  = np.log(P0(S)/(P0(T)*X))/sp + sp/2
    return P0(S)*norm.cdf(h) - X*P0(T)*norm.cdf(h-sp)

def P_at(T, S, r):                      # P(T,S) given short rate r at T
    Bt = B(T,S)
    A  = (P0(S)/P0(T))*np.exp(Bt*r0 - sig**2/(4*a)*Bt**2*(1-np.exp(-2*a*T)))
    return A*np.exp(-Bt*r)

def call_value(Tc, c, K):               # Jamshidian decomposition
    ts = np.arange(np.ceil(Tc+1e-9), MAT+1e-9, 1.0)
    if len(ts) == 0: return 0.0
    cf = np.full(len(ts), 100*c); cf[-1] += 100.0
    rstar = brentq(lambda r: np.sum(cf*P_at(Tc,ts,r)) - K, -0.6, 0.95)
    Xs = P_at(Tc, ts, rstar)
    return float(np.sum(cf*np.array([zbc(Tc,S,X) for S,X in zip(ts,Xs)])))

def straight(c):
    ts = np.arange(1.0, MAT+1e-9, 1.0)
    cf = np.full(len(ts), 100*c); cf[-1] += 100.0
    return float(np.sum(cf*P0(ts)))

for label, Kfun in [("par     ", lambda t: 100.0),
                    ("declining", lambda t: 100.0 + max(0.0, 10.0 - 1.25*t))]:
    pc = [brentq(lambda c: straight(c)-call_value(t,c,Kfun(t))-100.0, 0., .45)*100
          for t in range(1,10)]
    print(label, " ".join(f"{v:5.2f}" for v in pc))
```

```
par       4.84  4.82  4.75  4.66  4.56  4.46  4.37  4.27  4.17
declining 4.13  4.22  4.28  4.32  4.33  4.32  4.30  4.27  4.17
```

Run it against your own schedule. If the flat-par row is what your pricer should be reproducing and it isn't, the bug is upstream of the model.

### References

- F. Jamshidian, An Exact Bond Option Formula, Journal of Finance 44(1), 1989 — the decomposition used above; worth having as an independent check on any callable pricer, since it is exact for European calls under a one-factor Gaussian model.

- J. Hull, A. White, Pricing Interest-Rate-Derivative Securities, Review of Financial Studies 3(4), 1990.

- L. Andersen, V. Piterbarg, Interest Rate Modeling, Vol. 3, Atlantic Financial Press, 2010 — Bermudan callables, exercise boundaries and the lockout effect.

- F. Fabozzi, Bond Markets, Analysis and Strategies — call schedule conventions, which is the input actually in question here.