Hedge From Inside Your Pro Forma

A development deal pencils on the development spread — your yield-on-cost (stabilized NOI ÷ total project cost) minus the exit cap rate — earned across an 18–36 month build and lease-up. You control the cost line. You do not control the two variables that decide whether the spread survives: the rents you actually achieve at delivery and the cap rate you exit at. Those two live in the Operations block (trended rents, lease-up and absorption, loss-to-lease, vacancy and credit loss → stabilized NOI) and the Reversion block (exit cap → reversion value) of your model.

So, following the modeling discipline you find in resources like Adventures in CRE, you stress them the classic way: a two-variable data table, exit cap rate across the top, rent growth down the side, reading out levered IRR and equity multiple. It is the right instinct. But it ends the same way every time — you land on the ugly corner cell, note the number, and move on. The interest reserve keeps burning, the takeout still assumes a stabilized asset, and peak equity is exposed the whole way. The table quantifies the pain. It does nothing about it.

ZipToken is an institutional exchange for parametric, index-settled downside protection on the exact variables that live in your model. Four settleable perils, each priced on a published index:

Each contract is index-settled: it pays on the published first print of its index, with no adjusters and no argument about what your building is worth. For home value and lease rate the default contract is now a graduated layer: you set a deductible (the index decline you absorb, with its dollar equivalent shown live), a coverage limit, and a term, and it pays proportionally above the deductible up to the limit — no all-or-nothing cliff. The binary trigger remains available under Advanced, and vacancy and weather contracts stay binary. You quantify the downside once, in your own model, and buy a defined payout against it.

The whole workflow is a short round trip that starts and ends in your workbook. Your model already holds the four inputs a quote needs. ZipToken turns them into a sized, priced hedge. That comes back as a premium line item and a protected IRR — and, when you are ready, executes.

Same engine, three front doors — from zero code to a little. Start with the agent; drop to the CLI or a custom function when you want the numbers wired into the sheet permanently.

{
  "mcpServers": {
    "ziptoken": {
      "command": "node",
      "args": ["/absolute/path/to/zip_token/packages/mcp/dist/index.js"],
      "env": {
        "ZIPTOKEN_API_URL": "https://zip-token-production.up.railway.app",
        "ZIPTOKEN_API_KEY": ""
      }
    }
  }
}

Open my model. Price a 50% hedge on the rent downside for the
Charlotte deal in row 42, using the ZORI lease-rate index for
Mecklenburg County. Put the reference premium in AC42 and the
sizing in AD42:AF42. Don't place anything — just quote and size.

Read B42 (Charlotte, 220 units), G42 (exposure $6.0M rent NPV),
H42 (break-even −3% rents), K42 (delivery 2027-12).

  search_geo "Charlotte NC"        → county:37119 (Mecklenburg)
  get_index_value county:37119     → ZORI $1,624, YoY +2.1%  (Data from Zillow)
  quotes API node=county:37119  kind=layered  index=zori
             attachBps=300 (−3% deductible = your break-even)
             exhaustBps=800 (full limit at −8%)
             expiry=2027-12
             notional=6,000,000    → reference premium  $300,000  (5.0¢ / $1)
                                      coverage limit    $6,000,000
                                      chance of any payout 10.0% · full limit 1.5%
                                      deductible ≈ $3.6M of decline you absorb
  size_hedge cross-check (the manual 3-strike ladder ≈ this one layer)
             downside=0.08 fraction=0.5 → ladder premium ≈ $300k

Wrote AC42 = $300,000  ·  AD42:AF42 = deductible −3% / limit $6.0M / term 2027-12.
Reference / model pricing — not firm until liquidity providers post.
Say "place it" (needs a trading-scope key) and I'll execute; the binary
strike ladder via get_quote + place_order still works if you prefer it.

$ ziptoken hedge size --exposure 6000000 --class multifamily-noi \
    --downside 0.08 --fraction 0.5 --attach 0.03 \
    --strikes 0.02,0.05,0.08 --price 0.06,0.09,0.13

Asset class: multifamily_noi  (beta_class=0.5, beta_geo=1, h_total=0.5000)
Hedge fraction: requested 50.0% -> capped 50.0%
Coverage target (C): $120,000

#  STRIKE  PRICE    PRICE(EFF)  WEIGHT  COVERAGE  CONTRACTS  PREMIUM
-  ------  -------  ----------  ------  --------  ---------  --------
1  -2.0%   $0.0600  $0.0606     40.0%   $48,000     51,096   $3,096
2  -5.0%   $0.0900  $0.0909     35.0%   $42,000     46,200   $4,200
3  -8.0%   $0.1300  $0.1313     25.0%   $30,000     34,534   $4,534

Total contracts:  131,830
Total premium:    $11,830  (0.20% of exposure)
Expected variance removed: ~35.0% (HE_mid=0.70 x F_capped=0.50)

=ZIPTOKEN.QUOTE("county:37119", 300, 800, "2027-12", 6000000)
→ 300000     ' reference premium (USD) for a −3% → −8% layer, straight into the cell

/**
 * ZIPTOKEN.QUOTE — reference premium (USD) for graduated (layered)
 * downside protection, pulled live from GET /api/quotes into a single cell.
 * You absorb index decline up to the deductible; it pays proportionally
 * above it, reaching the full coverage limit at the exhaustion point.
 * @customfunction
 * @param node       geo node, e.g. "county:37119" (Mecklenburg / Charlotte)
 * @param attachBps  deductible — the index decline you absorb, e.g. 300 = −3%
 * @param exhaustBps decline at which the full limit pays, e.g. 800 = −8%
 * @param expiry     quarter-end expiry "YYYY-MM", e.g. "2027-12"
 * @param coverage   coverage limit (max payout) in USD
 */
async function QUOTE(node, attachBps, exhaustBps, expiry, coverage) {
  const base = "https://zip-token-production.up.railway.app";
  const url =
    base + "/api/quotes?node=" + encodeURIComponent(node) +
    "&kind=layered&attachBps=" + attachBps + "&exhaustBps=" + exhaustBps +
    "&index=zori&expiry=" + expiry + "&notional=" + coverage;
  const res = await fetch(url, { headers: { "x-api-key": "" } });
  if (!res.ok) throw new Error("ZipToken " + res.status); // 422 = invalid layer
  const q = await res.json();
  return q.premiumUsd;  // reference model price — not a firm executable quote
  // Binary trigger instead? Omit kind/attach/exhaust and pass &strikeBps= —
  // the API default stays binary, so existing strike-ladder cells keep working.
}

An $80M ground-up multifamily deal in Mecklenburg County, delivering into a 2027 lease-up. The base case pencils; the downside — softer rents at delivery and a wider exit cap — is the corner cell from the top of this page. The hedge is sized to that corner: one graduated ZORI lease-rate layer — a −3% deductible (the pro forma's break-even) running to the full limit at −8% — plus a vacancy contract, settling on the same indices your Operations block already trends.

The $300k premium is a sunk soft cost of 0.38% of project cost. You absorb the first 3% of rent decline; above it the layer pays in proportion — a −5.5% print pays $3.0M, and −8% or worse pays the full $6.0M. In the corner-cell downside that payout, net of premium, turns the −$4.2M loss into a positive +$1.5M and lifts the protected IRR off the floor — with no cliff if rents land at −7.9% instead of −8%. The base case is barely touched — you gave up ~0.4% of cost to delete the tail.

The $300k above assumes you write the check at close. That is one of three payment structures you choose at quote time on the platform — the sizing, coverage, and protection are identical across all three; only when the premium hits your pro forma changes. For a pre-development budget with little cash to spare, the third is usually the one that matters.

Underwritten as what it is — a small, sized, sunk premium — the hedge is a risk-budget soft cost that sits next to the interest reserve and the contingency. It converts an un-financeable tail into a known number, which changes three conversations. It strengthens the equity story with LPs: peak equity now carries a defined floor instead of an open-ended corner cell. It gives construction lenders lease-up and completion comfort, because absorption and delay risk have a named backstop. And it lets you defend the development spread you underwrote — the whole reason the deal exists — across the 18–36 month window when you cannot control rents or exit cap. A premium you can size beats a downside you can only stare at.