Orchestrate

Report an issue

Something wrong, out of date or unclear? Tell us. Corrections are prioritized over new topics. You don't need to sign in.

0 / 2000

Don't include personal or confidential company details. Reports are reviewed with AI assistance.

Model tiers and prices in late 2026

Which model prices change on 1 December 2026 and 1 January 2027, which models retire, and how to re-price an SAP AI workload with caching and batch.

Updated Nov 17, 2026Foundational 8 minDeep 35 min
Foundational layer · 8 min read

What changed, and when

Two dated price changes sit on model vendors' pricing pages as of 17 November 2026. Both are on Google's Gemini Developer API page (Google AI Studio pricing):

  • 1 December 2026: Gemini 4 Argon doubles. Its introductory price of 2.00 US dollars per million input tokens and 10.00 per million output tokens runs through 30 November. From 1 December it is 4.00 and 20.00. Cached input and Batch prices double too (What's new in Gemini 4 Argon).
  • 1 January 2027: Gemini 3.8 Flash and 3.6 Flash double. Input goes from 0.75 to 1.50 and output from 3.75 to 7.50 per million tokens. Some speech and robotics models change on the same date.

The other two big vendors announce no list-price change for those dates. Their pages show different late-2026 moves instead:

  • OpenAI. GPT-5.6 Sol's promotional price runs until 30 November 2026, and the page doesn't say what comes after (OpenAI pricing). Several older models shut down: GPT-5, GPT-5 mini, GPT-5 nano and o3 on 11 December 2026, and some GPT-4o and GPT-4.1 versions on 14 January 2027 (OpenAI deprecations).
  • Anthropic. Prices hold. The increase planned for Claude Sonnet 5 on 1 September 2026 was cancelled, so its introductory price became standard (Claude pricing). Claude Sonnet 4.5 retires on 30 November 2026, a date Anthropic marks as tentative (Claude model deprecations).

These are the vendors' own list prices, in US dollars, for their direct APIs. If you use models through SAP's generative AI hub, you pay SAP's rates in capacity units instead (see below). This page explains what the changes mean and how to re-price a workload. The concepts behind it are in Token economics and Model selection and routing.

Why it matters to the business

A model price is not a fixed input to a business case. It moves, sometimes on a date announced a few weeks ahead, and the move is often large: a doubling, not a few percent.

Three things make this a business question, not just a technical one:

  • Budgets for 2027 are being set now. A feature priced on November's list prices may cost twice as much in January, with no change in usage.
  • Retirements force changes. When a model shuts down, the feature must move to another one. The new model has a different price, and its answers must be tested again.
  • The cheapest lever is rarely the list price. On the course's made-up Calder workload, choosing a smaller model tier changes the bill far more than any announced price change does. Caching and batch processing cut it again.

Take the fictional Calder Pumpworks, the pump maker this course uses as its running company. It has two AI jobs. An agent explains about 600 blocked sales orders a month to customer service. A nightly job reads about 1,500 supplier invoices a month for accounts payable. Priced on Gemini 3.8 Flash, the month costs 5.59 USD in November and December and 11.17 USD from January, with caching and batch on. Priced on a large model like GPT-6 Astra, the same work costs 75.88 USD.

SAP's own finance leaders make the same point: they name model routing, capping tokens and cutting unneeded tools as the levers for token spend, and write that "Token spend is not a technology line item" (SAP News, 8 September 2026).

How SAP does it

SAP's generative AI hub, part of SAP AI Core on SAP BTP, gives access to foundation models "from SAP and leading providers". SAP prices it in capacity units per year, under your SAP BTP contract (SAP generative AI hub). How tokens turn into capacity units is explained in Token economics.

What that means for the dates above:

  • The vendor's list price is not your SAP price. SAP converts tokens to capacity units at its own per-model rates. A vendor's price change doesn't tell you whether, or when, SAP's rate for that model changes. Ask your SAP account team.
  • SAP's model list is its own. As of 10 November 2026, the SAP Cloud SDK for AI lists GPT-6 Astra, GPT-6.1 Sol, GPT-6 Luna, GPT-5.6 Sol, Gemini 3.8 Flash, Gemini 3.6 Flash, Gemini 3.5 Flash-Lite and Claude Opus 4.8, among others (SDK release notes). It names no Gemini 4 Argon and no Claude 5 models. Your region and contract decide what you can actually deploy.
  • SAP retires models on its own schedule. The same release notes set removal dates, for example 30 November 2026 for one Mistral Medium version and 31 December 2026 for the older SAP-RPT tabular models.

What moves, model by model

List prices in US dollars per million tokens, direct from each vendor, as read on 17 November 2026. "Tier" is this course's grouping by price within each vendor's lineup.

Vendor Model Tier Input Output In SAP's SDK list What changes
Google Gemini 4 Argon large 2.00 10.00 no 4.00 and 20.00 from 1 Dec 2026
Google Gemini 3.8 Flash medium 0.75 3.75 yes 1.50 and 7.50 from 1 Jan 2027
Google Gemini 3.5 Flash-Lite small 0.30 2.50 yes nothing announced
OpenAI GPT-6 Astra large 10.00 50.00 yes nothing announced
OpenAI GPT-6.1 Sol medium 2.00 10.00 yes nothing announced
OpenAI GPT-5.6 Sol medium 4.00 20.00 yes promotional price ends 30 Nov 2026; next price not published
OpenAI GPT-6 Luna small 0.10 0.50 yes nothing announced
Anthropic Claude Opus 5.5 large 4.00 20.00 no nothing announced
Anthropic Claude Sonnet 5.5 medium 2.00 10.00 no nothing announced
Anthropic Claude Haiku 5.5 small 0.10 0.50 no higher price for prompts over 100,000 tokens
Anthropic Claude Opus 4.8 large 5.00 25.00 yes nothing announced

Sources: Google, OpenAI, Anthropic, SAP Cloud SDK for AI.

Open-weight models (models whose weights you can download and run yourself) have no per-token list price from the model maker. You pay for the computers that run them, so the cost depends on your volume and hardware. Google's pricing page lists Gemma 4 with no paid-tier price. Which open-weight models SAP's hub offers, and at what rate, is a question for your SAP contract. Quantization and local models covers the trade-offs of running one yourself.

Two discounts apply on every vendor. Prompt caching charges much less for the part of a prompt that repeats, such as instructions and tool definitions. Batch processing runs requests within a day instead of at once, at half the standard price on all three vendors' pages.

Questions to ask

  1. Which models does each AI feature use today, and on which route: a vendor's API directly, or SAP's generative AI hub?
  2. For each model, does its price change, or does it retire, before the end of our budget year?
  3. In SAP's generative AI hub, what are our per-model capacity-unit rates, and will SAP change them when a vendor changes its list price?
  4. Which jobs can wait hours for an answer and could run as batch at half price?
  5. Do we cache the repeating part of each prompt, and how often does the cache actually hit?
  6. Is each feature on the smallest model tier that passes its evaluation set?
  7. When a model retires, who re-runs the evaluation on the replacement, and how long does that take?
  8. Do we pay extra for keeping data in one region, and is that requirement written down?

Common misconceptions

  • "A newer model always costs more." Not on these pages. Claude Opus 5.5 lists below Claude Opus 4.8, and GPT-6.1 Sol below GPT-5.6 Sol.
  • "A vendor's price change changes our SAP bill on the same day." In the generative AI hub you pay SAP's capacity-unit rates, under your contract. Ask SAP what changes and when.
  • "Price per token is the number to compare." The same text becomes a different number of tokens on different models. Anthropic says its newer tokenizer produces about 30% more tokens for the same text. Compare the cost of a whole task.
  • "Batch processing is a different, weaker model." It is the same model; you accept a slower answer for half the price.
  • "A promotional price is the price." It ends. GPT-5.6 Sol's promotion runs until 30 November 2026, and the page doesn't say what follows.

Key terms

All course terms, A to Z, in the glossary

  • Model tier: A vendor's grouping of models by capability and price, from large (most capable, most expensive) to small (fast and cheap).
  • List price: The price a vendor publishes for its own API, before any contract discount.
  • Capacity unit: The unit SAP uses to bill SAP BTP services, including the generative AI hub.
  • Prompt caching: Reusing the repeating start of a prompt so it is billed at a lower price on later calls.
  • Batch processing: Sending many requests to be answered within a set time, usually a day, at a discount.
  • Introductory price: A lower launch price that the vendor says will end on a date.
  • Model retirement (shutdown): The date after which a model no longer answers requests.
  • Open-weight model: A model whose weights are published, so you can run it on your own or rented computers.

Check yourself

Pick one answer for each question. The explanation appears after you choose.

1Which price change dated 1 December 2026 appears on a vendor's own pricing page?

Answer: D. Google's pricing page shows Gemini 4 Argon's introductory price through 30 November and double the price from 1 December 2026. Anthropic cancelled its planned Sonnet 5 increase, and SAP's rates are set by SAP and your contract.

2Calder uses Gemini 3.8 Flash through SAP's generative AI hub. What should the team do about Google's 1 January change?

Answer: A. In the hub you pay SAP's per-model rates under your contract, not Google's list price. The vendor's change doesn't say whether or when SAP's rate moves, so it is a question for your SAP account team.

3On the course's Calder workload, which lever changed the monthly cost the most?

Answer: D. On the made-up workload, GPT-6 Astra cost many times what Gemini 3.8 Flash did for the same work, while the announced changes double a price. Caching and batch help too, but tier choice dominates.

4A model your feature uses retires on 11 December 2026. What is the main business risk?

Answer: D. After a shutdown the model stops answering, so the feature needs a replacement. A replacement has its own price and behavior, so the evaluation must be re-run before go-live.

5Which job is a good fit for batch processing at half the standard price?

Answer: A. Batch requests are answered within a set window, usually a day, so they suit work that can wait, like a nightly invoice run. A person waiting for an answer needs standard processing.

6Why is "price per million tokens" a poor way to compare two vendors' models?

Answer: A. Each model family has its own tokenizer; Anthropic says its newer one produces about 30% more tokens for the same text. Compare the cost of a whole task, measured on your own prompts.
Deep layer · 35 min read

Mental model: a price is a model, a date, a route and a mode

"What does this model cost?" has no single answer. The cost of one task is the product of four choices, and a date:

  1. The model, which sets the list prices for input, output, cache writes and cache reads.
  2. The date, because list prices change on announced dates, and promotions end.
  3. The route: the vendor's API directly, a cloud marketplace, or SAP's generative AI hub (capacity units at SAP's rates). Data residency adds a premium on some routes.
  4. The mode: standard, batch (half price, answered within a window) or a premium fast mode.
  5. The prompt's shape: how much of it repeats and can be cached, and how many calls one task makes.

The list prices are the part you can't control. The other four you design. A re-pricing tool therefore holds prices with dates and sources, and computes the cost per task from the design.

How it works

Three vendors, three caching rules

Each vendor bills cached tokens differently, and the differences matter more than the headline price.

Vendor Writing to the cache Reading from the cache Notes
Anthropic 1.25x input for a 5-minute cache, 2x for 1 hour 0.1x input on most models; 0.05x on Opus 5.5 and Sonnet 5.5; 0.025x on Fable and Mythos 5.1 and 5.2 Caching pays after one read (5 minutes) or two (1 hour)
OpenAI The page lists "30m write" and "12h write" prices without explaining them A "cached input" price, 5% of input on GPT-6.1 Sol The course script charges the 30-minute price as a write, the cautious reading
Google Implicit caching: no write charge stated; explicit context caching adds an hourly storage price A context caching price: 5% of input on Gemini 4 Argon, 10% on Gemini 3.8 Flash Gemini 4 Argon's page describes the implicit cache discount on hits

Sources: Claude pricing, OpenAI pricing, Google pricing, Gemini 4 Argon.

How caching works in general, and when it costs more than it saves, is covered in Caching for LLM applications.

Batch halves everything

All three vendors price batch processing at half of standard. Anthropic says its caching multipliers stack with the Batch discount. OpenAI's and Google's batch tables show their cached and cache-write prices halved too. So the cost of a batch job is the standard cost, cache included, times 0.5.

Other multipliers

  • Long prompts. OpenAI prices requests over 272K input tokens higher. Claude Haiku 5.5 has higher prices for prompts over 100,000 tokens. Gemini 3.1 Pro Preview and 2.5 Pro price prompts over 200K higher. Anthropic's other Claude 4.6 and later models bill the full 1M context at the standard rate.
  • Data residency. Anthropic applies 1.1x to all token prices for US-only inference on Claude 4.6 and later. OpenAI adds 10% for regional processing on models released on or after 5 March 2026. Some partner clouds add a 10% premium for regional endpoints.
  • Fast modes. Anthropic's fast mode and OpenAI's Fast mode (renamed from Priority on 30 July 2026) cost more for quicker answers.
  • Tokenizers. Anthropic says Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text. A cheaper rate on a model that counts more tokens can cost more.

What a dated change does to one task

flowchart LR
  T[Task: one invoice] --> C[Calls and tokens<br/>per call]
  C --> K{Prefix cached?}
  K -->|hit| R[Read price]
  K -->|miss| W[Write price]
  C --> I[Input and output prices]
  P[(Price table<br/>with dates)] --> R
  P --> W
  P --> I
  R --> S[Cost per task]
  W --> S
  I --> S
  S --> B{Batch job?}
  B -->|yes| H[x 0.5]
  B -->|no| M[Cost per month]
  H --> M

Only the price table depends on the date. When a vendor changes a price, you change one row and re-run.

Build it yourself: re-price Calder's two jobs on three dates

You will build radar/model_prices.py. It prices Calder's two made-up AI jobs on 15 models, on 17 November 2026, 1 December 2026 and 1 January 2027, with each vendor's caching rule and the Batch discount. It extends the Unit 10 cost model, unit10/token_costs.py from Token economics, which priced one assistant at example rates.

Before you start: complete Set up your computer for this course. The script uses only built-in Python, needs no account and calls no model. Doing Token economics first helps, but isn't required.

flowchart LR
  J[Calder's two jobs<br/>calls and tokens] --> Q[Cost per run]
  P[(Price table<br/>read 17 Nov 2026)] --> Q
  Q --> M[Month per model<br/>on three dates]
  M --> D{Compare}

What you need

  • Your orchestrate-course folder with .venv from the setup topic.
  • About 30 to 45 minutes.
  • Cost: free.

Step 1: Open your course folder and turn on the virtual environment

  1. Open VS Code, choose File > Open Folder, and open orchestrate-course.

  2. Open a terminal: Terminal > New Terminal.

  3. If the prompt doesn't start with (.venv), turn it on:

    • Windows (PowerShell):

      .venv\Scripts\Activate.ps1
    • macOS / Linux:

      source .venv/bin/activate
  4. If you don't have a radar folder yet (an earlier radar page creates it), make one:

    • Windows (PowerShell):

      New-Item -ItemType Directory -Force radar
    • macOS / Linux:

      mkdir -p radar

Step 2: Create the script

  1. In VS Code, right-click radar, choose New File, name it model_prices.py, paste the code below and save.
"""Radar: what Calder's two AI jobs cost a month on each model, before and after the dated price changes.

It extends the Unit 10 cost model (unit10/token_costs.py) with three things that change real bills:
  - each vendor's own prompt caching rule (what a cache write and a cache read cost),
  - the Batch discount for work that can wait overnight,
  - list prices that change on a date (1 December 2026 and 1 January 2027 on Google's page).

Calder Pumpworks is a fictional company; the workload below is made up. The PRICES are list prices
in US dollars per million tokens, copied from the vendors' pages as read on 2026-11-17 (see SOURCES).
They are not SAP's prices: in SAP's generative AI hub you pay in capacity units at SAP's per-model
rates under your SAP BTP contract.

  python radar/model_prices.py                      every model on three dates, cache and batch on
  python radar/model_prices.py --no-cache --no-batch   the same at plain list prices
  python radar/model_prices.py --model gemini-3.8-flash  one model in detail: what cache and batch save
  python radar/model_prices.py --runs 2000 --invoices 6000   a busier month
  python radar/model_prices.py --hub                only models in the SAP AI SDK's model list
"""
import argparse
import sys
from datetime import date

READ_ON = "2026-11-17"
SOURCES = {
    "anthropic": "https://platform.claude.com/docs/en/about-claude/pricing",
    "openai": "https://developers.openai.com/api/docs/pricing",
    "google": "https://aistudio.google.com/docs/pricing",
}
DATES = [date(2026, 11, 17), date(2026, 12, 1), date(2027, 1, 1)]

# ---------------------------------------------------------------------------------------------
# List prices, USD per million tokens, read on READ_ON. in: input, out: output,
# write: what one cached token costs to write, read: what it costs to read (a cache hit).
# A model with "changes" switches to the new prices on that date. "ends" means a promotional
# price that runs through that date with no later price published: the script shows n/a after it.
# hub: the model's name in the SAP AI SDK model lists (JavaScript release notes to 2.18.0,
# 10 November 2026), or None when it isn't there. Your region and contract decide what you get.
# ---------------------------------------------------------------------------------------------
PRICES = {
    # Anthropic: write = 5-minute cache write (1.25x input); read = cache hit price per model.
    "claude-fable-5.2":  {"vendor": "anthropic", "tier": "large", "in": 8.00, "out": 40.00,
                          "write": 10.00, "read": 0.20, "hub": None},
    "claude-opus-5.5":   {"vendor": "anthropic", "tier": "large", "in": 4.00, "out": 20.00,
                          "write": 5.00, "read": 0.20, "hub": None},
    "claude-sonnet-5.5": {"vendor": "anthropic", "tier": "medium", "in": 2.00, "out": 10.00,
                          "write": 2.50, "read": 0.10, "hub": None},
    "claude-haiku-5.5":  {"vendor": "anthropic", "tier": "small", "in": 0.10, "out": 0.50,
                          "write": 0.125, "read": 0.01, "hub": None},   # prompts up to 100,000 tokens
    "claude-opus-4.8":   {"vendor": "anthropic", "tier": "large", "in": 5.00, "out": 25.00,
                          "write": 6.25, "read": 0.50, "hub": "anthropic--claude-4.8-opus"},
    "claude-sonnet-4.6": {"vendor": "anthropic", "tier": "medium", "in": 3.00, "out": 15.00,
                          "write": 3.75, "read": 0.30, "hub": "anthropic--claude-4.6-sonnet"},
    "claude-haiku-4.5":  {"vendor": "anthropic", "tier": "small", "in": 1.00, "out": 5.00,
                          "write": 1.25, "read": 0.10, "hub": "anthropic--claude-4.5-haiku"},
    # OpenAI: read = cached input; write = the page's "30m write" column, charged here as a write
    # (the page doesn't explain the column, so this is the cautious reading). Short context only.
    "gpt-6-astra":   {"vendor": "openai", "tier": "large", "in": 10.00, "out": 50.00,
                      "write": 12.50, "read": 1.00, "hub": "gpt-6-astra"},
    "gpt-6.1-sol":   {"vendor": "openai", "tier": "medium", "in": 2.00, "out": 10.00,
                      "write": 2.50, "read": 0.10, "hub": "gpt-6.1-sol"},
    "gpt-6.1-terra": {"vendor": "openai", "tier": "medium", "in": 1.00, "out": 5.00,
                      "write": 1.25, "read": 0.05, "hub": None},
    "gpt-6-luna":    {"vendor": "openai", "tier": "small", "in": 0.10, "out": 0.50,
                      "write": 0.125, "read": 0.01, "hub": "gpt-6-luna"},
    "gpt-5.6-sol":   {"vendor": "openai", "tier": "medium", "in": 4.00, "out": 20.00,
                      "write": 5.00, "read": 0.40, "hub": "gpt-5.6-sol", "ends": date(2026, 11, 30)},
    # Google: implicit caching assumed (writes at the input price, no storage charge);
    # read = the context caching price.
    "gemini-4-argon":        {"vendor": "google", "tier": "large", "in": 2.00, "out": 10.00,
                              "write": 2.00, "read": 0.10, "hub": None,
                              "changes": (date(2026, 12, 1), {"in": 4.00, "out": 20.00,
                                                              "write": 4.00, "read": 0.20})},
    "gemini-3.8-flash":      {"vendor": "google", "tier": "medium", "in": 0.75, "out": 3.75,
                              "write": 0.75, "read": 0.075, "hub": "gemini-3.8-flash",
                              "changes": (date(2027, 1, 1), {"in": 1.50, "out": 7.50,
                                                             "write": 1.50, "read": 0.15})},
    "gemini-3.5-flash-lite": {"vendor": "google", "tier": "small", "in": 0.30, "out": 2.50,
                              "write": 0.30, "read": 0.03, "hub": "gemini-3.5-flash-lite"},
}
BATCH_FACTOR = 0.5  # all three vendors list Batch at half the standard price, cache prices included

# ---------------------------------------------------------------------------------------------
# Calder's two jobs (made up). Token counts per model call:
#   prefix = the instructions and tool or schema definitions, the same on every call (cacheable)
#   rest   = everything else sent; out = tokens the model writes
# ---------------------------------------------------------------------------------------------
JOBS = {
    "order_exceptions": {
        "label": "AGT_ORDER_EXC explains blocked sales orders (interactive)",
        "per_month_option": "runs",
        "batchable": False,
        # Call 1 reads the order, call 2 reads the customer's credit, call 3 drafts the answer.
        # Each call re-sends the conversation so far.
        "calls": [{"prefix": 2400, "rest": 300, "out": 40},
                  {"prefix": 2400, "rest": 840, "out": 40},
                  {"prefix": 2400, "rest": 1280, "out": 350}],
    },
    "invoice_extraction": {
        "label": "supplier invoice extraction for CP10 (overnight, can wait)",
        "per_month_option": "invoices",
        "batchable": True,
        "calls": [{"prefix": 1800, "rest": 2600, "out": 450}],
    },
}


def prices_on(model: str, day: date):
    """The model's prices in effect on a day, or None if no price is published for that day."""
    p = dict(PRICES[model])
    if "ends" in p and day > p["ends"]:
        return None
    if "changes" in p and day >= p["changes"][0]:
        p.update(p["changes"][1])
    return p


def job_tokens(job: dict, cache: bool, hit_rate: float) -> dict:
    """Tokens of each kind for one run of a job. The first call finds the prefix in the cache at
    hit_rate; later calls in the same run come seconds later and always find it."""
    t = {"input": 0.0, "write": 0.0, "read": 0.0, "output": 0.0}
    for i, c in enumerate(job["calls"]):
        t["output"] += c["out"]
        t["input"] += c["rest"]
        if not cache:
            t["input"] += c["prefix"]
            continue
        hit = 1.0 if i > 0 else hit_rate
        t["read"] += c["prefix"] * hit
        t["write"] += c["prefix"] * (1 - hit)
    return t


def job_cost(p: dict, tokens: dict, batch: bool) -> float:
    """USD for one run, from tokens and prices per million."""
    usd = (tokens["input"] * p["in"] + tokens["write"] * p["write"]
           + tokens["read"] * p["read"] + tokens["output"] * p["out"]) / 1e6
    return usd * (BATCH_FACTOR if batch else 1.0)


def month_cost(model: str, day: date, args, cache=None, batch=None):
    """USD per month for both jobs, or None when no price is published for that day."""
    p = prices_on(model, day)
    if p is None:
        return None
    cache = args.cache if cache is None else cache
    batch = args.batch if batch is None else batch
    total = 0.0
    for job in JOBS.values():
        volume = getattr(args, job["per_month_option"])
        tokens = job_tokens(job, cache, args.hit_rate)
        total += job_cost(p, tokens, batch and job["batchable"]) * volume
    return total


def money(v):
    return "n/a" if v is None else f"{v:,.2f}"


def show_all(args) -> None:
    print(f"Calder's monthly AI bill by model, list prices as read {READ_ON} (USD, made-up workload)")
    print(f"Workload: {args.runs:,} order exception runs (3 calls each) + "
          f"{args.invoices:,} supplier invoices (1 call each)")
    plan = (f"cache {'on' if args.cache else 'off'}"
            + (f" (first-call hit rate {args.hit_rate:.2f})" if args.cache else "")
            + f", batch {'on' if args.batch else 'off'} for invoice extraction")
    print(f"Plan: {plan}\n")
    head = "".join(f"{d.strftime('%d %b %Y'):>13}" for d in DATES)
    print(f"{'model':<23}{'tier':<8}{'hub':<5}{head}  change")
    notes = []
    for model, p in PRICES.items():
        if args.hub and not p["hub"]:
            continue
        costs = [month_cost(model, d, args) for d in DATES]
        first, last = costs[0], costs[-1]
        if last is None:
            change = "price ends"
            notes.append(f"{model}: promotional price runs until {p['ends']}; "
                         "no later price published on the page")
        elif last != first:
            change = f"{(last / first - 1) * 100:+.0f}%"
        else:
            change = "none"
        cells = "".join(f"{money(c):>13}" for c in costs)
        print(f"{model:<23}{p['tier']:<8}{'yes' if p['hub'] else 'no':<5}{cells}  {change}")
    print("\nhub = named in the SAP AI SDK model lists (release notes to 10 Nov 2026). In the hub you pay "
          "SAP's\ncapacity-unit rates, not these list prices.")
    for n in notes:
        print("! " + n)


def show_one(args) -> None:
    model = args.model
    if model not in PRICES:
        sys.exit(f"Unknown model {model}. Choose one of: {', '.join(PRICES)}")
    print(f"{model}: what caching and batch do to Calder's month (USD, made-up workload)\n")
    for d in DATES:
        p = prices_on(model, d)
        if p is None:
            print(f"{d}: no published price\n")
            continue
        print(f"{d}: input {p['in']:.3f}, output {p['out']:.3f}, cache write {p['write']:.3f}, "
              f"cache read {p['read']:.3f} per million tokens")
        print(f"  {'plan':<26}{'order exceptions':>18}{'invoice extraction':>20}{'month':>12}")
        for label, cache, batch in (("list price", False, False), ("cache", True, False),
                                    ("cache + batch (invoices)", True, True)):
            parts = []
            for job in JOBS.values():
                volume = getattr(args, job["per_month_option"])
                tokens = job_tokens(job, cache, args.hit_rate)
                parts.append(job_cost(p, tokens, batch and job["batchable"]) * volume)
            print(f"  {label:<26}{money(parts[0]):>18}{money(parts[1]):>20}{money(sum(parts)):>12}")
        print()
    t = job_tokens(JOBS["order_exceptions"], True, args.hit_rate)
    print("One order exception run with cache on: "
          f"{t['input']:.0f} input, {t['write']:.0f} written, {t['read']:.0f} read from cache, "
          f"{t['output']:.0f} output tokens")


def main() -> None:
    parser = argparse.ArgumentParser(description="Calder's AI jobs priced on each model and date.")
    parser.add_argument("--runs", type=int, default=600, help="order exception runs a month")
    parser.add_argument("--invoices", type=int, default=1500, help="supplier invoices a month")
    parser.add_argument("--hit-rate", type=float, default=0.8,
                        help="share of first calls that find the prefix in the cache (0 to 1)")
    parser.add_argument("--no-cache", dest="cache", action="store_false", help="price without caching")
    parser.add_argument("--no-batch", dest="batch", action="store_false",
                        help="run invoice extraction at standard prices")
    parser.add_argument("--hub", action="store_true", help="only models in the SAP AI SDK model lists")
    parser.add_argument("--model", help="show one model in detail")
    args = parser.parse_args()
    if not 0 <= args.hit_rate <= 1:
        sys.exit("--hit-rate must be between 0 and 1.")
    if args.runs < 0 or args.invoices < 0:
        sys.exit("--runs and --invoices can't be negative.")
    if args.model:
        show_one(args)
    else:
        show_all(args)


if __name__ == "__main__":
    main()
  1. Check the file is there:

    • Windows (PowerShell):

      dir radar\model_prices.py
    • macOS / Linux:

      ls radar/model_prices.py

Step 3: Price every model on three dates

  1. Run the script with no options:

    python radar/model_prices.py
  2. You should see this:

    Calder's monthly AI bill by model, list prices as read 2026-11-17 (USD, made-up workload)
    Workload: 600 order exception runs (3 calls each) + 1,500 supplier invoices (1 call each)
    Plan: cache on (first-call hit rate 0.80), batch on for invoice extraction
    
    model                  tier    hub    17 Nov 2026  01 Dec 2026  01 Jan 2027  change
    claude-fable-5.2       large   no           57.64        57.64        57.64  none
    claude-opus-5.5        large   no           29.33        29.33        29.33  none
    claude-sonnet-5.5      medium  no           14.67        14.67        14.67  none
    claude-haiku-5.5       small   no            0.76         0.76         0.76  none
    claude-opus-4.8        large   yes          37.94        37.94        37.94  none
    claude-sonnet-4.6      medium  yes          22.76        22.76        22.76  none
    claude-haiku-4.5       small   yes           7.59         7.59         7.59  none
    gpt-6-astra            large   yes          75.88        75.88        75.88  none
    gpt-6.1-sol            medium  yes          14.67        14.67        14.67  none
    gpt-6.1-terra          medium  no            7.33         7.33         7.33  none
    gpt-6-luna             small   yes           0.76         0.76         0.76  none
    gpt-5.6-sol            medium  yes          30.35          n/a          n/a  price ends
    gemini-4-argon         large   no           14.39        28.77        28.77  +100%
    gemini-3.8-flash       medium  yes           5.59         5.59        11.17  +100%
    gemini-3.5-flash-lite  small   yes           2.83         2.83         2.83  none
    
    hub = named in the SAP AI SDK model lists (release notes to 10 Nov 2026). In the hub you pay SAP's
    capacity-unit rates, not these list prices.
    ! gpt-5.6-sol: promotional price runs until 2026-11-30; no later price published on the page
  1. Read it from the top:
    • The two doublings show up on their dates: Gemini 4 Argon from 1 December, Gemini 3.8 Flash from 1 January.
    • GPT-5.6 Sol shows n/a after 30 November. The script refuses to guess a price the page doesn't publish. If a feature runs on it, that is a question for the vendor or for SAP, not a number to assume.
    • Tier spreads are wider than the price changes. Between GPT-6 Astra and GPT-6 Luna there is a factor of 100 on the same work. Whether the small model is good enough is a question for your evaluation set (Model selection and routing).
    • Two models with the same list prices, Claude Sonnet 5.5 and GPT-6.1 Sol, cost the same here because the script uses the same token counts for both. In real use their tokenizers count the same text differently, so measure.

Step 4: Turn caching and batch off

  1. Run:

    python radar/model_prices.py --no-cache --no-batch
  2. Compare a few rows with Step 3:

    model                  tier    hub    17 Nov 2026  01 Dec 2026  01 Jan 2027  change
    claude-opus-4.8        large   yes          85.19        85.19        85.19  none
    gpt-6-astra            large   yes         170.37       170.37       170.37  none
    gemini-3.8-flash       medium  yes          12.78        12.78        25.56  +100%

    Caching and batch together cut each model's month by more than half on this workload. In money, they are worth about as much as one price doubling.

Step 5: Look at one model in detail

  1. Run:

    python radar/model_prices.py --model gemini-3.8-flash
  2. You should see this (the 1 December block repeats the November one, and is left out here):

    gemini-3.8-flash: what caching and batch do to Calder's month (USD, made-up workload)
    
    2026-11-17: input 0.750, output 3.750, cache write 0.750, cache read 0.075 per million tokens
      plan                        order exceptions  invoice extraction       month
      list price                              5.30                7.48       12.78
      cache                                   2.57                6.02        8.60
      cache + batch (invoices)                2.57                3.01        5.59
    
    2027-01-01: input 1.500, output 7.500, cache write 1.500, cache read 0.150 per million tokens
      plan                        order exceptions  invoice extraction       month
      list price                             10.59               14.96       25.56
      cache                                   5.15               12.05       17.20
      cache + batch (invoices)                5.15                6.02       11.17
    
    One order exception run with cache on: 2420 input, 480 written, 6720 read from cache, 430 output tokens
  3. What it shows:

    • Caching halves the agent's cost: its three calls send the same 2,400-token prefix, and the second and third find it in the cache. It helps the invoice job less, because most of each invoice's tokens are the invoice itself.
    • Batch halves the invoice job. The agent can't use batch: a clerk is waiting.
    • From 1 January, the fully optimized plan (11.17) still costs less than November's plain list price (12.78).

Step 6: Only the models in SAP's list

  1. Run:

    python radar/model_prices.py --hub
  2. You see nine rows: the models whose names appear in the SAP Cloud SDK for AI release notes. Gemini 4 Argon and the Claude 5 models drop out.

  3. These list prices are not what you pay in the hub. Use them to see which models move, then ask SAP what your capacity-unit rates for those models are and whether they change. To price in capacity units, put SAP's rates into unit10/token_costs.py --sap from Token economics.

Step 7: A busier month

  1. Try a hundred times Calder's volume:

    python radar/model_prices.py --hub --runs 60000 --invoices 150000
  2. Look at the Gemini 3.8 Flash row:

    gemini-3.8-flash       medium  yes         558.65       558.65     1,117.31  +100%

    The doubling is now worth about 559 USD a month. At this volume, moving the agent from a large tier to a medium one is worth thousands. The ratios are the same as in Step 3; only the stakes grew.

Step 8: Save your work

git add radar/model_prices.py
git commit -m "Radar: re-price Calder's AI jobs on three dates"

How the code works

Part What it does
READ_ON, SOURCES When and where the prices were read, so anyone can check them
PRICES Per model: vendor, tier, input, output, cache write and cache read prices, the SAP SDK name if any, and a dated change or promotion end
BATCH_FACTOR The Batch discount, 0.5 on all three vendors
JOBS Calder's two jobs as lists of calls, each with a cacheable prefix, the rest of the input and the output
prices_on Returns the prices in effect on a date, or None when no price is published
job_tokens Splits one run's tokens into input, cache writes, cache reads and output
job_cost Multiplies tokens by prices and applies the Batch discount
month_cost, show_all Prices both jobs for a month on each date and prints the comparison
show_one Shows what caching and batch save for one model, job by job

If something goes wrong

What you see What it means What to do
python is not recognized, or command not found Python isn't installed, or the terminal can't find it Windows: repeat the setup topic's Python step and open a new terminal. macOS/Linux: use python3 until .venv is active
can't open file ... model_prices.py You are not in the course folder, or the file is elsewhere Run cd to orchestrate-course; check the file is in radar
SyntaxError or IndentationError Part of the code was not pasted Select all in the file, delete, and paste the whole block again
Unknown model ... The name after --model isn't in PRICES Copy a name exactly from the list the message prints
--hit-rate must be between 0 and 1. You typed a percentage Use 0.8, not 80
Your numbers differ from the ones shown You changed PRICES, JOBS or an option Expected after edits. Paste the code again to get the published numbers

No network is used, so proxies and firewalls don't affect this script. A missing library is not possible either: it uses only built-in modules.

The SAP way

As of 17 November 2026, from the pages read for this topic:

  • Pricing model. The generative AI hub is "priced by capacity units per year", with contract duration on request (SAP generative AI hub). Tokens convert to capacity units at per-model rates, as Token economics explains. Those rates, not the vendors' list prices, are what you budget with.
  • Model list. SAP's developer kits track the hub's models. The JavaScript SDK added gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna and gemini-3.5-flash-lite in 2.16.0 (18 September 2026), and gpt-6-astra, gpt-6-luna, gpt-6.1-sol, gemini-3.8-flash and gemini-3.6-flash in 2.17.0 (22 October 2026). Earlier, 2.14.0 added anthropic--claude-4.5-opus and anthropic--claude-4.8-opus. Version 2.18.0 (10 November 2026) changed no models (JavaScript release notes). The Java SDK 2.0.0 (20 October 2026) also lists QWEN_3_8_MAX (Java release notes).
  • Retirements. The same notes give removal dates: mistralai--mistral-medium-instruct on 2026-11-30, and sap-rpt-1-small, sap-rpt-1-large, sap-rpt-1.5 and sap-rpt-1.5-large on 2026-12-31, replaced by the 1.6 models (Tabular AI and SAP-RPT covers them).
  • Vendor retirements are not SAP's. OpenAI shuts down gpt-5 on its own API on 11 December 2026, and Anthropic retires Claude Sonnet 4.5 on 30 November 2026 (tentative). The release notes read for this topic set no SAP removal date for the hub's gpt-5 or anthropic--claude-4.5-sonnet. Check SAP's model lifecycle for your region before you assume either way.
  • What the hub adds for cost. Earlier topics cover the hub's prompt caching, how cached tokens are metered, and fallbacks between models (Token economics, Generative AI hub and orchestration, Model selection and routing). A batch mode with a discount in the hub was not found on the pages read for this topic.

Build vs. SAP

Question Vendor API directly SAP generative AI hub
Which price applies? The vendor's list price or your contract with the vendor SAP's per-model capacity-unit rates under your SAP BTP contract
When a list price doubles You pay it from the vendor's date Ask SAP whether and when the hub's rate changes
Newest models Usually first, as soon as the vendor releases them Added on SAP's schedule; Gemini 4 Argon and Claude 5 models were not in SAP's SDK lists on 10 November 2026
Batch discount Half price on all three vendors Not found on SAP pages read for this topic
Caching discount The vendor's own rule Through the orchestration service, billed at SAP's rates (see Token economics)
One bill, one contract for many vendors No: one per vendor Yes, in capacity units
Fits Large batch jobs, newest models, teams outside SAP BTP SAP-centric apps that want one contract and the hub's orchestration modules

Architecture view

Where it sits. The price table is configuration, not code. In Calder's landscape it lives next to the AI gateway or the cost reports, and both routes feed the same cost view.

flowchart LR
  A[Calder apps and agents<br/>on SAP BTP] --> G[AI gateway<br/>budgets and routing]
  G -->|capacity units| H[SAP generative AI hub]
  G -->|vendor list price| V[Vendor API<br/>batch jobs]
  H --> M[(Models)]
  V --> M
  G --> L[Usage log:<br/>model, tokens, job]
  P[(Price table<br/>with dates and sources)] --> R[Monthly cost report]
  L --> R

Non-functional requirements that decide the design:

Requirement Typical target What breaks if missed
Cost per task Known per job, per model, per date A price change surprises the budget owner
Price freshness Every price has a source and a read date; checked monthly A promotion ends and nobody notices
Model lifecycle Retirement dates tracked 90 days ahead A feature stops on a shutdown date
Data residency Written requirement per job You pay a regional premium you don't need, or skip one you do
Latency Batch only for jobs that can wait hours A clerk waits a day for an answer

Integration and identity. The usage log records the model, tokens by kind, the job and the agent's name, never the prompt text. The gateway calls the hub with a service key held on SAP BTP; a direct vendor call uses a key in the gateway's secret store. How the gateway enforces budgets is in AI gateways for model and agent traffic.

The decision to record. In the short form from Writing a solution design doc:

  • Context: Calder's invoice extraction runs on Gemini 3.8 Flash in the hub. Google's list price doubles on 1 January 2027; SAP hasn't said whether its rate changes.
  • Options: A, stay and accept whatever SAP's rate becomes; B, move the nightly job to a vendor's Batch API at half price, outside the hub; C, test a smaller tier (Gemini 3.5 Flash-Lite) on the evaluation set and switch if it passes.
  • Decision: C first, then A for whatever fails the test. B only if SAP's rate rises and the job's data may leave the hub's controls.
  • Consequences: a few days of evaluation work; one contract stays; the invoice job's accuracy is measured again before any switch.

What a design review will ask:

  1. Which jobs run on which model and route, and what does each cost per task today?
  2. Which prices or models change before the end of the budget year, and who owns the follow-up?
  3. Which jobs can run as batch, and what do they save?
  4. What does the evaluation say about the next smaller tier for each job?
  5. If data residency is required, is its premium in the budget?

Production concerns

  • Security and SAP authorizations. Moving a job from the hub to a vendor's API changes where data goes. Check the data processing terms and the masking you rely on in the hub before you move a job for price. A cost log holds counts and identifiers, not prompts.
  • Evaluation. Every model change, for price or retirement, needs a re-run of the job's evaluation set (Building an evaluation harness). A cheaper model that gets 5% more invoices wrong costs more in rework than it saves.
  • Cost. Keep prices in one table with sources and read dates. Re-run the comparison monthly and on every vendor announcement. Budget for the highest price in force during the budget year, not today's.
  • Operations. Track retirement dates 90 days ahead for every model in production, on the vendor's and on SAP's lists. Promotional prices need a calendar entry for their end date.
  • Clean core. Price and model changes happen outside S/4HANA. Features call S/4HANA through released APIs whatever model they use.

Pitfalls

  • Budgeting on an introductory price. Gemini 4 Argon's and GPT-5.6 Sol's November prices end within weeks.
  • Comparing price per token across vendors. Tokenizers differ; compare the cost of a whole task on your own prompts.
  • Assuming the hub follows the vendor's list. Your SAP rate is a contract question.
  • Caching a prefix that changes. A date or user name at the start of the prompt breaks every cache hit.
  • Using batch for interactive work. Half price is no saving if a person waits a day.
  • Ignoring retirements. A model that shuts down stops answering, whatever its price.
  • Forgetting the premium routes. Data residency and fast modes add 10% or more; put them in the table if you use them.
  • Copying prices without a date. A number without a read date and a source can't be checked later.

Exercise: re-price one of your own jobs

You will add one job of your own to the script and decide which model and mode it should use from 1 January 2027.

Before you start: finish Build it yourself, Steps 1 to 5.

  1. Pick a job you built earlier in the course, such as the blocked-orders assistant in unit10/token_costs.py from Token economics.

  2. Run that script once and note its token counts per call: the fixed prefix (system plus tools), the rest of the input and the output.

  3. In radar/model_prices.py, copy the "invoice_extraction" entry inside JOBS and paste it below, before the closing } of JOBS.

  4. Rename the copy "my_job", set its label, set "per_month_option": "my_volume", and type your token counts into "calls". Set "batchable" to True only if a person never waits for the answer.

  5. In main(), below the --invoices line, add:

    parser.add_argument("--my-volume", type=int, default=1000, help="runs of my job a month")
  6. Open each vendor's pricing page (links in SOURCES) and check two prices you rely on. If one changed, update it in PRICES and change READ_ON to today's date.

  7. Run:

    python radar/model_prices.py --hub
  8. Write three lines in a file radar/my_job_decision.md: the model and mode you choose for January, its monthly cost on 1 January 2027, and the next smaller tier you would test on your evaluation set.

Done when the table shows your job included in every model's monthly cost, every price you changed has a new READ_ON date, and radar/my_job_decision.md names a model, a mode, a cost and a smaller tier to test.

Check yourself

Pick one answer for each question. The explanation appears after you choose.

1Why does the script show n/a for GPT-5.6 Sol on 1 December 2026?

Answer: A. OpenAI's page says GPT-5.6 Sol's promotional pricing is available until 30 November 2026 and gives no later price. The script refuses to guess, which makes the gap visible instead of hiding it.

2In the order exception job, why does caching cut the cost by about half?

Answer: D. The agent sends the same 2,400-token prefix on each of its three calls, and later calls read it from the cache at a small fraction of the input price. The invoice job gains less because most of its tokens are the invoice itself.

3How does the script compute the cost of a batch run?

Answer: B. All three vendors price batch at half of standard, and their pages show cached and cache-write prices halved too (Anthropic says the multipliers stack). So job_cost multiplies the whole run's cost by BATCH_FACTOR.

4Calder's invoice job runs on Gemini 3.8 Flash in SAP's generative AI hub. What is the best first step before 1 January 2027?

Answer: B. The hub bills SAP's per-model rates, so the list price change is a question for SAP, not a certain doubling. Testing a smaller tier is the lever that can save the most, but only if it passes the evaluation.

5Two models list the same input and output prices. Why can the same job still cost more on one of them?

Answer: C. Each model family splits text into tokens its own way. Anthropic says its newer tokenizer produces about 30% more tokens for the same text, so equal rates don't mean equal cost per task.

6OpenAI shuts down gpt-5 on 11 December 2026. What should a team using gpt-5 through SAP's hub conclude?

Answer: A. SAP retires models on its own schedule, and the release notes read for this topic set no hub date for gpt-5. The vendor's shutdown is a warning sign, not proof of SAP's date either way.

7Which price table design lets the team re-price quickly when a vendor announces a change?

Answer: C. With one dated, sourced table, a change is one edit and a re-run, and anyone can check where each number came from. Past invoices and averages hide which model and date caused a change.

Sources

  • Gemini Developer API pricing (Google AI Studio) — read 2026-11-17; paid tier: Gemini 4 Argon input 2.00, output 10.00, caching 0.10 per 1M tokens through 30 November 2026, then 4.00, 20.00 and 0.20 from 1 December 2026; Gemini 3.8 Flash and 3.6 Flash 0.75, 3.75 and 0.075 through 31 December 2026, then 1.50, 7.50 and 0.15 from 1 January 2027 (TTS and Robotics ER models also double then); Gemini 3.5 Flash-Lite 0.30, 2.50, 0.03 with no date; Batch API '50% cost reduction'; explicit context caching also has an hourly storage price
  • What's new in Gemini 4 Argon (Gemini API documentation) — read 2026-11-17, page last updated 2026-10-27; model ID gemini-4-argon; introductory pricing through 30 November 2026, higher prices from 1 December 2026; implicit caching discount on cache hits; not on the free tier
  • Pricing (Claude API documentation, Anthropic) — read 2026-11-17; per-model input, 5-minute and 1-hour cache write, cache hit and output prices (Opus 5.5 4/20, Sonnet 5.5 2/10, Haiku 5.5 0.10/0.50 up to 100,000-token prompts, Opus 4.8 5/25, Sonnet 4.6 3/15, Haiku 4.5 1/5); cache hits 0.05x on Opus 5.5 and Sonnet 5.5, 0.025x on Fable and Mythos 5.1 and 5.2, 0.1x otherwise; Sonnet 5 introductory 2/10 became standard and the 1 September 2026 increase will not occur; Batch API 50% off; US-only inference 1.1x for Claude 4.6 and later; Claude 4.7 and later use a tokenizer that produces about 30% more tokens for the same text; no dated change announced for December 2026 or January 2027
  • Model deprecations (Claude API documentation, Anthropic) — read 2026-11-17; claude-sonnet-4-5-20250929 deprecated 30 September 2026, retirement 30 November 2026 (tentative), replacement claude-sonnet-5-5; claude-opus-4-5-20251101 active, not sooner than 24 November 2026; at least 60 days' notice before retiring publicly released models
  • API pricing (OpenAI developer documentation) — read 2026-11-17; standard short context (up to 272K input tokens): gpt-6-astra 10.00/50.00 (cached 1.00), gpt-6.1-sol 2.00/10.00 (0.10), gpt-6.1-terra 1.00/5.00 (0.05), gpt-6-luna 0.10/0.50 (0.01), gpt-5.6-sol 4.00/20.00 (0.40), plus '30m write' and '12h write' columns the page doesn't explain; Batch about half of Standard; GPT-5.6 Sol promotional pricing until 30 November 2026 with no later price stated; regional processing 10% uplift for models released on or after 5 March 2026; Priority renamed Fast mode on 30 July 2026; no dated list-price change for December 2026 or January 2027
  • Deprecations (OpenAI developer documentation) — read 2026-11-17; gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3 and o3-pro shut down 11 December 2026 (notice 11 June 2026; replacements gpt-6.1-sol, gpt-6.1-terra, gpt-6-luna); gpt-4o, gpt-4o-mini, gpt-4.1 and gpt-4.1-mini snapshots shut down 14 January 2027 (notice 14 October 2026; replacement gpt-6-luna)
  • SAP Cloud SDK for AI (JavaScript), release notes — read 2026-11-17; 2.16.0 (18 September 2026) adds gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gemini-3.5-flash-lite, mistralai--mistral-medium and SAP-RPT 1.5 and 1.6; 2.17.0 (22 October 2026) adds gpt-6-astra, gpt-6-luna, gpt-6.1-sol, gemini-3.8-flash, gemini-3.6-flash, deprecates mistralai--mistral-medium-instruct (removal 2026-11-30) and SAP-RPT 1 and 1.5 (2026-12-31); 2.14.0 adds anthropic--claude-4.5-opus and -4.8-opus; 2.18.0 (10 November 2026) has no model changes; no gemini-4-argon or Claude 5.x model names in the release notes
  • SAP Cloud SDK for AI (Java), release notes — read 2026-11-17; 2.0.0 (20 October 2026) adds GPT_6_ASTRA, GPT_6_LUNA, GPT_61_SOL, GPT_51 and QWEN_3_8_MAX to the orchestration model list; 2.0.0-M1 (25 September 2026) adds GEMINI_3_8_FLASH
  • Generative AI hub (sap.com product page) — read 2026-11-17; access to foundation models 'from SAP and leading providers'; 'priced by capacity units per year'; contract duration on request; no model names or per-model prices on the page
  • The finance challenge of managing AI token spend (SAP News, 8 September 2026) — read 2026-11-17; SAP's CMO for financial management and its chief controlling officer name token capping, tool rationalization and model routing as levers; 'Token spend is not a technology line item'

Sign in to track your progress

We'll email you a one-time sign-in link. No password needed.

or

Tell us a little about you

Optional, every field. It helps us pitch answers to your questions at the right level and decide which topics to write next. It is never shown publicly, and you can change or clear it anytime from the account menu.

SAP areas you work in