const outputDelta = this.calculateCappedDelta(prevSku.outputRate, currentSku.outputRate);

  if (inputDelta.capped || cachedDelta.capped || outputDelta.capped) {
    cappedCount++;
  }

  matched.push({
    ...currentSku,
    inputRate: inputDelta.value,
    cachedInputRate: cachedDelta.value,
    outputRate: outputDelta.value,
  } as PricingSnapshot);
}

this.previousSnapshots.clear();
current.forEach(sku => this.previousSnapshots.set(sku.skuId, sku));

return this.aggregateDeltas(matched, cappedCount);

}

private calculateCappedDelta(prev: number, curr: number): { value: number; capped: boolean } { if (prev === 0) return { value: 0, capped: false }; const rawDelta = (curr - prev) / prev; const capped = Math.abs(rawDelta) > this.VOLATILITY_CAP; return { value: capped ? Math.sign(rawDelta) * this.VOLATILITY_CAP : rawDelta, capped, }; }

private aggregateDeltas(matched: PricingSnapshot[], cappedCount: number): IndexMetrics { const n = matched.length; if (n === 0) return { inputDelta: 0, cachedInputDelta: 0, outputDelta: 0, matchedSkuCount: 0, volatilityCapped: 0 };

const inputDelta = matched.reduce((sum, s) => sum + s.inputRate, 0) / n;
const cachedDelta = matched.reduce((sum, s) => sum + s.cachedInputRate, 0) / n;
const outputDelta = matched.reduce((sum, s) => sum + s.outputRate, 0) / n;

return {
  inputDelta,
  cachedInputDelta: cachedDelta,
  outputDelta,
  matchedSkuCount: n,
  volatilityCapped: cappedCount,
};

} }

### Why This Architecture Works

- **Chained matching** ensures that a 75% promotional discount on DeepSeek V4-Pro or a cache pricing cut to RMB 1 per million tokens on Alibaba Cloud Bailian registers accurately in the cached input column without being diluted by new model additions.
- **Volatility capping** prevents experimental audio or image generation SKUs (which recently added 190 new entries) from skewing the broader text index.
- **Column separation** captures the reality that cache pricing is now the primary battleground for platform channels, while output rates reflect true generation cost compression.
- **Modality awareness** allows teams to track when segments like audio stabilize (currently at 223 SKUs with zero movement after a 5.77% input jump) versus when they re-enter volatility due to new entrants.

## Pitfall Guide

### 1. Composition Bias Trap
**Explanation**: Using simple averages across all available SKUs causes new, cheaper models to artificially deflate the index, while model retirements cause artificial spikes. Teams mistake catalog churn for vendor pricing strategy.
**Fix**: Implement strict matched-model chaining. Only calculate deltas for SKUs present in both tracking windows. Exclude new entrants and retired models from rolling calculations.

### 2. Cache Pricing Blind Spot
**Explanation**: Aggregating input and cached input into a single "prompt cost" metric hides platform-level optimizations. Cache pricing drops (like the -17.47% platform channel shift) are often the first indicator of sustained market softening.
**Fix**: Track input, cached input, and output as separate index columns. Weight cache-heavy workloads differently in budget models. Monitor platform vs. direct API channels independently.

### 3. Promotional Mirage
**Explanation**: Temporary discounts (e.g., DeepSeek's 75% V4-Pro promotion) create short-term index dips that reverse once the campaign ends. Engineering teams overcommit to architectures based on non-recurring rates.
**Fix**: Tag promotional SKUs with campaign metadata. Apply a decay weight to promotional deltas in trend analysis. Require a minimum 3-week sustained decline before classifying a move as directional.

### 4. Retirement Volatility Spike
**Explanation**: When vendors sunset models (xAI grok-imagine-image-pro on May 15, Moonshot Kimi K2 on May 25, Writer Palmyra-x-003 on July 13), the sudden removal of high-cost or niche SKUs distorts weekly averages.
**Fix**: Maintain a retirement registry. Pre-exclude scheduled sunsets from index calculations during their final tracking window. Log retirement events separately to correlate with volatility spikes.

### 5. Reasoning Premium Misinterpretation
**Explanation**: The reasoning premium compression from 2.2x to 1.7x is often misread as base price cuts. In reality, new entrants join at lower price points while incumbents maintain rates.
**Fix**: Separate incumbent rate tracking from entrant pricing analysis. Calculate reasoning premiums against a stable baseline of established models. Adjust agent routing logic based on true premium shifts, not catalog expansion.

### 6. Modality Conflation
**Explanation**: Mixing text, audio, image, and reasoning pricing into a single index dilutes actionable signals. Audio recently stabilized at 223 SKUs with zero movement, while text showed coordinated declines.
**Fix**: Deploy modality-specific indexes with independent volatility baselines. Use cross-modality weights only for portfolio-level budgeting, never for architectural decision-making.

### 7. Over-Capping Outliers
**Explanation**: Applying a rigid ±50% cap across all modalities can suppress legitimate market corrections in emerging segments like voice or image generation.
**Fix**: Implement tiered volatility caps. Use ±50% for mature text/reasoning markets, and ±75% for emerging modalities. Review cap thresholds quarterly as segments mature.

## Production Bundle

### Action Checklist
- [ ] Deploy matched-model chaining: Ensure only SKUs present in consecutive tracking windows contribute to index calculations.
- [ ] Separate pricing columns: Track input, cached input, and output independently to capture cache-driven market shifts.
- [ ] Implement volatility capping: Apply ±50% SKU-level caps to prevent outlier distortions, with tiered thresholds for emerging modalities.
- [ ] Register model retirements: Maintain a calendar of scheduled sunsets (May 15, May 25, July 13) and exclude them from rolling calculations.
- [ ] Tag promotional campaigns: Flag temporary discounts and apply decay weights to prevent mirage-driven architecture decisions.
- [ ] Segment by modality & tier: Run independent indexes for text, audio, image, and reasoning to preserve signal fidelity.
- [ ] Monitor platform vs. direct channels: Platform cache pricing often leads broader market adjustments; track them separately.
- [ ] Validate directional signals: Require 3+ consecutive weeks of synchronized column softening before classifying a trend as structural.

### Decision Matrix

| Scenario | Recommended Approach | Why | Cost Impact |
|----------|---------------------|-----|-------------|
| High-volume text generation | Matched-model text index with cache weighting | Cache pricing drives 60%+ of prompt economics in production workloads | 15-25% reduction via cache-aware routing |
| Cache-heavy enterprise pipelines | Platform channel benchmarking | Platform vendors lead cache pricing innovation (e.g., -17.47% weekly shifts) | Lower marginal cost per reused prompt |
| Reasoning-intensive agent workflows | Incumbent-only reasoning premium tracking | New entrants compress averages without cutting base rates | Prevents over-provisioning on false premium drops |
| Multi-modal product launch | Modality-segmented indexes with independent caps | Audio/image volatility differs significantly from text baselines | Avoids cross-subsidization and budget misallocation |
| Long-term capacity planning | 3-week confirmed directional signal validation | Single/weekly moves are noise; sustained shifts indicate vendor strategy | Enables accurate 6-12 month token budgeting |

### Configuration Template

```yaml
inference_benchmark:
  engine:
    methodology: chained_matched_model
    volatility_cap: 0.50
    min_tracking_window_days: 7
    require_consecutive_declines: 3
  
  segments:
    text:
      tiers: [frontier, standard, economy]
      columns: [input, cached_input, output]
      volatility_cap: 0.50
    reasoning:
      tiers: [frontier, standard]
      columns: [input, output]
      premium_baseline: 2.2
      track_entrants_separately: true
    audio:
      tiers: [standard]
      columns: [input, output]
      volatility_cap: 0.75
      stable_sku_threshold: 200
    image:
      tiers: [standard, economy]
      columns: [input, output]
      volatility_cap: 0.75

  retirement_registry:
    - model: grok-imagine-image-pro
      vendor: xAI
      sunset_date: "2026-05-15"
      exclude_from_index: true
    - model: kimi-k2-original
      vendor: Moonshot
      sunset_date: "2026-05-25"
      exclude_from_index: true
    - model: palmyra-x-003-family
      vendor: Writer
      sunset_date: "2026-07-13"
      exclude_from_index: true

  alerting:
    directional_signal:
      threshold_weeks: 3
      columns_must_align: [input, cached_input, output]
    cache_shift:
      platform_channel_threshold: -0.10
      trigger_architecture_review: true

Quick Start Guide

1. Initialize the tracking engine: Deploy the InferenceIndexEngine class with a persistent snapshot store. Configure the volatility cap and matching window to align with your vendor update frequency.
2. Ingest vendor catalogs: Pull per-token pricing across input, cached input, and output columns. Normalize SKU identifiers and tag modality/tier metadata. Exclude retired models during ingestion.
3. Run weekly index calculations: Execute calculateWeeklyIndex() against consecutive snapshots. Monitor the matchedSkuCount and volatilityCapped metrics to validate data quality.
4. Validate directional signals: Require 3+ consecutive weeks of synchronized declines across pricing columns before triggering architecture or budget adjustments. Cross-reference platform channel cache shifts for early signals.
5. Integrate with capacity planning: Feed validated index deltas into your token budgeting models. Adjust routing logic to prioritize cache-optimized paths when platform channel indices show sustained softening.