DEV Community

MT_Notes
MT_Notes

Posted on

Three New Models in 48 Hours: "Switching Models" Is Now a Four-Question Form

#ai #apigateway

1. Background: the price tables are done, the incidents are not

SpaceXAI shipped Grok 4.7 on September 21. Anthropic shipped Claude Opus 5.5 on September 22, and OpenAI followed roughly ninety minutes later with GPT-6 Sol and GPT-6 Luna. Three price tables in three days, and the press has covered the price war three times over. But the things that actually cause production incidents are not prices. They are four others: the request protocol, the long-context pricing cliff, the default effort level, and how many tokens a model actually burns.
For anyone running multi-model routing and automatic fallback, this round of releases asks four fill-in-the-blank questions. None of them is about price, and any one of them can make a "50% cheaper" claim impossible to reconcile.

2. Technical Deep Dive

2.1 Protocol divergence: Opus 5.5's four 400s
Anthropic's own migration docs list four breaking changes, and the first three also apply to Fable 5.1:

There is one more change that raises no error but alters the response shape: the short notes a model writes between tool calls now come back as progress-update thinking blocks, whose text is empty under the default display of omitted. A UI that streamed those notes as progress simply goes quiet between tool calls. Nothing errors; the user just stops seeing anything. To bring them back, set thinking.display to updates (the beta header thinking-display-updates-2026-08-18) or summarized.
GPT-6's protocol constraint sits somewhere else. OpenAI's model pages point built-in tools and function calling at the Responses API; on Chat Completions, function calling requires reasoning effort to be none. That matters enormously to gateways: plenty of compatibility layers normalize every vendor onto /v1/chat/completions and fan out from there, so the assumption that only the model field needs to change breaks the moment tools are involved.
2.2 Cliff divergence: three thresholds, three multipliers

The two OpenAI models put the cliff at 272,000 tokens; Grok puts it at 200,000. That is a 72,000-token gap. The multipliers differ too: GPT-6 doubles input but only lifts output by half, while Grok doubles everything. Which means "which of these models has the cheaper input price" has no answer in long-context work unless you also say which band the request lands in. A 300K-input request bills at double on Sol, and at double on Grok 4.7 with output rising as well. This is a cliff, not a marginal rate: splitting 300K into two 150K requests is often cheaper than sending it once.
One easily missed detail: Grok 4.7's cache read is $0.50 below 200K, but you have to ask for the hit. Set prompt_cache_key on the Responses API, or send the x-grok-conv-id header on Chat Completions. Without the hint, cache hits are unreliable, and cached input costs 75% less than fresh input.
2.3 Default effort and token consumption
Opus 5.5's default effort dropped from high on Opus 5 to medium. GPT-6 Sol and Luna default to medium. Grok 4.7 defaults to high, yet several headline benchmarks are reported at xhigh. Three vendors, three different defaults, which means "send the same prompt to all three" is not a like-for-like comparison to begin with. Anthropic's migration doc is blunt about it: set effort explicitly first, then re-run your sweep.
Token consumption deserves even more attention. Grok 4.7's per-token price is identical to Grok 4.6 — $$2 / $$6, with $$0.50 cache reads, all below 200K — but Artificial Analysis measured roughly 81,000 output tokens per Intelligence Index task in xHigh mode, against about 36,000 for Grok 4.6 in High mode. That is 125% more output. On the same index, a task works out to about $$3.74 on Grok 4.7 against about $1.99 on GPT-5.6 Sol. The unit price did not rise; the unit task did. Since reasoning tokens bill as output, the effort setting is currently the single biggest cost control you have.
2.4 Measured: one slug, five endpoints, 1.75x spread in what you actually pay

These figures come from OpenRouter's Claude Opus 5.5 model page, over a window that includes September 23. All five endpoints list exactly the same price, yet cache hit rates run from 80.6% to 91.7% and the effective input price runs from $$0.580 to $$1.016 — a 1.75x spread. The page's overall weighted average input price is $$0.8623, under a quarter of the $$4 list price, while the weighted average output price still sits at $$20.13 because output carries no cache discount. Several endpoints are excluded from the default routing pool, including a $$4.40 / $$22 tier priced 10% above list and a 2x Anthropic Fast tier at $$8 / $40.
The same page also reports availability: 99.92% for the model, against 98.48% without routing. List price is a horizontal line; what you actually pay is a distribution. Cost decisions require holding both variables at once — which endpoint served the request, and whether the cache hit.
2.5 In practice: turn the four questions into one table
In code, the four questions collapse into a capability table plus a small rewrite step:

from openai import OpenAI

client = OpenAI(base_url="https://router.accels.tech/v1", api_key="your-accels-key")

# Protocol constraints, cliff thresholds and default effort live with the model ID
MODELS = {
    "claude-opus-5-5": {"effort": "medium", "forced_tool": False, "cliff": None},
    "gpt-6-sol":       {"effort": "medium", "forced_tool": True,  "cliff": 272_000},
    "grok-4.7":        {"effort": "high",   "forced_tool": True,  "cliff": 200_000},
}

def build(model, messages, tools=None, must_call_tool=False, effort=None):
    caps = MODELS[model]
    kwargs = {
        "model": model,
        "messages": messages,
        "output_config": {"effort": effort or caps["effort"]},
    }
    if tools:
        kwargs["tools"] = tools
        # Fall back to auto where forcing is unsupported, then validate the result
        kwargs["tool_choice"] = "required" if (must_call_tool and caps["forced_tool"]) else "auto"
    return kwargs
Enter fullscreen mode Exit fullscreen mode

Three takeaways. Set effort explicitly rather than trusting a default, because the vendors disagree on what the default is. auto does not guarantee a tool call, so check and retry. And check the input token count against the cliff before sending — if you are over the line, split the request or compact the history rather than waiting for the vendor to warn you.

3. Where It Lands: Four Questions, One Entry Point

Every question above points at the same thing: switching models is no longer a string edit. It means maintaining protocol compatibility, cliff thresholds, effort levels and per-endpoint effective pricing at the same time. That is exactly why a model gateway like router.accels.tech has become practical in this release cycle. Accels is a Singapore-based company, and it puts multiple vendors' models behind a single OpenAI-compatible entry point:

  • Stable: one base_url. New models don't mean maintaining a separate SDK and key rotation per vendor, and when an endpoint errors or rate-limits, traffic can move to a healthy one. Your regression script only touches the model field.
  • Complete model coverage: Claude, GPT, Grok and other mainstream models sit behind one entry point, so the MODELS table above can cover every candidate in your fallback chain — cliff parameters like 272K and 200K declared alongside everything else.
  • Unified billing: usage across vendors lands on one bill, so comparing what "Opus 5.5 at medium" and "Grok 4.7 at xhigh" actually cost on the same task set doesn't require reconciling several invoices and several caching conventions. A usage pattern that fits today's topic: sample 200 real production requests, send them through the single entry point to all three models at low, medium and high effort, then measure the 400 rate, tool-call hit rate, cache hit rate and cost per task, and let the numbers set your migration pace: 
import concurrent.futures
from openai import OpenAI

client = OpenAI(base_url="https://router.accels.tech/v1", api_key="your-accels-key")
MODELS = ["claude-opus-5-5", "gpt-6-sol", "grok-4.7"]
EFFORTS = ["low", "medium", "high"]

def run(model, effort, sample):
    resp = client.chat.completions.create(
        model=model,
        messages=sample["messages"],
        output_config={"effort": effort},
    )
    u = resp.usage
    return {
        "model": model, "effort": effort,
        "input": u.prompt_tokens, "output": u.completion_tokens,
        "cached": u.prompt_tokens_details.cached_tokens,
    }

jobs = [(m, e, s) for m in MODELS for e in EFFORTS for s in samples[:200]]
with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
    rows = list(pool.map(lambda a: run(*a), jobs))

# Aggregate by (model, effort): cache hit rate, cost per task, 400s, tool-call failures
Enter fullscreen mode Exit fullscreen mode

Check the console's model list for the exact model IDs and available fields.

  1. Closing The real signal in this round is not in the price tables. Opus 5.5 made thinking a default that cannot be switched off, GPT-6 tied function calling to the Responses API, and Grok 4.7 traded an unchanged unit price for more output tokens. Each vendor moved one step — on protocol, on cliffs, on effort, on token burn — and getting any one of those four questions wrong makes the "half the price" arithmetic unreconcilable. Rather than firefighting every upgrade, write the capability table, the cliff thresholds and the adaptation layer into your router now. If you are about to migrate, run the old and new models side by side through router.accels.tech with a single key before you move production traffic.

Sources

Top comments (0)