Microsoft Cut Per-Employee AI Budgets From $100,000 To $10,000 A Month; Haiku 5.5 Costs Five Times More Above 100K Tokens. Building The AI Spend Gateway A Bank Needs Before Its First Budget Review

from dataclasses import dataclass

@dataclass(frozen=True)
class PriceBand:
    max_prompt_tokens: int | None   # None = no upper bound
    input_per_m: float
    output_per_m: float
    cache_read_per_m: float

# Verify against the provider's current price list before relying on these.
PRICES = {
    "claude-haiku-5-5": [PriceBand(100_000, 0.10, 0.50, 0.01), PriceBand(None, 0.50, 2.50, 0.05)],
    "claude-sonnet-5-5": [PriceBand(None, 2.00, 10.00, 0.20)],
    "claude-opus-5-5": [PriceBand(None, 4.00, 20.00, 0.20)],
}

def band_for(model: str, prompt_tokens: int) -> PriceBand:
    for band in PRICES[model]:
        if band.max_prompt_tokens is None or prompt_tokens <= band.max_prompt_tokens:
            return band
    raise ValueError("no price band")

def estimate_cost(model: str, prompt_tokens: int, cached_tokens: int, output_tokens: int) -> float:
    b = band_for(model, prompt_tokens)                 # the WHOLE request is priced by its prompt size
    fresh = prompt_tokens - cached_tokens
    return (fresh * b.input_per_m + cached_tokens * b.cache_read_per_m + output_tokens * b.output_per_m) / 1_000_000

def tier_cliff_warning(model: str, prompt_tokens: int, margin: float = 0.05):
    """Flag prompts just over a tier boundary - usually a few retrieved chunks too many."""
    for band in PRICES[model]:
        lim = band.max_prompt_tokens
        if lim and lim < prompt_tokens <= lim * (1 + margin):
            return f"{prompt_tokens} tokens is {prompt_tokens - lim} over the {lim} tier: trim retrieval to save ~5x"
    return None

interface Budgets { userMonthlyUsd: number; teamMonthlyUsd: number; runUsd: number }

export async function guardedCall(req: ModelRequest, ctx: { userId: string; teamId: string; runId: string }, ledger: Ledger, budgets: Budgets) {
  const estimate = estimateCost(req.model, req.promptTokens, req.cachedTokens, req.maxOutputTokens);   // worst case
  const [user, team, run] = await Promise.all([
    ledger.monthToDate("user", ctx.userId), ledger.monthToDate("team", ctx.teamId), ledger.total("run", ctx.runId),
  ]);
  if (run + estimate > budgets.runUsd) throw new BudgetError("run budget exceeded - agent paused for review");
  if (user + estimate > budgets.userMonthlyUsd) throw new BudgetError("monthly personal AI budget reached");
  if (team + estimate > budgets.teamMonthlyUsd) throw new BudgetError("team budget reached - ask your budget owner");

  const warning = tierCliffWarning(req.model, req.promptTokens);
  if (warning) await telemetry.warn("tier_cliff", { ...ctx, model: req.model, warning });

  const res = await provider.call(req);
  const actual = estimateCost(req.model, res.usage.inputTokens, res.usage.cachedTokens, res.usage.outputTokens);
  await ledger.record({ ...ctx, model: req.model, usd: actual, task: req.taskType, outcomeId: req.outcomeId });
  return res;
}

# Pass rates come from your own golden sets, per task type, refreshed on every model release.
EVALS = {
    "classify_email":   {"claude-haiku-5-5": 0.985, "claude-sonnet-5-5": 0.990},
    "extract_kyc":      {"claude-haiku-5-5": 0.962, "claude-sonnet-5-5": 0.981},
    "draft_credit_memo": {"claude-sonnet-5-5": 0.94, "claude-opus-5-5": 0.96},
}
FLOORS = {"classify_email": 0.98, "extract_kyc": 0.975, "draft_credit_memo": 0.93}

def route(task: str, prompt_tokens: int, expected_output: int) -> str:
    eligible = [m for m, p in EVALS[task].items() if p >= FLOORS[task]]
    if not eligible:
        raise RuntimeError("no model meets the quality floor for " + task)
    # Cost is per request at this prompt size, so tiers are respected automatically.
    return min(eligible, key=lambda m: estimate_cost(m, prompt_tokens, 0, expected_output))

# classify_email -> haiku; extract_kyc -> sonnet (haiku below floor); draft_credit_memo -> sonnet (cheaper than opus, passes)

-- Cost per outcome by team and task, with what routing saved versus sending everything to the frontier model.
SELECT
  l.team_id,
  l.task_type,
  COUNT(DISTINCT l.outcome_id)                                   AS outcomes,
  SUM(l.usd)                                                     AS spend_usd,
  SUM(l.usd) / NULLIF(COUNT(DISTINCT l.outcome_id), 0)           AS usd_per_outcome,
  SUM(l.frontier_equivalent_usd) - SUM(l.usd)                    AS routing_saving_usd,
  SUM(CASE WHEN l.tier_cliff THEN 1 ELSE 0 END)                  AS tier_cliff_calls,
  SUM(CASE WHEN l.run_budget_hit THEN 1 ELSE 0 END)              AS runs_stopped
FROM ai_ledger l
WHERE l.at >= date_trunc('month', now())
GROUP BY 1, 2
ORDER BY spend_usd DESC;