DEV Community: AIHubMix

MiniMax M3.1 Flash vs DeepSeek V4.1 Flash vs Claude Haiku 5.5: Same Bug Fix, Measured

AIHubMix — Mon, 19 Oct 2026 10:54:28 +0000

TL;DR. One two-bug Python fix, 215 hidden tests, three runs per model through one AIHubMix key, on 19 October 2026. All 12 runs passed every test. At default settings, Claude Haiku 5.5 finished in about 7 s for $0.0007 per fix, DeepSeek V4.1 Flash 1017 in about 15 s for $0.0014, and MiniMax M3.1 Flash in 56 s for $0.0045. With reasoning_effort: "low", M3.1 Flash dropped to 9.5 s and $0.0006, the cheapest configuration tested.

On this task, the default thinking level shaped the bill more than the per-token price did.

The three models

	MiniMax M3.1 Flash	DeepSeek V4.1 Flash 1017	Claude Haiku 5.5
AIHubMix model ID	minimax-m3.1-flash	deepseek-v4.1-flash-1017	claude-haiku-5-5
Input / output per 1M	$0.165 / $0.66	$0.155 / $0.62	$0.10 / $0.50
Cache read per 1M	$0.0165	$0.0031	$0.01
Context / max output	1M / 512K	1M / 384K	1M / 128K
Input types	Text, image, video	Text, image	Text, image
Thinking can be off	No	Yes	Yes
Default thinking	max	On	medium
Open weights	Not yet	Yes (MIT)	No

These are AIHubMix list prices on 19 October 2026. A 30% AIHubMix discount on DeepSeek V4.1 Flash 1017 runs from 19 to 25 October and isn't included. Haiku 5.5's rate rises to $0.50 / $2.50 above 100K prompt tokens. DeepSeek's own API doubles its price at peak hours; AIHubMix lists one price. M3.1 Flash's video input is documented by MiniMax, while AIHubMix lists text and image.

Spec sources: MiniMax's model list, DeepSeek's models and pricing page, and Anthropic's Haiku page.

Why these three? They're the cheap tier of each vendor and launched within four weeks of each other:

DeepSeek V4.1 Flash came out on 10 September and its 1017 update on 17 October.
Haiku 5.5 came out on 7 October.
M3.1 Flash ran anonymously as Space Bunny Alpha from 23 September, was named on 27 September, and became callable per token on AIHubMix on 19 October.

During its free OpenRouter week, Space Bunny topped the daily chart ahead of DeepSeek V4.1 Flash.

Prerequisites

An AIHubMix key in AIHUBMIX_API_KEY (the quick start covers it).
Python 3.10+ and pip install openai.
All three models answer on https://aihubmix.com/v1/chat/completions, so only the model ID changes.

The task and the grader

The function under test has two bugs. A pause that runs past the period end subtracts the end day, which isn't in the period. Overlapping pauses get subtracted twice.

def billable_days(start: date, end: date, pauses: list[tuple[date, date]]) -> int:
    """Days in the half-open period [start, end) when the subscription was active.
    `pauses` holds inclusive (first_day, last_day) ranges..."""
    total = (end - start).days
    for p_start, p_end in pauses:
        s = max(p_start, start)
        e = min(p_end, end)
        if s <= e:
            total -= (e - s).days + 1
    return total

The prompt describes the two symptoms and asks for the corrected function in one code block. The grader pulls the last code block from the reply and runs it against 215 cases in an isolated subprocess:

15 hand-written edge cases: touching, nested, and duplicate pauses, a pause covering the whole period, an empty period, and a pause starting on the end date
200 random cases from a fixed seed, each checked against a brute-force reference that counts day by day

The original function passes 138 of the 215.

The request loop

import os, time
from openai import OpenAI

client = OpenAI(base_url="https://aihubmix.com/v1", api_key=os.environ["AIHUBMIX_API_KEY"])
prompt = open("task.md").read()

for model, extra in [("minimax-m3.1-flash", {"reasoning_effort": "low"}),
                     ("deepseek-v4.1-flash-1017", {}),
                     ("claude-haiku-5-5", {})]:
    t0 = time.time()
    r = client.chat.completions.create(model=model, max_tokens=32768,
                                       messages=[{"role": "user", "content": prompt}], **extra)
    print(model, round(time.time() - t0, 1), "s", r.usage.completion_tokens, "output tokens")

Thinking tokens are in usage.completion_tokens_details.reasoning_tokens. Cost is computed from prompt_tokens, prompt_tokens_details.cached_tokens, and completion_tokens at each model's AIHubMix price. Thinking is billed as output on all three.

Results

Three runs per row, Chat Completions, max_tokens 32,768, measured by AIHubMix on 19 October 2026:

Model and setting	Avg thinking tokens	Avg output tokens	Avg time	Avg cost per fix	Tests
Claude Haiku 5.5 (default)	755	1,323	7.2 s	$0.0007	215/215 ×3
DeepSeek V4.1 Flash 1017 (default)	1,823	2,148	14.6 s	$0.0014	215/215 ×3
MiniMax M3.1 Flash (default = max)	6,364	6,673	56.3 s	$0.0045	215/215 ×3
MiniMax M3.1 Flash (low)	591	889	9.5 s	$0.0006	215/215 ×3

Here is what the numbers say:

Same correctness. Twelve perfect fixes. This task doesn't separate the models on quality.
About 8× the thinking at default. Flash's default spent 6,364 thinking tokens against Haiku's 755. That's why Haiku's default costs about a sixth of Flash's default.
Flash at low is the cheapest, at $0.64 per 1,000 fixes against Haiku's $0.70. Haiku is still faster.
Throughput. Output tokens divided by wall time came to about 183 tok/s for Haiku, 148 for DeepSeek, and 112 for Flash.

Per 1,000 fixes: Haiku about $0.70, DeepSeek about $1.35, and Flash about $4.45 at default or $0.64 at low.

A second check sorted five support tickets into four labels, with each model at its default and at its lowest thinking setting. All 30 answers were correct, and every call cost under $0.0001. Thinking tokens per call were 0–6 for Flash, 0 for Haiku, and about 25 for DeepSeek.

Failure modes and fixes

Flash's default looks like a hang. With no effort field, M3.1 Flash thinks at max, and a small fix took 56 s on average. Client timeouts tuned for a fast model will fire. The fix is to send reasoning_effort on every request and start at low.

reasoning_effort: "none" doesn't zero DeepSeek's thinking through AIHubMix. On the triage prompts, DeepSeek used about 25 reasoning tokens with none and with the default alike. The cost difference is negligible. Just don't assume none gives you a non-thinking reply on this route.

Haiku's long-prompt price cliff. Above 100K prompt tokens, Haiku 5.5 bills $0.50 / $2.50. As an estimate for a 300K-token prompt with no cache, counting input only and assuming the higher rate applies to the whole prompt as OrcaRouter describes: Haiku costs 300,000 × $0.50 ÷ 1M = $0.15, while M3.1 Flash costs 300,000 × $0.165 ÷ 1M ≈ $0.05, about the same as DeepSeek. That's roughly 3× per call. Route large-context calls away from Haiku, or cache aggressively.

Promo prices drift. DeepSeek V4.1 Flash 1017's AIHubMix page shows the discounted price until 25 October. Budget on the list price.

What this test can't tell you

Quality differences. Every run passed, so a harder, multi-file task is needed to rank the models on correctness.
Statistical confidence. Three runs per setting is a small sample, and thinking length varies a lot between runs.
M3.1 Flash on a benchmark. MiniMax hasn't published one and Artificial Analysis doesn't list it. DeepSeek's benchmark scores are self-reported in its V4.1 Flash technical report. Haiku's Artificial Analysis score of 43 is cited by OrcaRouter.
Video input through AIHubMix. It's in MiniMax's docs but wasn't tested here.
Haiku's exact long-prompt rule. The $0.15 figure assumes the higher rate covers the whole prompt.

Which one to use

A person waiting, short prompts: Claude Haiku 5.5.
Benchmarks, self-hosting, or a real non-thinking mode: DeepSeek V4.1 Flash 1017.
Large context, long outputs, or video, with effort set explicitly: MiniMax M3.1 Flash at low or medium.

To check the price cards side by side, use AIHubMix's compare pages: M3.1 Flash vs DeepSeek V4.1 Flash 1017 and M3.1 Flash vs Claude Haiku 5.5.

Keep reading: the MiniMax M3.1 Flash series

For what M3.1 Flash is and what it replaced, from Space Bunny to its price against M2.7 and M3: MiniMax M3.1 Flash (ex-Space Bunny) on the API: Specs, Price, and a Measured Bug-Fix Cost
Flash's numbers above swing on one setting. Here's the same fix at all five effort levels: Measuring MiniMax M3.1 Flash's Five Effort Levels on One Bug Fix
If you're porting MiniMax M2.5/M2.7 code rather than starting fresh, read the 400s and silent changes first: Fixing "requires adaptive thinking" (2013) When Moving from MiniMax M2.7 to M3.1 Flash

Sources

Measuring MiniMax M3.1 Flash's Five Effort Levels on One Bug Fix

AIHubMix — Mon, 19 Oct 2026 10:54:22 +0000

TL;DR: We ran the same two-bug fix through MiniMax M3.1 Flash at all five effort levels plus "omitted", three runs each, and graded every answer against 215 hidden tests. Every run passed. The omitted default, which MiniMax documents as max, averaged 6,364 thinking tokens, 56 seconds, and $0.0045 per fix. low averaged 591 thinking tokens, 9.5 seconds, and $0.0006. So the default cost about 7× low and bought nothing on this task. Set low explicitly and move up per task.

The engineering problem: M3.1 Flash always thinks, and if the request has no effort field, MiniMax's text generation guide says it "defaults to max". Code migrated from MiniMax M2.x never set an effort level because M2.x had none. That code now runs at the most expensive setting by default.

Setup

Model: minimax-m3.1-flash on AIHubMix. Upstream reports MiniMax-M3.1-Flash.
Endpoint: POST https://aihubmix.com/v1/chat/completions, max_tokens: 32768, key from AIHUBMIX_API_KEY (see the AIHubMix quick start).
Date: 19 October 2026. Three runs per setting.
Prices (AIHubMix, per 1M tokens): $0.165 input, $0.66 output, $0.0165 cached input. Thinking tokens bill as output.

The task: a billing function with two bugs. A pause that runs past the period end double-counts one day, and overlapping pauses get subtracted twice. The prompt states both symptoms and asks for the corrected function in one code block. A local harness runs it against 215 cases: 15 hand-written edge cases plus 200 random ones checked against a brute-force reference. The original buggy function passes 138.

Field names per protocol

Protocol	Field	Values	Default
OpenAI Chat Completions	reasoning_effort	low, medium, high, xhigh, max	max
Anthropic Messages	output_config.effort	low, medium, high, xhigh, max	max
OpenAI Responses	reasoning.effort	low, medium, high, xhigh, max	max

All three protocols work for this model on AIHubMix. Thinking can't be turned off. MiniMax's Messages API reference says thinking: {"type": "disabled"} and effort none return HTTP 400 with model "MiniMax-M3.1-Flash" requires adaptive thinking. Older MiniMax models ignore the effort field.

The measurement loop

This is the shape of the run, minus the grader:

import os, time
from openai import OpenAI

client = OpenAI(base_url="https://aihubmix.com/v1", api_key=os.environ["AIHUBMIX_API_KEY"])
prompt = open("bugfix_prompt.md").read()

for effort in [None, "low", "medium", "high", "xhigh", "max"]:
    for run in range(3):
        extra = {"reasoning_effort": effort} if effort else {}
        t0 = time.time()
        r = client.chat.completions.create(
            model="minimax-m3.1-flash", max_tokens=32768,
            messages=[{"role": "user", "content": prompt}], **extra)
        u = r.usage
        print(effort or "omitted", run, round(time.time() - t0, 1),
              u.completion_tokens, u.completion_tokens_details.reasoning_tokens)

Results

Effort	Avg thinking tokens	Range (3 runs)	Avg time	Avg cost per fix	Tests
low	591	344–812	9.5 s	$0.0006	215/215 ×3
medium	1,522	970–2,488	21.7 s	$0.0013	215/215 ×3
high	2,863	2,194–3,673	27.1 s	$0.0022	215/215 ×3
xhigh	1,949	1,019–2,562	19.2 s	$0.0015	215/215 ×3
max	4,699	2,612–6,246	40.4 s	$0.0034	215/215 ×3
omitted	6,364	4,284–9,376	56.3 s	$0.0045	215/215 ×3

Cost arithmetic for the "omitted" row: 464 prompt tokens, about 192 of them cached, plus 6,673 output tokens. That's (272 × $0.165 + 192 × $0.0165 + 6,673 × $0.66) ÷ 1M ≈ $0.0045.

What the table supports:

Quality was flat. 18 Chat runs, 18 perfect fixes. On this bounded bug, thinking beyond low bought nothing measurable.
low → medium is a real step: about 2.6× the thinking tokens and more than twice the time.
Above medium, n=3 can't order the levels. xhigh averaged below high, and max overlaps both.
Omitted ≈ max, as documented. The higher "omitted" average is within run-to-run noise.
Time tracks tokens. Throughput held at about 112 output tokens per second across all 24 Flash runs (Chat and Messages), so a 6,000-token think costs close to a minute of wall time.

Short prompts behave differently. With five support tickets sorted into four labels, low used 0 thinking tokens and the default averaged 6, with every label correct. "What is 17 × 23?" at low produced no thinking and 2 output tokens. Adaptive thinking scales with the prompt, so the missing off switch barely costs anything on classification-style calls.

Failure modes and fixes

Truncation from thinking. Thinking counts toward max_tokens. One default run used 9,376 thinking tokens on a single function. A 4K or 8K limit carried over from M2.x can end with finish_reason: "length" and a cut-off answer. Fix: raise max_tokens (MiniMax recommends 131,072, max 524,288) and check finish_reason.

Latency spikes at a fixed level. On the Anthropic Messages endpoint, three low runs used 511, 1,861, and 6,060 thinking tokens; the last took 56 seconds. Effort sets the average depth, not a cap. Fix: set client and proxy timeouts to 120 s or more at high and above, and don't size timeouts from low averages alone.

Effort values that silently do nothing. Through AIHubMix, reasoning_effort values none, minimal, and auto all returned HTTP 200, and the model still thought. MiniMax's own endpoints reject unknown values, according to a gateway project's tests (sub2api issue #8025). Fix: send one of the five documented values. AIHubMix's unified reasoning parameters page describes how the gateway maps reasoning fields across vendors.

Tools that don't send a level. OpenCode resolves no effort variants for this model, so its effort toggle does nothing. Some frameworks also send "thinking disabled", which returns the 400. Fix: check the outgoing request body.

Mixed-model routing. M3 and M2.x ignore the effort field, so a level that saves money on Flash does nothing on the others.

Verify it reached the model. Read usage: completion_tokens_details.reasoning_tokens (Chat), output_tokens_details.thinking_tokens (Messages), output_tokens_details.reasoning_tokens (Responses). If these don't change when you change the level, the setting isn't arriving.

Setting it on Messages and Responses through AIHubMix:

import os
import anthropic
from openai import OpenAI

ant = anthropic.Anthropic(base_url="https://aihubmix.com", api_key=os.environ["AIHUBMIX_API_KEY"])
msg = ant.messages.create(
    model="minimax-m3.1-flash", max_tokens=32768,
    messages=[{"role": "user", "content": "Write a function that merges overlapping date ranges."}],
    extra_body={"output_config": {"effort": "medium"}},
)
print(msg.usage)

oai = OpenAI(base_url="https://aihubmix.com/v1", api_key=os.environ["AIHUBMIX_API_KEY"])
resp = oai.responses.create(
    model="minimax-m3.1-flash", reasoning={"effort": "low"}, max_output_tokens=32768,
    input="Write a function that merges overlapping date ranges.",
)
print(resp.usage)

Starting points

Only the first two rows are backed by the measurements above. The rest are recommendations to check against your own retry rates.

Workload	Start at	Move up when
Classification, extraction, routing	low	Labels are wrong on hard cases
Single-function fixes, small reviews	low	A fix fails tests twice
Multi-file changes, refactors	medium	The agent misses a dependent file
Agent loops with many tool calls	low or medium	Steps repeat or stall
Hard debugging, design questions	high	Answers stay shallow
Interactive chat, person waiting	low	Never default to max here

What we can't verify

Where higher levels start to pay off. Our task was solved at every level. MiniMax hasn't published per-level token, latency, or accuracy data, and one bounded task can't show where high, xhigh, or max earn their cost.
Ordering above medium. Three runs per level isn't enough to separate high, xhigh, and max.
Other tasks and prompt lengths. All numbers come from one short coding prompt and one classification prompt, measured by AIHubMix on 19 October 2026. Nobody else has reproduced them.

Keep reading: the MiniMax M3.1 Flash series

For the bigger picture behind this setting, from the Space Bunny launch to the price against M2.7 and M3: MiniMax M3.1 Flash (ex-Space Bunny) on the API: Specs, Price, and a Measured Bug-Fix Cost
Effort is one of several things that change when M2.5/M2.7 code moves over. This post covers the 400 errors and the rest: Fixing "requires adaptive thinking" (2013) When Moving from MiniMax M2.7 to M3.1 Flash
At low, Flash was the cheapest of three models on this same fix. Here's how its default compares with DeepSeek's and Haiku's: MiniMax M3.1 Flash vs DeepSeek V4.1 Flash vs Claude Haiku 5.5: Same Bug Fix, Measured

Sources

Fixing "requires adaptive thinking" (2013) When Moving from MiniMax M2.7 to M3.1 Flash

AIHubMix — Mon, 19 Oct 2026 10:54:14 +0000

Result first. We sent M2.x-style requests to MiniMax M3.1 Flash through AIHubMix on 19 October 2026. Three things broke or changed:

Disabling thinking on Chat Completions returns HTTP 400, code 2013, "requires adaptive thinking".
Every other way of asking for "no thinking" returns 200 and the model thinks anyway.
With no effort set, the model runs at max: on a small bug fix that meant about 6,400 reasoning tokens and 56 seconds, against about 600 tokens and 9.5 seconds at low. Both settings passed all 215 tests.

The rest of this post is the error, a minimal repro, the fixes, and what we couldn't verify.

Why this matters now

MiniMax retires M2.5 and M2.7 (plus the -highspeed variants) on 18 November 2026. Since 19 October, both families have been closed to new users. Requests on M Plan and Token Plan that name them are served by M3.1 Flash under the old name, per MiniMax's models page. Pay-as-you-go calls keep working until the retirement date, then stop: "Once retired, API requests to these models will no longer work." M2.1 and M2 aren't in the notice.

If you're on a plan, your logs still say M2.7 but the model behind it has changed: 1M context instead of 204,800, top_p 0.95 instead of 0.9, and thinking at max by default. Re-run your evals.

Prerequisites

An AIHubMix key in AIHUBMIX_API_KEY.
Model ID on AIHubMix: minimax-m3.1-flash. Responses report the upstream name as MiniMax-M3.1-Flash.
Endpoints that work for this model on AIHubMix (all tested): /v1/chat/completions, /v1/messages, /v1/responses.

The 400: repro and fix

curl https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "minimax-m3.1-flash",
       "messages": [{"role": "user", "content": "hi"}],
       "thinking": {"type": "disabled"}}'

Response, copied from our run:

{"error": {"message": "invalid params, model \"MiniMax-M3.1-Flash\" requires adaptive thinking; thinking.type=\"disabled\" (including reasoning.effort=none) is not allowed (2013) (tid: …)", "type": "bad_request_error", "param": "", "code": null}}

MiniMax's Messages API reference says the model "always thinks"; thinking.type, if sent, must be adaptive. Code written for M3 can hit this, because M3 can turn thinking off. Frameworks that classify the model as non-reasoning and send "thinking off" by default fail on every call, as the kodus-ai and 9router-go projects reported.

Fix: drop thinking, or send {"type": "adaptive"}. To make calls faster, lower the effort:

import os
from openai import OpenAI

client = OpenAI(base_url="https://aihubmix.com/v1", api_key=os.environ["AIHUBMIX_API_KEY"])

resp = client.chat.completions.create(
    model="minimax-m3.1-flash",
    reasoning_effort="low",   # low | medium | high | xhigh | max; omitted = max
    max_tokens=32768,         # thinking counts toward this
    messages=[{"role": "user", "content": "Explain in two sentences why the sky is blue."}],
)
print(resp.choices[0].finish_reason, resp.usage.completion_tokens_details.reasoning_tokens)

Same code 2013, different cause

invalid param: remote returned status 400 (2013) came back for an image URL on upload.wikimedia.org. The same request with a base64 image, or an image URL from another host, returned 200. 2013 is MiniMax's general invalid-params code. Our reading of this message is that the upstream couldn't fetch the image; MiniMax doesn't document the case. Send images as data:image/png;base64,… and read the full message before grepping logs for 2013.

Quiet failure modes (all return 200)

Request through AIHubMix	What actually happens
Messages, thinking disabled	Still thinks: 469–622 tokens on a short puzzle
Chat, reasoning_effort none	Still thinks: 265–372 tokens on the same puzzle
Chat, reasoning_effort minimal	Still thinks (one run, arithmetic prompt)
Effort omitted	Runs at max
max_tokens 64	finish_reason length, answer cut mid-sentence
cache_control blocks	Not supported; caching is automatic
service_tier	Not supported; no Priority tier

The puzzle rows are three runs each; low used 173–251 reasoning tokens on the same puzzle. Only Chat Completions with thinking: {"type": "disabled"} produces the 400.

Effort cost, measured. The task was a two-bug fix in one Python function, graded against 215 hidden tests. It ran three times per setting on Chat Completions.

Setting	Avg reasoning tokens	Avg time	Avg cost per fix
Effort omitted	6,364	56 s	$0.0045
Effort low	591	9.5 s	$0.0006

All runs passed. Prices are AIHubMix's: $0.165 input, $0.66 output, and $0.0165 cache read per 1M tokens. Thinking is billed as output, and it was 95% of the output at default (6,364 of 6,673 tokens).

Truncation. With max_tokens: 64 and a two-sentence question, the response was finish_reason: "length" with content "Sunlight contains many colors,". MiniMax recommends 131,072 and allows 524,288.

Caching. cache_control isn't supported on M3.1 Flash (or M3). M2.7 billed explicit cache writes at $0.375 per 1M tokens. Every request we sent, even the first, had about 175–195 prompt tokens served from cache. It looks like a fixed MiniMax-side preamble, and it costs about a third of a cent per thousand requests at AIHubMix's cache-read price.

Pricing gaps. MiniMax's pricing page has no per-token price for M3.1 Flash yet. M3's official price doubles above 512K input tokens; AIHubMix lists one flat price for M3.1 Flash, so check your first invoice if you send very long prompts.

Agents and coding tools

Agent behaviour that matters:

It reasons before every tool call, even at low; our short tool steps took about 2–7 s.
It follows instructions narrowly. An early tester called it "insanely fast, but it needs clear and specific instructions, otherwise it's too lazy." Give explicit stop conditions and verification steps.
MiniMax documents tool_choice as auto only. AIHubMix accepted "required" and {"type": "any"} and the tool was called, but forcing isn't documented. Don't rely on it.
Return thinking blocks unchanged (Messages) and keep reasoning_content intact (Chat), per MiniMax. A stripped short round trip worked in our test; long loops should follow the rule.

Protocol support, tested on 19 October with text, a tool call, and a tool-result round trip:

Tool	Protocol	Works via AIHubMix	Effort field
Claude Code	Anthropic Messages	Yes	output_config.effort
Codex CLI	OpenAI Responses	Yes	reasoning.effort
OpenCode	OpenAI-compatible	Yes	reasoning_effort

Claude Code (AIHubMix guide):

export ANTHROPIC_BASE_URL="https://aihubmix.com"
export ANTHROPIC_AUTH_TOKEN="$AIHUBMIX_API_KEY"
export ANTHROPIC_MODEL="minimax-m3.1-flash"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="minimax-m3.1-flash"

thinking: enabled with a budget and thinking: adaptive both returned 200.

Codex CLI (AIHubMix guide): use a custom provider with wire_api = "responses", model = "minimax-m3.1-flash", and model_reasoning_effort. Function calls come back as function_call items. xhigh and minimal were accepted. minimal isn't a MiniMax level, so the model still thinks.

OpenCode: issue #54801 (reproduced on v2.0.27) says OpenCode resolves no effort variants for this model. The workaround is to declare five variants in opencode.json. Through AIHubMix's OpenAI-compatible provider, each variant should set reasoning_effort (low … max) rather than the issue's output_config.effort. Don't add none.

The context window is 1,000,000 on MiniMax's API. MiniMax Code's own client defaults to 512K "to balance experience and cost", per a maintainer's quote of MiniMax's docs in the magpie project. The API has no window parameter.

Smoke test (about 15 minutes): give the agent a scratch folder with one known bug and a failing test, and ask it to "Run the tests, fix the bug, run the tests again, and show me the output." Pass criteria: tests run before and after, the final run is green, it takes a few turns, and no turn returns a 400. In the AIHubMix usage log, minimax-m3.1-flash requests should show reasoning tokens. If turns take close to a minute, the effort setting isn't reaching the model.

What we couldn't verify

Claude Code effort. Whether Claude Code's effort setting reaches a non-Claude model as output_config.effort isn't documented. If it doesn't, the model runs at max.
Forced tool calls. Whether tool_choice forcing is enforced or the model just happened to call the tool.
The image error. Why the Wikimedia URL failed; our explanation is a reading of the error text.
Long tool loops. Whether stripping thinking blocks breaks them. Our test was one short round trip.
AIHubMix's own M2.7 route. What happens to minimax-m2.7 on AIHubMix after 18 November isn't stated. MiniMax's retirement applies to MiniMax's API.
Sample size. All timings come from three runs per setting, so treat small differences as noise.

Keep reading: the MiniMax M3.1 Flash series

What you're migrating to, from the Space Bunny launch to its price against M2.7 and M3: MiniMax M3.1 Flash (ex-Space Bunny) on the API: Specs, Price, and a Measured Bug-Fix Cost
The effort setting decides most of your post-migration bill. All five levels, measured on one fix: Measuring MiniMax M3.1 Flash's Five Effort Levels on One Bug Fix
If you're reconsidering MiniMax altogether, the same task on its two closest rivals: MiniMax M3.1 Flash vs DeepSeek V4.1 Flash vs Claude Haiku 5.5: Same Bug Fix, Measured

Sources

MiniMax M3.1 Flash (ex-Space Bunny) on the API: Specs, Price, and a Measured Bug-Fix Cost

AIHubMix — Mon, 19 Oct 2026 10:54:04 +0000

Result first: MiniMax M3.1 Flash is now callable per token on AIHubMix as minimax-m3.1-flash ($0.165 input / $0.66 output per million tokens). On a two-bug fix in one Python function, it passed all 215 hidden tests at both settings we compared. Left at its default effort, it averaged 6,673 output tokens and 56 seconds per fix. At reasoning_effort="low" it averaged 889 tokens and 9.5 seconds. That's $0.0045 vs $0.0006 per fix.

If you're switching from M2.7 (MiniMax already reroutes plan traffic) or evaluating it against M3, the per-token price is only half the story. The effort setting decides the other half.

What this model is

M3.1 Flash first shipped anonymously. On 23 September it appeared on OpenRouter and OpenCode as Space Bunny Alpha: free, 1M context, multimodal, thinking always on. According to CellCog's timeline it topped OpenRouter's daily chart ahead of DeepSeek V4.1 Flash and stayed OpenCode's most-used model for five days. The community matched it to MiniMax through the tokenizer before MiniMax said anything. cheaty's comparison on X found the text tokenizer "perfectly matches that of the MiniMax M3", and other testers matched 36/36 and 50/50 probe strings.

Timeline:

Date (2026)	Event
23 Sep	Space Bunny Alpha live on OpenRouter and OpenCode
27 Sep	MiniMax names M3.1-Flash-Preview, default in MiniMax Code
30 Sep	Token Plan becomes M Plan, includes M3.1 Flash
19 Oct	M2.5/M2.7 closed to new users; plan requests routed to M3.1 Flash
19 Oct	minimax-m3.1-flash live on AIHubMix, pay per token

MiniMax's model list now drops the "Preview" label and calls it MiniMax-M3.1-Flash, a "frontier multimodal coding model with 1M context window and tunable thinking depth." Every AIHubMix response reports that upstream name.

Spec diff vs M2.7

	MiniMax M2.7	MiniMax M3.1 Flash
Context window	204,800	1,000,000
max_tokens (recommended / max)	65,536 / 204,800	131,072 / 524,288
Input	Text	Text, image, video
Thinking	Always on, no levels	Always on, five levels
Default thinking depth	—	max
Explicit cache_control	Supported, writes billed	Not supported
Default top_p	0.9	0.95
Status	Retires 18 Nov 2026	Current

Unchanged: both think on every request, both speak MiniMax's Anthropic-compatible and OpenAI-compatible APIs, and both accept only tool_choice: auto per MiniMax's API reference.

The new knob is effort. MiniMax's text generation guide lists low, medium, high, xhigh, and max, and the model uses max when the field is omitted. M2.7 code doesn't send this field, so after a model swap, every request runs at max.

Price table

Per million tokens, checked 19 October 2026. Official prices are from MiniMax's pay-as-you-go page; M3's includes MiniMax's "Permanent 50% off" label.

Model	Official input / output	AIHubMix input / output	AIHubMix cache read
MiniMax M2.7	$0.30 / $1.20	$0.2958 / $1.1832	$0.05916
MiniMax M3.1 Flash	not published	$0.165 / $0.66	$0.0165
MiniMax M3	$0.30 / $1.20	$0.288 / $1.152	—

On AIHubMix, Flash is about 44% below M2.7 ($0.165 ÷ $0.2958 ≈ 0.56) and about 43% below M3 ($0.165 ÷ $0.288 ≈ 0.57); output follows the same ratio. M3's official price doubles above 512K input tokens, while AIHubMix lists one flat price for Flash.

Measuring a real task

Prerequisites: an AIHubMix key in AIHUBMIX_API_KEY, and the openai Python SDK. The AIHubMix quick start covers both.

Task: a billing function billable_days(start, end, pauses) with two bugs. A pause that runs past the period end double-counts one day, and overlapping pauses are subtracted twice. The prompt describes the symptoms and asks for the corrected function only. A local harness then runs 215 hidden cases. Each setting ran three times through Chat Completions on 19 October 2026. These are AIHubMix's own measurements, not yet reproduced by anyone else.

The request, with cost computed from usage:

import os
from openai import OpenAI

client = OpenAI(base_url="https://aihubmix.com/v1", api_key=os.environ["AIHUBMIX_API_KEY"])
PRICE_IN, PRICE_OUT, PRICE_CACHE = 0.165, 0.66, 0.0165  # AIHubMix, per 1M tokens

def run(prompt, effort=None):
    extra = {"reasoning_effort": effort} if effort else {}
    r = client.chat.completions.create(
        model="minimax-m3.1-flash",
        max_tokens=32768,
        messages=[{"role": "user", "content": prompt}],
        **extra,
    )
    u = r.usage
    cached = (u.prompt_tokens_details.cached_tokens or 0) if u.prompt_tokens_details else 0
    cost = ((u.prompt_tokens - cached) * PRICE_IN + cached * PRICE_CACHE
            + u.completion_tokens * PRICE_OUT) / 1e6
    return r.choices[0].message.content, u.completion_tokens, cost

Results (3 runs each):

Setting	Avg output tokens	Avg time	Avg cost per fix	Tests passed
Effort omitted (= max)	6,673	56 s	$0.0045	215/215 every run
Effort low	889	9.5 s	$0.0006	215/215 every run

Here is the arithmetic for the default row: 464 prompt tokens, about 192 of them cached, plus 6,673 output tokens. (272 × $0.165 + 192 × $0.0165 + 6,673 × $0.66) ÷ 1,000,000 ≈ $0.0045. Per 1,000 such fixes, that's about $4.45 at the default and $0.64 at low.

Variance was large: the default ranged from 4,589 to 9,680 output tokens, and from 39 to 82 seconds. The effort post in this series has all five levels.

Failure modes when you switch

Unset effort means max. If your client never sends an effort field, expect long turns and thinking-heavy bills. Fix: send reasoning_effort (Chat Completions) on every request; start at low.
No way to skip thinking. M3 can run without thinking; Flash can't. Short classification prompts spent almost nothing (0 to 6 thinking tokens) in our runs, but zero isn't guaranteed. If a code path needs a guaranteed non-thinking call, keep it on M3.
No Priority tier. Flash rejects the service_tier field. If you relied on M3's Priority tier (1.5× price) for latency, there's no equivalent here.
Video isn't on AIHubMix's listing yet. MiniMax documents video input; AIHubMix currently lists text and image. Base64 images and image URLs both worked in our tests.
Prompts need to be specific. An early Space Bunny user called it "insanely fast, but it needs clear and specific instructions, otherwise it's too lazy." Spell out the expected output and the checks the model should run.

What we can't verify

Quality against M3. MiniMax published no benchmark for M3.1 Flash, and Artificial Analysis has no entry for it. M3 has MiniMax's self-reported 59.0% on SWE-Bench Pro and an Artificial Analysis Intelligence Index of 29.2. Any Flash benchmark table you see is either M3's or unsourced.
MiniMax's own per-token price. Not published as of 19 October 2026.
Harder tasks. Our task was bounded, and low was enough. Three runs per setting can't tell you where higher effort starts paying off.
Open weights. MiniMax says it plans to release them, with no date. M3's weights are on Hugging Face.

Should you switch

M Plan / Token Plan users on M2.5 or M2.7: you already have; MiniMax reroutes the names starting today. Re-run evals and add an effort setting.
Pay-as-you-go users on M2.5 or M2.7: you have until 18 November. On AIHubMix, change the model ID and add reasoning_effort.
Teams on M3 for coding agents: try Flash at low/medium on a slice of traffic. AIHubMix's compare page shows both price cards, and the model page has the ID and endpoints.
Stay on M3 if you need open weights, thinking off, independent benchmarks, or the Priority tier.

Keep reading: the MiniMax M3.1 Flash series

Switching existing M2.7 code? This one covers the 400 errors and the silent changes: Fixing "requires adaptive thinking" (2013) When Moving from MiniMax M2.7 to M3.1 Flash
The default effort drove most of the cost above. Here are all five levels on the same fix: Measuring MiniMax M3.1 Flash's Five Effort Levels on One Bug Fix
The same task on the two other cheap coding models released the same month: MiniMax M3.1 Flash vs DeepSeek V4.1 Flash vs Claude Haiku 5.5: Same Bug Fix, Measured

Sources

Codex config.toml: A Working Setup and What Each Error Means

AIHubMix — Mon, 19 Oct 2026 10:02:29 +0000

Recent Codex CLI releases reject parts of older config.toml files. A profile = "..." line, wire_api = "chat" or approval_policy = "untrusted" now stop it at startup, and a few other mistakes fail silently. Configs copied from guides written earlier in 2026 are the usual cause.

This post is the config that works on Codex CLI 0.162.1 with a custom provider, the checks to run after editing it, and the exact messages Codex prints when something is wrong. Checked on October 19, 2026, against OpenAI's configuration docs. AIHubMix is the provider in the examples; any gateway that serves the OpenAI Responses API is configured the same way.

TL;DR

File: ~/.codex/config.toml (C:\Users\<you>\.codex\config.toml on Windows). Codex reads it only at startup.
Provider: base_url, wire_api = "responses" (the only accepted value), and env_key, which names an environment variable holding the key.
Profiles: one file each, ~/.codex/<name>.config.toml, selected with --profile <name>. [profiles.x] tables inside config.toml are gone.
Project .codex/config.toml: trusted projects only, and it can't set model_provider.
Proxy: no config key. Codex follows HTTPS_PROXY, ALL_PROXY and NO_PROXY.

Prerequisites

Codex CLI installed (npm install -g @openai/codex), checked here on 0.162.1
An API key for your provider; for AIHubMix, from the AIHubMix console

The config

# ~/.codex/config.toml
model = "gpt-6-sol"
model_provider = "aihubmix"
model_reasoning_effort = "high"

[model_providers.aihubmix]
name = "AIHubMix"
base_url = "https://aihubmix.com/v1"
wire_api = "responses"
env_key = "AIHUBMIX_API_KEY"

# macOS / Linux: put this in ~/.zshrc or ~/.bashrc, then open a new terminal
export AIHUBMIX_API_KEY=sk-...

# Windows PowerShell: applies to terminals opened afterwards
setx AIHUBMIX_API_KEY "sk-..."

Three rules that cause most failures:

model_provider must match the table name, and the table name can't be openai, ollama or lmstudio, which belong to Codex's built-in providers.
env_key is the name of the variable, not the key. The key saved by codex login in auth.json is never sent to a custom provider.
Top-level keys go above the first [table] line. In TOML, everything after a table header belongs to that table.

Check it

codex exec "say ok"     # one non-interactive request
codex doctor            # install, config and auth checks

codex exec prints the effective settings before the request: model:, provider:, approval:, sandbox: and reasoning effort:. That header is the quickest way to see which values actually won. Note that codex exec reported approval: never in testing even with on-request in the config, because a non-interactive run has nobody to ask.

Profiles and project config

A profile is a file with only the keys that differ, written at the top level:

# ~/.codex/review.config.toml
model_reasoning_effort = "xhigh"
sandbox_mode = "read-only"

Run it with codex --profile review. The format changed in Codex 0.134.0; OpenAI's advanced configuration guide covers the migration.

A repo's .codex/config.toml is read only if the project is trusted in your user config:

[projects."/Users/you/code/my-app"]
trust_level = "trusted"

Even then, Codex drops model_provider, model_providers, openai_base_url, profile, notify and a few others from project files, so a repo can't redirect your requests. Keep providers in ~/.codex/config.toml.

Precedence

From OpenAI's Config basics, highest first:

CLI flags and -c key=value overrides
Project .codex/config.toml (closest to the working directory wins)
The --profile file
~/.codex/config.toml
/etc/codex/config.toml
Built-in defaults

The project file outranks the profile. In a test with a different model in the user config, a profile and a trusted project, codex exec --profile fast ran the project's model and only took the profile's reasoning effort; -m beat both.

Sandbox and approvals

Key	Values
sandbox_mode	read-only, workspace-write, danger-full-access
approval_policy	on-request, never, or a granular table

workspace-write allows writes in the working directory, /tmp and $TMPDIR, with no network until you set network_access = true under [sandbox_workspace_write]. never stops prompts but doesn't widen the sandbox.

Proxy

export HTTPS_PROXY=http://127.0.0.1:7890
export NO_PROXY=localhost,127.0.0.1
export CODEX_CA_CERTIFICATE=/path/to/corp-root-ca.pem   # only for TLS-inspecting proxies

OpenAI's environment variable reference documents CODEX_CA_CERTIFICATE but not the proxy variables. With Codex 0.162.1, requests to the custom provider went through HTTPS_PROXY, lowercase https_proxy and ALL_PROXY, and hosts in NO_PROXY were skipped.

Custom models in /model

/model lists only OpenAI's models unless a top-level model_catalog_json points at a catalog file. The catalog replaces the built-in list, and every entry needs the full internal field set, so generate it: the AIHubMix Codex CLI guide has a script that clones a built-in entry for the top 30 AIHubMix models. Verify with codex debug models.

Failure modes and fixes

`legacy profile = "..." config is no longer supported`

A profile = "..." selector is still in config.toml. Move the profile into its own file and delete the selector. With a leftover [profiles.x] table, --profile x fails with --profile x cannot be used while ... contains legacy ... config. Without the flag, the table is ignored silently.

`wire_api = "chat" is no longer supported`

Change it to responses. Providers that only serve Chat Completions need a translating proxy.

`model_providers contains reserved built-in provider IDs`

Rename a provider called openai, ollama or lmstudio. To repoint the built-in OpenAI provider, set the top-level openai_base_url instead.

`approval_policy = "untrusted" is no longer supported`

Remove it or use on-request. on-failure is deprecated but still accepted.

`Missing environment variable: AIHUBMIX_API_KEY`

The variable named in env_key isn't in the environment Codex started from. New terminal, or source ~/.zshrc.

401 Unauthorized after "Reconnecting..."

The request carried no key. Check env_key; auth.json doesn't apply to custom providers.

`Model metadata for ... not found. Defaulting to fallback metadata`

A warning for any model outside Codex's catalog, normal for non-OpenAI models. Requests still work; a catalog removes it.

`Ignored unsupported project-local config keys`

A project file set a user-only key, usually model_provider. Move it to ~/.codex/config.toml.

`missing field base_instructions`

A catalog entry is incomplete and the whole file is rejected. Regenerate the catalog instead of hand-editing it.

Not verified here

PAC files: Codex has no setting for them; the behavior described in third-party write-ups wasn't tested.
The desktop app's model picker: it may hide catalog models (openai/codex#19694); only the CLI was tested.
No real requests were sent for the error tests; each used a throwaway CODEX_HOME and an unreachable base URL.

Sources

Config basics (OpenAI)
Advanced configuration (OpenAI)
Configuration reference (OpenAI)
Codex CLI integration guide (AIHubMix)
Codex CLI proxy configuration: SOCKS, HTTP, and corporate networks (Daniel Vaughan)

DeepSeek V4.1 Flash 1017: Same Price, Shorter Outputs, and AIHubMix vs OpenRouter Pricing

AIHubMix — Mon, 19 Oct 2026 05:35:27 +0000

DeepSeek V4.1 Flash 1017 keeps the September checkpoint's per-token price and API surface, and by DeepSeek's own chart it cuts the cost of a DeepSWE task from about $0.50 to just under $0.20 while the score rises from 74.2% to 77.0%. Terminal-Bench 4.0 goes from 31.2 to 42.3. All of these are DeepSeek's numbers; nobody has reproduced them yet.

The engineering problem is that the upgrade ships as a checkpoint swap, not as a new API. On October 17, 2026, DeepSeek pointed deepseek-flash at 1017, so anything calling DeepSeek directly has already moved, and the September checkpoint can't be pinned. On AIHubMix, 1017 has its own ID, deepseek-v4.1-flash-1017, so you choose when to switch. Either way, three things need checking on your own workload:

which checkpoint actually answered;
whether shorter outputs break anything downstream;
what a finished task costs now, not what a token costs.

This post covers what changed, a working request through AIHubMix, how to confirm the checkpoint, the cost math, how AIHubMix and OpenRouter compare on price, and the failure modes worth testing for.

What changed, in one table

Item	September V4.1 Flash	V4.1 Flash 1017
Architecture	552B MoE, 8B / 16B active	Same
Context / max output	1M / 384K	Same
Input	Text and images	Same
Thinking default	On, effort high	Same
Effort levels	low / high / max	Same
DeepSeek API name	deepseek-flash	deepseek-flash (now 1017)
List price	Unchanged	Unchanged
Output length	Long	Shorter (DeepSeek, not quantified)

The Hugging Face model card calls it "a minor update", and DeepSeek's release note calls it "a Pareto improvement in performance and cost". The architecture and API are untouched; the post-training is new, described by DeepSeek as "reinforcement learning with self-feedback to improve end-to-end project development".

The legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp still resolve on DeepSeek's API, and both now run on 1017 at Flash prices.

The benchmark deltas

Figures come from DeepSeek's model card and changelog, compiled the same way by The Decoder and Kingy.ai; nobody has reproduced them independently.

Benchmark	September	1017	Change
Terminal-Bench 4.0	31.2	42.3	+11.1
ProgramBench	20.3	29.1	+8.8
Apex Bench v1.1	64.6	72.1	+7.5
HLE, no tools	36.8	42.6	+5.8
Automation-Bench	54.8	60.5	+5.7
Agents' Last Exam	31.8	35.4	+3.6
DeepSWE v1.1	74.2	77.0	+2.8
NL2Repo-Bench	65.4	68.2	+2.8
BabyVision, with tools	89.6	92.5	+2.9

Terminal-Bench 4.0 ran in the Claude Code harness; DeepSWE in mini-SWE-v2.

Read it by workload. Long terminal sessions and building a program from scratch moved the most, which matches the training DeepSeek describes. Repository-level bug fixing (DeepSWE, NL2Repo) and vision moved two to three points. If your agent mostly patches existing repos, expect a smaller step than the headline number.

Prerequisites

An AIHubMix API key exported as AIHUBMIX_API_KEY. The AIHubMix quick start walks through creating one.
The OpenAI Python SDK (pip install openai), pointed at https://aihubmix.com/v1.
The model ID deepseek-v4.1-flash-1017. AIHubMix serves it on Chat Completions, the Responses API, and Anthropic Messages; the sample below uses Chat Completions.

The request

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIHUBMIX_API_KEY"],
    base_url="https://aihubmix.com/v1",
)

resp = client.chat.completions.create(
    model="deepseek-v4.1-flash-1017",
    messages=[{"role": "user", "content": "Write a Python function that merges overlapping intervals."}],
    reasoning_effort="high",
    max_tokens=32000,
)
print(resp.choices[0].message.content)

reasoning_effort="high" is the default anyway; it's set explicitly so the level shows up in your code review. Thinking is on by default, and reasoning tokens count toward max_tokens, so leave room. The model card recommends at least 256K for long agent runs.

Confirm which checkpoint answered

AIHubMix ran a set of requests against deepseek-v4.1-flash-1017 on October 19, 2026, one run per check:

Every response's model field read deepseek-v4-1-flash-261017. Log resp.model: that string is how you know the 1017 checkpoint answered.
reasoning_effort values low, high, and max were all accepted with HTTP 200.
The response included reasoning_content, and usage.completion_tokens_details.reasoning_tokens reported the thinking share of the output, which is the number to watch when you compare effort levels.
Chat Completions, the Responses API (/v1/responses), and Anthropic Messages (/v1/messages) all returned 200.

Cost: the token price is fixed, the token count isn't

Model	DeepSeek input	DeepSeek output	AIHubMix input	AIHubMix output
V4.1 Flash (September)	$0.30	$1.20	$0.3098	$1.2392
V4.1 Flash 1017	$0.30	$1.20	$0.3098	$1.2392
V4 Pro 0813	$1.32	$3.96	$1.3944	$4.1832

Peak prices per 1M tokens, cache miss. Peak hours are 01:00–04:00 and 06:00–10:00 UTC on weekdays; every other hour, weekends, and Chinese public holidays are off-peak at half price. Flash cache hits cost $0.006 on DeepSeek and $0.0062 on AIHubMix at peak. AIHubMix is running a limited-time 30% discount on 1017; the figures here use list prices.

Since the price per token is identical, any saving has to come from fewer tokens. The September checkpoint was verbose: when Artificial Analysis ran its Intelligence Index on it at max effort, it generated about 250M output tokens against a 130M median, and 62% more than DeepSeek's V4 Pro 0813. DeepSeek's DeepSWE chart, as read by The Decoder, puts the September model at 74.2% for about $0.50 a task, 1017 at its top setting at 77.0% for just under $0.20, and 1017 at its low setting above 72% for about $0.10.

To turn that into a per-session number, here is an estimate from stated assumptions, because no published test gives per-task token counts for 1017: a bug-fix session of 40 model calls, 1.2M input tokens in total with 90% served from cache, and 60K output tokens including thinking. At AIHubMix list prices:

Model	Peak	Off-peak
V4.1 Flash 1017	$0.118	$0.059
V4 Pro 0813	$0.469	$0.233

1017, peak: 0.12M × $0.3098 + 1.08M × $0.0062 + 0.06M × $1.2392 = $0.118

The same token counts cost exactly the same on the September model. What changes is the token count itself: if 1017 needs fewer turns and shorter answers for the same fix, the bill shrinks with them. Running batch work off-peak halves it again.

Effort is the other lever. DeepSeek's V4.1 Flash paper maps the API's low, high, and max tiers to internal effort values of 50, 75, and 100, and reports that the last step to max "lengthens agent trajectories by 1.6–1.8× for only marginal improvements". Start agents at high and reserve max for the hardest tasks.

AIHubMix vs OpenRouter

OpenRouter serves 1017 as deepseek/deepseek-v4.1-flash-1017 through 15 providers, so its price depends on which one answers. The like-for-like row is DeepSeek's own endpoint:

Route	Input	Output	Cache hit
OpenRouter, DeepSeek endpoint	$0.30	$1.20	$0.006
AIHubMix, DeepSeek channel	$0.3098	$1.2392	$0.0062
AIHubMix, ByteDance, Oct 19–25	$0.1971	$0.7885	$0.0039

Peak prices per 1M tokens, checked October 19, 2026; both halve off-peak on the same schedule. AIHubMix serves 1017 through DeepSeek, ByteDance, and Alibaba Cloud channels. The ByteDance channel lists at $0.2816 / $1.1264, is 30% off October 19–25 (UTC) with the discount applied automatically to deepseek-v4.1-flash-1017, and adds a cache storage fee of $0.0024 per 1M tokens per hour. AIHubMix has no top-up fee; OpenRouter adds no markup to DeepSeek's price but charges 5.5% when you buy credits by card.

Through October 25 that makes AIHubMix about 34% cheaper per token, or 38% once OpenRouter's card fee is counted. At list price, the DeepSeek channel is 3.3% higher per token but about 2% cheaper after the card fee, and the ByteDance channel is 6% lower per token. For the session above: $0.075 against $0.114 at peak ($0.121 with the fee), and $0.038 against $0.057 off-peak.

OpenRouter won't route to DeepSeek's endpoint by default, though. Without provider preferences it picks among stable providers weighted by the inverse square of price, and several third-party hosts undercut every peak price above:

Host on OpenRouter	Weights	Input	Output	Session
Relace	Not stated	$0.05	$0.10	$0.023
DeepInfra	fp8	$0.098	$0.294	$0.033
Wafer	mxfp4	$0.10	$0.50	$0.045
Morph	fp8	$0.043	$0.60	$0.047
InferenceNet	fp8	$0.08	$0.50	$0.048

Flat rates per 1M tokens around the clock, checked October 19, 2026. "Weights" is the quantization OpenRouter lists. Off-peak, the discounted ByteDance channel ($0.0986 / $0.3942, $0.038 per session) beats Wafer, Morph, and InferenceNet; Relace and DeepInfra stay cheaper.

Check two things before routing production traffic there: output quality on quantized weights, since DeepSeek's benchmarks weren't run on these hosts, and the output cap, since DeepInfra and InferenceNet stop at 131K tokens on OpenRouter, below the 256K the model card recommends for long agent runs. To pin DeepSeek's endpoint instead, pass "provider": {"only": ["deepseek"]} in the request body (extra_body in the OpenAI SDK).

Failure modes and fixes

A parser that worked on September output starts failing

Shorter outputs can break parsers and evaluation checks written around the old verbosity. Before moving production prompts with strict output formats, run your regression suite against deepseek-v4.1-flash-1017 and diff the failures against your September baseline.

Your "September" traffic on DeepSeek is already 1017

On DeepSeek's own API, deepseek-flash is a rolling alias, and deepseek-v4-flash and deepseek-v4-flash-vision-exp now run on 1017 too. There is no pinned name for September. If you need reproducible behaviour, call a dated model ID; on AIHubMix that's deepseek-v4.1-flash-1017, and log resp.model so a change would show up.

Answers come back short or cut off at a low max_tokens

Thinking is on by default and its tokens count toward max_tokens. A budget sized for a non-thinking model leaves little room for the answer. Keep it generous (the sample uses 32,000), go to 256K or more for long agent runs as the model card recommends, and watch reasoning_tokens in the usage block.

The bill doesn't drop the way the chart suggests

Two usual causes. Traffic that lands in the weekday peak window (01:00–04:00 and 06:00–10:00 UTC) pays twice the off-peak rate, so move batch jobs out of it. And max effort lengthens agent runs by 1.6–1.8× by DeepSeek's own measure; if an agent framework sets it globally, drop it back to high and raise it per task.

Where it is not the right model

Knowledge-heavy questions. HLE without tools is 42.6, well behind Claude Opus 5 (56.3) and below Claude Haiku 5.5 (45.9, Anthropic's figure).
Long, hard shell sessions. 42.3 on Terminal-Bench 4.0 is a big jump, but Sonnet 5.5 (70.6) and Opus 5.5 (66.4) are in a different league there.
Workloads that need a frozen model on DeepSeek's API, for the alias reason above.

For context on the comparisons DeepSeek chose: inside its own lineup, 1017 has passed V4 Pro 0813 on every agentic benchmark DeepSeek publishes for both (Terminal-Bench 4.0: 42.3 vs 12.4; DeepSWE: 77.0 vs 62.7). Against Claude Opus 5 it leads on DeepSWE, Automation-Bench, Agents' Last Exam, and Apex, while Opus 5 leads on Terminal-Bench 4.0 (51.8), ProgramBench (37.0), NL2Repo (75.3), and HLE (56.3). Opus 5.5, Sonnet 5.5, and the GPT-6 generation are not in DeepSeek's table; Google separately reports Opus 5.5 at 66.4 on Terminal-Bench 4.0.

What hasn't been verified

Every benchmark number above is DeepSeek's own. No third party has reproduced them.
How much shorter the outputs are. DeepSeek hasn't published a figure, and the per-task costs are The Decoder's reading of a vendor chart, not a measurement.
Per-task token counts for 1017. The session cost above is an estimate from assumptions.
Effort cost through AIHubMix. The October 19 test used trivial prompts, and the reasoning token counts (68, 39, and 54 for low, high, and max) don't separate the levels. It confirms the parameter passes through, nothing more.
Quality on OpenRouter's quantized hosts. No published test compares their output with DeepSeek's endpoint.

Decision rules

Switch now: coding agents, terminal automation, and tool-calling pipelines on the September Flash. Same price, better scores, and fewer tokens per task by DeepSeek's measure.
Switch after a regression run: production prompts with strict output formats, or anything gated by an evaluation suite.
Stay put or look elsewhere: knowledge-heavy Q&A and hard debugging that already needs a frontier model.

The AIHubMix compare page shows the two Flash checkpoints' specs and prices side by side.

Keep reading: the DeepSeek V4.1 Flash 1017 series

Switching an existing tool loop? The reasoning_content 400, the alias swap, and peak-hour billing each have their own fix in the migration guide: Migrating to DeepSeek V4.1 Flash 1017: The reasoning_content 400, the Silent Alias Swap, and Peak-Hour Billing
If Terminal-Bench is the number you care about, this runs 1017 and Anthropic's cheapest model on the same terminal coding task: DeepSeek V4.1 Flash 1017 vs Claude Haiku 5.5: Which Cheap Model for Terminal Coding Agents?
Running V4 Pro 0813 next to the Flash? This one checks whether Pro still earns its 3.3× output price: DeepSeek V4.1 Flash 1017 vs V4 Pro: Is the Flash Enough Now?

Sources

DeepSeek-V4.1-Flash-1017 release note (DeepSeek)
DeepSeek-V4.1-Flash-1017 model card (Hugging Face)
DeepSeek V4.1 Flash 1017 on AIHubMix (AIHubMix)
Deepseek V4.1 Flash 1017 beats larger rivals in agentic tasks (The Decoder)
DeepSeek V4.1 Flash 1017 on OpenRouter (OpenRouter)

Migrating to DeepSeek V4.1 Flash 1017: The reasoning_content 400, the Silent Alias Swap, and Peak-Hour Billing

AIHubMix — Mon, 19 Oct 2026 05:35:18 +0000

If a DeepSeek tool loop fails with HTTP 400 on the request right after its first tool call, DeepSeek's docs point to one dropped field: reasoning_content. That's the loud part of moving to DeepSeek V4.1 Flash 1017. The quiet part happened on October 17, 2026, when DeepSeek swapped the checkpoint behind deepseek-flash without changing the name or the price. Many apps migrated that afternoon without anyone deciding to.

This post is the engineering side of the move: reproduce and fix the 400, detect the swap from the response itself, see what peak hours and the effort setting do to the bill, and wire Claude Code, Codex, and DeepSeek Harness to the new checkpoint. On AIHubMix it has its own ID, deepseek-v4.1-flash-1017, so the switch happens when you change the model string, not when DeepSeek ships.

TL;DR

With tools in the request, DeepSeek requires the reasoning_content of every earlier assistant turn. Drop it and DeepSeek's API returns 400. Append the whole assistant message to your history.
deepseek-flash, deepseek-v4-flash, and deepseek-v4-flash-vision-exp on DeepSeek's API all run 1017 now, and there is no pinned name for the September checkpoint. Log the response's model field and rerun your evals.
Weekday peak hours (01:00–04:00 and 06:00–10:00 UTC) cost twice the off-peak rate. A sample agent session comes to $0.118 at peak and $0.059 off-peak.
Keep effort at high. DeepSeek's own paper says max lengthens agent runs 1.6–1.8× for marginal gains.
Through AIHubMix, Chat Completions, Anthropic Messages, and the Responses API all returned 200 in a one-run test on October 19.

Prerequisites

An AIHubMix API key in AIHUBMIX_API_KEY.
Model ID deepseek-v4.1-flash-1017. OpenAI-format clients use the base URL https://aihubmix.com/v1; Claude Code uses https://aihubmix.com.
For the smoke test at the end: git, Python with pytest, and one of Claude Code, Codex, or DeepSeek Harness.

What AIHubMix tested

AIHubMix sent a short set of requests to deepseek-v4.1-flash-1017 on October 19, 2026, at 03:02 UTC. Each check ran once, so read every row as "worked once", not as a guarantee.

Check	Endpoint	Result
Effort low, high, max	Chat Completions	200 for all three
Tool turn 2 without reasoning_content	Chat Completions	200, normal answer
Two-turn tool call	Anthropic Messages	200 on both turns
No effort setting	Anthropic Messages	No thinking block
output_config.effort set to low	Anthropic Messages	Thinking block returned
reasoning.effort set to low	Responses	200, reasoning + message

Every response carried "model": "deepseek-v4-1-flash-261017", the 1017 checkpoint.

Failure 1: HTTP 400 on the request after a tool call

Symptom. The request that sends the tool result back fails with this message, as reported in a GitHub issue against opencodex for V4.1 Flash on October 15:

[invalid_request_error] The `reasoning_content` in the thinking mode must be passed back to the API.

The same text shows up in earlier reports against opencode, LangChain, and claude-code-router for V4 Pro and V4 Flash.

Cause. DeepSeek's thinking mode guide says that when a request includes tools, the reasoning_content of every earlier assistant turn must be sent back, "even for turns where the model did not perform a tool call". If it isn't, "the API will return a 400 error". Without tools, sending it back is optional and ignored. Clients trip on this because their message serialiser keeps content and tool_calls and drops the extra field.

Reproduce. Turn two of a tool loop, with the assistant message stripped of reasoning_content:

curl -s https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash-1017",
    "tools": [{"type": "function", "function": {"name": "get_weather",
      "parameters": {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}}}],
    "messages": [
      {"role": "user", "content": "What is the temperature in Hangzhou? Use the tool."},
      {"role": "assistant", "content": null, "tool_calls": [{"id": "call_00_example", "type": "function",
        "function": {"name": "get_weather", "arguments": "{\"city\": \"Hangzhou\"}"}}]},
      {"role": "tool", "tool_call_id": "call_00_example", "content": "{\"celsius\": 18}"}
    ]
  }'

On DeepSeek's own API, this is the shape that returns the 400 in the public reports. Through AIHubMix, the same shape returned HTTP 200 and a normal answer in the October 19 run. That was one request, and the response doesn't show which upstream channel served it, so treat it as an observation, not a contract.

Fix. Keep the field, whichever route you use:

msg = resp.choices[0].message
messages.append(msg)  # carries content, reasoning_content, and tool_calls over

In your own code, append the whole assistant message, not a hand-built copy of it.
In frameworks, upgrade: opencode fixed the round trip in later releases, and opencodex merged its fix on October 16.
As a last resort, set {"thinking": {"type": "disabled"}} for tool loops. That avoids the error but gives up the reasoning that makes the model good at agent work.

Failure 2: no error, different model

DeepSeek's changelog for October 17: "The API calling method and pricing remain unchanged — simply use deepseek-flash to access the latest model." There is no pinned name for the September checkpoint, and the two older Flash names run on 1017 too.

Nothing throws, but three things can shift under your tests:

Output length. 1017 was trained to produce shorter outputs. Parsers, UI layouts, and prompts that expected the September model's long explanations may get less text. DeepSeek hasn't put a number on how much shorter.
Evaluation baselines. Scores and costs recorded on the September checkpoint no longer describe what deepseek-flash returns.
Behaviour. DeepSeek retrained 1017 for end-to-end project work, so agents may take different paths to the same result.

Detect it. The response tells you which checkpoint answered. Through AIHubMix, every response in the test carried "model": "deepseek-v4-1-flash-261017". Store that field and the date with every evaluation run, rerun your regression set now, and an unannounced swap shows up the day it happens.

Failure 3: the bill doubles at weekday peak

DeepSeek charges full price 01:00–04:00 and 06:00–10:00 UTC on weekdays, and half price at every other hour, all weekend, and on Chinese public holidays. AIHubMix uses the same windows and prices each request at the time it was submitted, so a long streaming request that starts off-peak stays off-peak.

Item	Peak	Off-peak
Input, cache miss	$0.3098	$0.155
Input, cache hit	$0.0062	$0.0031
Output	$1.2392	$0.62

AIHubMix list prices per 1M tokens for deepseek-v4.1-flash-1017. A limited-time 30% discount is running on top.

A worked example, under stated assumptions: one agent session of 40 calls, 1.2M input tokens with 90% cache hits, and 60K output tokens.

Peak: 0.12M × $0.3098 + 1.08M × $0.0062 + 0.06M × $1.2392 = $0.118
Off-peak: the same tokens at half the rate = $0.059

Three levers move that number:

Schedule. Moving batch runs off-peak is the single biggest saving.
Cache. Hits are 50 times cheaper than misses. Agents resend the same system prompt, tool definitions, and history on every call; keep that prefix stable and put anything that changes per call at the end.
Thinking. It's on by default, and reasoning tokens count toward both the bill and max_tokens.

One date to put in the calendar: DeepSeek opened its new Search and Fetch APIs on October 17 at $0.75 per 1,000 successful calls each. Server-side calls made through DeepSeek Harness, Claude Code, or Codex on DeepSeek's API are free until October 31, 2026, 16:00 UTC. After that, an agent that searches on every turn adds a per-call cost on top of tokens.

Failure 4: settings that cost more than they return

Effort. The API offers low, high (default), and max. DeepSeek's V4.1 Flash paper maps them to internal effort values of 50, 75, and 100, and reports that the step to max "lengthens agent trajectories by 1.6–1.8× for only marginal improvements". DeepSeek's own Claude Code setup guide still sets CLAUDE_CODE_EFFORT_LEVEL=max. For everyday agent work, high is the better default.

Other effort names get folded in: minimal becomes low, while medium and xhigh both become high. A tool that offers five levels effectively gives you two or three. In the October 19 test, AIHubMix accepted low, high, and max on Chat Completions.

max_tokens. The model card recommends at least 256K for long agent runs, because thinking shares the output budget. With a small cap, a hard step can spend the whole budget thinking. Alert on finish_reason: "length".

Sampling. In thinking mode, temperature, presence_penalty, and frequency_penalty are accepted without error and have no effect. top_p is clamped to 0.95–1.0. A pipeline that relied on low temperature for deterministic output no longer gets it.

Before you give it shell access

1017 was trained with reinforcement learning on whole projects, so it tends to keep building until the job looks done. Its answers are also shorter, which means less narration of what it changed.

Review diffs and command logs, not the model's summary of them.
Run it in a sandbox with an allowlist of commands, and require approval for anything destructive: deletes, force pushes, migrations, outbound network calls.

DeepSeek itself flags the Flash line's strength on security tasks; the September checkpoint scored 88.1 on CyberGym in DeepSeek's own table. That's useful for defensive work, and another reason to scope its permissions tightly.

Wiring the coding tools

AIHubMix serves deepseek-v4.1-flash-1017 on all three protocols these tools need: Claude Code speaks Anthropic Messages, Codex the Responses API, DeepSeek Harness Chat Completions.

Claude Code. Point it at AIHubMix as in the Claude Code guide and set the model:

export ANTHROPIC_BASE_URL="https://aihubmix.com"
export ANTHROPIC_AUTH_TOKEN="$AIHUBMIX_API_KEY"
export ANTHROPIC_MODEL="deepseek-v4.1-flash-1017"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-v4.1-flash-1017"
export CLAUDE_CODE_SUBAGENT_MODEL="deepseek-v4.1-flash-1017"
export CLAUDE_CODE_EFFORT_LEVEL="high"

Keep an effort level set. In the test, a Messages request with no effort setting came back without a thinking block, while one with output_config.effort returned thinking. Check the request logs to confirm 1017 is reasoning.
The [1m] suffix. DeepSeek's guide adds it to the model name for its own endpoint; it wasn't tested through AIHubMix.
Known issue. Through some routers, Claude Code has dropped thinking content and hit the 400 above (claude-code-router issue 1378). The two-turn tool test through AIHubMix's Messages endpoint didn't hit it.

Codex. Follow the Codex CLI guide: an aihubmix provider with base_url = "https://aihubmix.com/v1" and wire_api = "responses", and model = "deepseek-v4.1-flash-1017". To pick it from /model, add it to a model_catalog_json file with context_window set to 1,000,000.

The guide's catalog script offers low, medium, and high. Under DeepSeek's mapping, medium and high both land on DeepSeek's high, so you get two real levels.
Newer Codex versions discard the whole catalog if a single required field is missing. The guide's script avoids that.

DeepSeek Harness. DeepSeek says 1017 works best with Harness 0.2.1-rc.1 or later. Add AIHubMix as an OpenAI-compatible provider following the DeepSeek Harness guide, then add deepseek-v4.1-flash-1017 as a model. The guide was written against an earlier Harness release, so check field names if the UI has changed.

A 15-minute smoke test

Create a tiny repo with one failing test:

mkdir flash-smoke && cd flash-smoke && git init -q
printf 'def mean(xs):\n    return sum(xs) / len(xs)\n' > stats.py
printf 'from stats import mean\n\ndef test_mean():\n    assert mean([1, 2, 3]) == 2\n\ndef test_empty():\n    assert mean([]) == 0\n' > test_stats.py

Start your tool in that folder and ask: "Run pytest, fix the failing test by changing stats.py only, then run pytest again." It passes if:

the agent makes at least two tool calls (run the tests, edit the file) with no 400;
both tests pass at the end;
the AIHubMix request log shows deepseek-v4.1-flash-1017, and the session cost is a few cents at most.

What this doesn't tell you

The 200 on the stripped tool turn. One request, upstream channel not visible. DeepSeek's rule still stands; send the field.
Effort cost. The effort check used a trivial prompt, and its reasoning token counts (68, 39, and 54 for low, high, and max) don't separate the levels. The cost argument for high rests on DeepSeek's paper, not on this test.
Context suffix. The [1m] model-name suffix from DeepSeek's Claude Code guide is untested through AIHubMix.
Harness UI. The AIHubMix Harness guide predates 0.2.1-rc.1.
"Shorter outputs". DeepSeek doesn't quantify it. Compare completion_tokens on your own prompts with what you logged on the September checkpoint.

Keep reading: the DeepSeek V4.1 Flash 1017 series

Want the benchmark and cost case before touching your integration? The upgrade post compares 1017 with the September checkpoint: DeepSeek V4.1 Flash 1017: Same Price, Shorter Outputs, and AIHubMix vs OpenRouter Pricing
Wiring Claude Code anyway? See how 1017 compares with the model Claude Code uses for its own subagents: DeepSeek V4.1 Flash 1017 vs Claude Haiku 5.5: Which Cheap Model for Terminal Coding Agents?
Migrating from V4 Pro rather than the old Flash? This one checks whether you still need Pro at all: DeepSeek V4.1 Flash 1017 vs V4 Pro: Is the Flash Enough Now?

Sources

Thinking Mode (DeepSeek)
Change Log (DeepSeek)
Integrate with AI Tools (DeepSeek)
DeepSeek V4.1 Flash 1017 on AIHubMix (AIHubMix)
DeepSeek V4.1 Flash returns reasoning_content 400 after tool calls, issue 7118 (GitHub)

DeepSeek V4.1 Flash 1017 vs Claude Haiku 5.5: Which Cheap Model for Terminal Coding Agents?

AIHubMix — Mon, 19 Oct 2026 05:35:05 +0000

Take one Claude Code session: 40 model calls, a prompt that grows from 20K to 176K tokens. At AIHubMix list prices, DeepSeek V4.1 Flash 1017 runs it for $0.152 at peak hours ($0.076 off-peak) and Claude Haiku 5.5 for $0.288. Stop the same session after 21 calls, before the prompt crosses 100K tokens, and the order flips: Haiku 5.5 costs $0.040, 1017 costs $0.077 at peak and $0.039 off-peak. On capability, the one benchmark both vendors report for this kind of work, Terminal-Bench 4.0, has them roughly level: 42.3 for 1017 and 39.2 for Haiku 5.5, both vendor-reported.

That is the engineering problem. You have a cheap slot in your agent setup, either the main loop for long runs or a subagent for short calls, and two candidates released ten days apart: Haiku 5.5 on October 7 and 1017 on October 17, 2026. Their cost curves cross at Haiku's 100K-token price tier. Their benchmark numbers come from different harnesses and settings. Each one returns 400s if you migrate carelessly. This post gives the published numbers, a script to redo the cost math with your own token counts, a one-key setup for running both in Claude Code, and the failure modes on each side.

What you need

An AIHubMix API key exported as AIHUBMIX_API_KEY. Both models are on AIHubMix: deepseek-v4.1-flash-1017 and claude-haiku-5-5.
Claude Code installed.
One failing test or small task from your own repo, to run through both models.

Run both models in Claude Code with one key

Point Claude Code at AIHubMix, as in the AIHubMix Claude Code guide:

export ANTHROPIC_BASE_URL="https://aihubmix.com"
export ANTHROPIC_AUTH_TOKEN="$AIHUBMIX_API_KEY"
export ANTHROPIC_MODEL="deepseek-v4.1-flash-1017"
claude

Two things to do once it's running:

Keep an effort level set, for example CLAUDE_CODE_EFFORT_LEVEL=high. In AIHubMix's October 19 test over the Anthropic Messages protocol (the one Claude Code uses), 1017 completed a two-turn tool call, but the request with no effort setting came back with text and a tool call and no thinking block. A request with an effort level returned one.
Switch models inside the session with /model claude-haiku-5-5. Same key, same repo state. Run the same failing test through both, then compare the diffs and the request logs.

For specs and prices side by side, the AIHubMix compare page lists both models.

The benchmark picture

Terminal-Bench 4.0 scores long shell sessions with real tools on whether the agent finishes the job, which is the closest public match to a Claude Code session. DeepSeek's figures come from its model card and Anthropic's from the Haiku 5.5 announcement. Nobody has run both models under the same harness and settings yet.

Model	Terminal-Bench 4.0	Reported by
Claude Sonnet 5.5	70.6	Anthropic
DeepSeek V4.1 Flash 1017	42.3	DeepSeek
Claude Haiku 5.5	39.2	Anthropic
DeepSeek V4.1 Flash (Sept)	31.2	DeepSeek

DeepSeek ran Terminal-Bench 4.0 in the Claude Code harness. Anthropic does not state Haiku's effort level in the headline table.

Three points between two vendor numbers with different settings is not a decisive win; read it as "roughly level, 1017 slightly ahead". The independent Haiku 5.5 runs published so far come in below Anthropic's figure and disagree with each other, and AIHubMix has not found an independent Terminal-Bench 4.0 result for 1017 yet. Anthropic's own guidance puts both cheap models below the top tier for this work: "Sonnet 5.5 and Opus 5.5 remain better choices for complex agentic coding tasks like those measured by Terminal-Bench 4.0."

Beyond Terminal-Bench, the vendors publish almost no shared numbers. DeepSeek reports DeepSWE v1.1 (77.0) and ProgramBench (29.1); Anthropic reports FrontierCode 1.1 (46.4) and OSWorld 2.1 (72.4). None of those has a published score for the other model. What the spec sheets do let you compare:

Area	V4.1 Flash 1017	Claude Haiku 5.5
Terminal-Bench 4.0	42.3	39.2
HLE, no tools	42.6	45.9
Context window	1M	1M
Max output	384K	128K
Input types	Text, images	Text, images, PDF
Price above 100K prompt	Unchanged	5x
Effort levels	3	5
Open weights	Yes, MIT	No

Vendor-reported benchmark figures. DeepSeek's effort levels are low, high, and max; Haiku's are low, medium (default), high, xhigh, and max.

The cost model

No published test gives per-task token counts for either model, so the numbers above come from stated assumptions:

40 model calls. The prompt starts at 20K tokens and grows by 4K per call (tool output plus the previous answer), ending at 176K.
Each call reads the earlier prompt from cache and adds 4K new tokens.
Each call produces 1.5K output tokens, thinking included.
Both models get the same token counts, although their tokenizers differ.
AIHubMix list prices. 1017: new tokens at the cache-miss rate, the cached prefix at the cache-hit rate, peak or off-peak. Haiku 5.5: new tokens written to the 5-minute cache, the prefix read from it, and any call whose prompt exceeds 100K billed entirely at the higher tier ($0.50 input, $2.50 output, $0.05 cache read, $0.625 cache write per 1M tokens).

Session	1017 peak	1017 off-peak	Haiku 5.5
First 21 calls, prompt up to 100K	$0.077	$0.039	$0.040
Full 40 calls, prompt up to 176K	$0.152	$0.076	$0.288

On Haiku 5.5, the 19 calls above 100K cost $0.248 of the $0.288. For 1017 at peak, the full session is 176K new × $0.3098 + 3.744M cached × $0.0062 + 60K output × $1.2392 = $0.152 (prices per 1M tokens).

The script below reproduces the table. Replace the call count, prompt growth, and output size with numbers from your own request logs; your real token counts will differ between the two models because the tokenizers do.

# Cost of one Claude Code session at AIHubMix list prices (USD per 1M tokens).
# Assumptions: 40 calls; the prompt starts at 20K tokens and grows 4K per call;
# each call reads the earlier prompt from cache, adds 4K new tokens, and writes 1.5K output.
M = 1_000_000
FLASH = {"peak": (0.3098, 0.0062, 1.2392), "off-peak": (0.155, 0.0031, 0.62)}  # miss, hit, out
HAIKU = {"short": (0.125, 0.01, 0.50), "long": (0.625, 0.05, 2.50)}  # 5-min write, read, out


def calls(n):
    prompt = 20_000
    for i in range(n):
        new = prompt if i == 0 else 4_000
        yield prompt, prompt - new, new, 1_500  # prompt, cached, new, output
        prompt += 4_000


def flash(tier, n):
    miss, hit, out = FLASH[tier]
    return sum(new * miss + cached * hit + o * out for _, cached, new, o in calls(n)) / M


def haiku(n):
    total = 0.0
    for prompt, cached, new, o in calls(n):
        write, read, out = HAIKU["long" if prompt > 100_000 else "short"]  # whole request
        total += new * write + cached * read + o * out
    return total / M


for n in (21, 40):
    print(f"{n} calls: 1017 peak ${flash('peak', n):.3f}, "
          f"off-peak ${flash('off-peak', n):.3f}, Haiku 5.5 ${haiku(n):.3f}")

21 calls: 1017 peak $0.077, off-peak $0.039, Haiku 5.5 $0.040
40 calls: 1017 peak $0.152, off-peak $0.076, Haiku 5.5 $0.288

Two levers move these numbers:

On Haiku 5.5, keep each request under 100K. Claude Code's /compact and short-lived subagents do that. The same 40 calls billed entirely at the short-prompt rate would cost $0.089.
On 1017, schedule batch and overnight agent runs outside 01:00–04:00 and 06:00–10:00 UTC on weekdays, which halves the bill. AIHubMix is also running a limited-time 30% discount on 1017, not included above.

Failure modes and fixes

Haiku 5.5 returns 400 on parameters that worked before

The API rejects temperature values other than 1, any top_k, manual budget_tokens thinking, and assistant prefill, all with a 400. Strip them from the request and control depth with the effort level instead.

The Haiku 5.5 bill jumps once sessions get long

Past 100K prompt tokens, input, output, and cache prices for the whole request rise to five times the short-prompt rate. In the example above, the 19 calls over the line cost $0.248 of the session's $0.288. Compact or hand work to short-lived subagents before the prompt reaches 100K, or put long-running loops on 1017.

1017 fails after the first tool call on DeepSeek's own API

DeepSeek's thinking mode guide requires every earlier assistant turn's reasoning_content to go back to the API when tools are in use; otherwise the request fails with a 400. Public GitHub reports quote the error as [invalid_request_error] The `reasoning_content` in the thinking mode must be passed back to the API. A client that drops the field breaks right after its first tool call. Keep the whole assistant message, reasoning_content included, when you append it to the history. In AIHubMix's October 19 test, the same turn sent without reasoning_content returned 200. The migration post in this series covers this error and the peak-hour billing rules in detail.

1017 answers without thinking

Over the Messages protocol, a request with no effort setting returned no thinking block in AIHubMix's test. Set CLAUDE_CODE_EFFORT_LEVEL (or the effort field in your own requests) so 1017 reasons before acting.

Haiku 5.5 refuses security work

ComputingForGeeks' review notes that Haiku 5.5 over-refused more than any other model in an automated behavioural audit, and that stricter cyber classifiers block some security work. If your agent does security tooling, test those steps first and keep another model available for them. The same review reports the upside: in Gray Swan coding scenarios, prompt-injection success fell from 58.4% on Haiku 4.5 to 0.08%.

What this comparison can't verify

Benchmarks: every score here is vendor-reported, under different harnesses and settings. A same-harness run of both models doesn't exist yet.
Token counts: the session is a model, not a measurement. Neither vendor publishes per-task token counts, and the two tokenizers count the same text differently.
The AIHubMix test: one run per check on October 19, 2026. The channel that served each request isn't visible, so the 200 on the missing-reasoning_content turn shows what happened in that run, not a guarantee for every route.

Which one goes where

1017: main-loop coding agents with long contexts, overnight or batch runs you can schedule off-peak, and tasks that build a program from a spec.
Haiku 5.5: short, scoped subagent calls under 100K tokens, document-heavy steps, computer use, and pipelines that read untrusted web or repo content.
Both: in one Claude Code setup, a stronger model plans, 1017 does long execution, and Haiku 5.5 handles quick lookups and summaries. Neither replaces Sonnet 5.5 or Opus 5.5 for the hardest shell sessions.

Keep reading: the DeepSeek V4.1 Flash 1017 series

Before 1017 takes the main-loop slot, see what the October checkpoint changed and how much shorter its outputs made each task: DeepSeek V4.1 Flash 1017: Same Price, Shorter Outputs, and AIHubMix vs OpenRouter Pricing
The reasoning_content failure mode above gets the full treatment there, with fixes for your own code and for agent frameworks, plus the peak-hour billing rules: Migrating to DeepSeek V4.1 Flash 1017: The reasoning_content 400, the Silent Alias Swap, and Peak-Hour Billing
If 1017 wins your side-by-side run, the same test can tell you whether DeepSeek's pricier tier still earns its place: DeepSeek V4.1 Flash 1017 vs V4 Pro: Is the Flash Enough Now?

Sources

DeepSeek-V4.1-Flash-1017 model card (Hugging Face)
Introducing Claude Haiku 5.5 (Anthropic)
DeepSeek V4.1 Flash 1017 vs Claude Haiku 5.5 (AIHubMix)
Claude Haiku 5.5: Pricing, Benchmarks, Tested (ComputingForGeeks)
DeepSeek V4.1 Flash 1017 Tested: Specs, Benchmarks & Price (Kingy.ai)

DeepSeek V4.1 Flash 1017 vs V4 Pro: Is the Flash Enough Now?

AIHubMix — Mon, 19 Oct 2026 05:34:49 +0000

DeepSeek's cheaper model now beats its pricier one. On every coding and agent benchmark DeepSeek publishes for both, V4.1 Flash 1017 (October 17) scores higher than V4 Pro 0813: 42.3 against 12.4 on Terminal-Bench 4.0, 77.0 against 62.7 on DeepSWE v1.1. Pro still costs 3.3 times as much per output token, and on a costed agent session it comes out at about four times the Flash's bill.

On paper that settles it. In practice, if you run a pipeline that was tuned on deepseek-v4-pro-0813, those are DeepSeek's numbers, not yours. The engineering problem is verifying the switch on your own workload: pass rate, output length, and cost per run, measured the same way on both models. This post collects the published numbers, gives a short script that calls both models with one key, and lists what skews the comparison.

The published numbers

Price

Model	Input, peak	Output, peak	Cache hit, peak
V4.1 Flash 1017	$0.30	$1.20	$0.006
V4 Pro 0813	$1.32	$3.96	$0.044

USD per 1M tokens, from the DeepSeek pricing page. Off-peak is half price for both models. AIHubMix lists Flash 1017 at $0.3098 / $1.2392 and Pro 0813 at $1.3944 / $4.1832 (input / output, peak).

The ratios: Pro is 4.4× on input, 3.3× on output, and over 7× on cache hits. On DeepSeek's own API, Pro's concurrency limit is also a fifth of the Flash's: 500 against 2,500.

Benchmarks

Pro figures come from Table 3 of DeepSeek's V4.1 Flash paper, all at max effort; 1017 figures come from the model card. All of them are DeepSeek's measurements, and nobody has reproduced them.

Benchmark	V4 Pro	Flash (Sept)	Flash 1017
Terminal-Bench 4.0	12.4	31.2	42.3
DeepSWE v1.1	62.7	74.2	77.0
ProgramBench	15.5	20.3	29.1
NL2Repo-Bench	61.5	65.4	68.2
Automation-Bench	43.2	54.8	60.5
Agents' Last Exam	25.7	31.8	35.4
HLE, text-only subset	42.7	39.1	44.0
GPQA Diamond	92.4	90.9	—

A dash means DeepSeek has not published that score for 1017.

The September Flash had already passed Pro on every coding and agent row; 1017 widened the gap. On the text-only HLE subset, 1017 (44.0) is now ahead of Pro (42.7) too. Pro's one possible remaining lead is GPQA Diamond. Artificial Analysis reached the same verdict independently on its general index in September, calling V4.1 Flash DeepSeek's "new flagship" ahead of V4 Pro 0813.

One session, costed

No published test gives per-task token counts for either model, so this is an estimate from stated assumptions: an agent bug-fix session with 40 model calls, 1.2M input tokens in total (90% cache hits), and 60K output tokens including thinking. Same token counts on both models, AIHubMix list prices:

Model	Peak	Off-peak
V4.1 Flash 1017	$0.118	$0.059
V4 Pro 0813	$0.469	$0.233

Pro, peak:   0.12M × $1.3944 + 1.08M × $0.0465 + 0.06M × $4.1832 = $0.469
Flash, peak: 0.12M × $0.3098 + 1.08M × $0.0062 + 0.06M × $1.2392 = $0.118

Pro costs about four times as much per session. To break even, Pro would have to finish the same job with roughly a quarter of the Flash's tokens. The only published verbosity measurement says otherwise: Artificial Analysis found the September Flash used 1.62 times Pro 0813's output tokens on its index, so Pro needed about 62% as many, not 25%.

Prerequisites

An AIHubMix API key exported as AIHUBMIX_API_KEY. The AIHubMix quick start walks through creating one.
The OpenAI Python SDK (pip install openai), pointed at https://aihubmix.com/v1.
Both model IDs: deepseek-v4.1-flash-1017 and deepseek-v4-pro-0813. One key covers both.
An eval set from your real workload, with a pass/fail check you already trust.

The script uses Chat Completions (/v1/chat/completions), the endpoint AIHubMix's model listing shows for 1017.

Run both models on the same prompt

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["AIHUBMIX_API_KEY"], base_url="https://aihubmix.com/v1")

for model in ("deepseek-v4-pro-0813", "deepseek-v4.1-flash-1017"):
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": "Find the bug: def mean(xs): return sum(xs) / len(xs) - 1"}],
        max_tokens=16000,
    )
    print(model, resp.usage.completion_tokens, resp.choices[0].message.content[:200])

Each line of output is the model ID, its completion_tokens, and the first 200 characters of the answer. Replace the single prompt with your eval set and record three things per model:

Pass rate on your own checks. The benchmarks say the Flash should win on coding and agent work; your eval set says whether that holds for you.
completion_tokens per prompt. This is the number that decides cost. 1017 was trained for shorter outputs, but nobody has measured it against Pro yet, so your logs are the first measurement that applies to your workload.
Cost per run, read from the AIHubMix request logs rather than estimated from list prices.

Failure modes that skew the comparison

The Flash prints more tokens, so it looks more expensive

Token counts alone don't decide cost. At the prices above, Pro only breaks even if it uses about a quarter of the Flash's tokens. Multiply by price before you compare.

The same eval costs twice as much on one run as on another

Off-peak is half price for both models. If one model's run lands at peak and the other's off-peak, the cost gap halves or doubles. Run the two back to back, in the same price window.

Image cases can't be scored on Pro

Pro does not take images at all; 1017 does. Split screenshot, chart, and UI cases out of the shared eval set. If your workflow has any of them, that decides the question on its own.

No 1017 score for your science-QA workload

GPQA Diamond is the one benchmark where Pro (92.4) beat the September Flash (90.9), and DeepSeek has not published a 1017 score. If science QA is your main workload, test it on your own questions before moving.

What nobody has verified yet

Every benchmark number above is DeepSeek's own; no third party has reproduced them.
The paper's Pro column does not name the 0813 build. Its Terminal-Bench 2.1 score matches the 0813 card, which is why it's read as 0813 here.
1017's output length against Pro. Artificial Analysis's 62% figure is for the September Flash, and no third party has re-measured 1017.
Per-task token counts for either model. The session cost above is an estimate from assumptions, not a measurement.

Decision rules

Keep Pro if you have a production pipeline validated on Pro 0813 and no time to re-run evaluations this month, or a science-QA workload where the GPQA gap has shown up in your own tests.
Move to the Flash for coding agents, terminal automation, tool-calling pipelines, anything with images, and anything high-volume where concurrency matters.
Test before moving long-form writing and analysis where you have relied on Pro's shorter, denser answers.

There is no deadline forcing the move: DeepSeek's changelog says it will keep serving V4 Pro, and no retirement date has been announced. The AIHubMix compare page lists both models' specs and prices side by side while you run the evals.

Keep reading: the DeepSeek V4.1 Flash 1017 series

Your eval results describe one checkpoint, and DeepSeek updates the Flash in place; here's what changed in 1017: DeepSeek V4.1 Flash 1017: Same Price, Shorter Outputs, and AIHubMix vs OpenRouter Pricing
If the evals pass and you move the integration, this covers the thinking-mode 400 and the billing rules that apply to both models: Migrating to DeepSeek V4.1 Flash 1017: The reasoning_content 400, the Silent Alias Swap, and Peak-Hour Billing
Once the Flash replaces Pro, the next comparison is outside DeepSeek's lineup: DeepSeek V4.1 Flash 1017 vs Claude Haiku 5.5: Which Cheap Model for Terminal Coding Agents?

Sources

DeepSeek models and pricing (DeepSeek)
DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression (DeepSeek-AI, arXiv)
DeepSeek V4.1 Flash 1017 vs DeepSeek V4 Pro 0813 (AIHubMix)
DeepSeek V4.1 Flash (max): Intelligence, Performance & Price Analysis (Artificial Analysis)
DeepSeek V4.1 Flash 1017 Tested: Specs, Benchmarks & Price (Kingy.ai)

Qwen3.8 Max Free vs Qwen3.8 Flash Free: Is Flash Enough?

AIHubMix — Fri, 16 Oct 2026 06:34:37 +0000

TL;DR: Route to Flash by default and escalate to Max only when Flash's output fails a check. Both are free on AIHubMix until around November 13, 2026 (Pacific Time), or until the campaign credits run out, but they draw on one shared 1M-token daily pool. On the free route, Max takes about 11x longer to start answering and generates about a quarter as fast, and its tokens are worth about 14x as much at paid rates. On Qwen's own numbers, Flash is within about a point of Max on office tasks and graduate-level science questions; Max pulls ahead on repo-level coding and very hard reasoning.

The engineering problem

Two free model IDs, qwen3.8-max-free and qwen3.8-flash-free, same endpoint, same price ($0). The constraints that actually matter:

One pool. After a top-up of $1 or more, all AIHubMix free models share 100 requests a day, 10 a minute and 1M tokens a day. Every Max call is a call you can't make on Flash.
Very different speeds. On AIHubMix's own measurement of the free route, Max shows about 55 s latency and about 9 tok/s; Flash shows about 5 s and about 36 tok/s.
A cliff on November 13. After the campaign, Max's output costs 13.3x Flash's on AIHubMix ($5.07 against $0.38 per million tokens).

	Qwen3.8 Max (free)	Qwen3.8 Flash (free)
Free price (in / out)	$0 / $0	$0 / $0
Paid price on AIHubMix (in / out)	$1.69 / $5.07	$0.1126 / $0.38
Parameters	2.4T total, ~95B active	125B total, 6B active
Context / max output	1M / 131K	1M / 131K
Latency, free route	about 55 s	about 5 s
Throughput, free route	about 9 tok/s	about 36 tok/s

Prices are per million tokens. Latency and throughput come from the Qwen3.8 Max (free) and Qwen3.8 Flash (free) pages on October 16, 2026, and move with load. Flash's parameter count is for the open-weight Flash-Next release. Side-by-side pages: free pair, paid pair.

What the benchmarks say (self-reported)

These are Qwen's launch figures as compiled by DataCamp (Max, Flash-Next). Nobody has reproduced them independently.

Benchmark	Qwen3.8 Max	Qwen3.8 Flash	Ahead
CoWorkBench	74.8	73.9	Max by 0.9
GPQA Diamond	92.6	91.7	Max by 0.9
JobBench	53.4	55.7	Flash by 2.3
SWE-bench Pro	67.7	62.5	Max by 5.2
HLE	43.6	35.9	Max by 7.7

Max's numbers come from its August launch table; the 0902 update raised CoWorkBench to 76.1 and JobBench to 64.0, by Qwen's numbers. Flash's come from the Flash-Next table, and the hosted Flash may score slightly differently.

Practical reading: treat sub-2-point gaps as ties. The real gaps are repository fixes (SWE-bench Pro, 5 points) and very hard expert questions (HLE, almost 8 points).

Sizing one task: a PR review

Assumptions: a 1,500-line pull request plus touched files is about 30K input tokens; the model writes about 6K output tokens (thinking plus comments). The same 6K is assumed for both. Artificial Analysis measured Max using more than twice the median output tokens on its test suite, so Max's numbers here are on the low side.

	Qwen3.8 Max	Qwen3.8 Flash
Tokens from the free daily pool	36K	36K
Reviews that fit in 1M tokens	about 27	about 27
Time at free-route speeds	about 12 min	about 3 min
Cost after the campaign	$0.081	$0.0057

Time = latency (55 s / 5 s) + 6K tokens at 9 / 36 tok/s. Cost = 30K input + 6K output at AIHubMix paid prices: $0.0507 + $0.0304 for Max, $0.0034 + $0.0023 for Flash.

Same pool cost today, about 4x the wall-clock for Max, and after the campaign the Flash review costs under a fourteenth of the Max one. A CI gate someone is waiting on belongs on Flash; an overnight review of payment-code PRs is where Max's 5-point SWE-bench Pro lead earns the wait.

The routing pattern

Same base URL, same SDK, so routing is a model-ID swap. Flash first, Max only on failure:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key=os.environ["AIHUBMIX_API_KEY"],
    timeout=900,
)

def ask(model: str, prompt: str) -> str:
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

answer = ask("qwen3.8-flash-free", prompt)
if not passes_checks(answer):  # your tests, a schema check, or a reviewer
    answer = ask("qwen3.8-max-free", prompt)

passes_checks is whatever you already trust: a test run, a JSON schema validation, a linter, a human approval step. The timeout=900 covers Max's long answers on the free route.

Where each task type should start:

Task	Start with	Why
Chat, Q&A, drafting	Flash	Seconds to answer, office scores near Max
Extraction, tagging, summaries	Flash	High volume; Max adds wait, not accuracy
In-editor help, small fixes	Flash	Interactive work needs fast replies
Multi-file bugs, deep code review	Max	Widest coding gap on Qwen's numbers
Hard math and expert questions	Max	Nearly 8 points ahead on HLE
Overnight and batch jobs	Max	The wait costs nothing there

Failure modes to plan for

Max as an interactive default. At about 55 s before the first token, Max makes chat UIs and editor assistants feel broken. Keep it off the interactive path.
Escalating everything. If your check is too strict, every request goes to Max and you pay twice from the shared pool (Flash's tokens plus Max's). Log the escalation rate; if most requests escalate, call Max directly for that task type.
Planning for after November 13 with free-route numbers. Max's output is 13.3x Flash's price on the paid IDs. A routing pattern that's free today has a real bill later, and Flash-first keeps it low.

What this post can't verify

The benchmark gaps are Qwen's own, and the Flash column is from the open-weight Flash-Next release, not the hosted model.
AIHubMix doesn't state which Max snapshot (launch or 0902) the free ID serves.
Latency and throughput are point-in-time readings from the model pages and change with load.
The PR-review numbers are estimates from stated assumptions, not a measured run.

Keep reading: the Qwen3.8 Free series

If you haven't set up the free IDs yet, start with the limits, the end date and a first request: Free Qwen3.8 Max and Flash API on AIHubMix: Limits, End Date, and Your First Call
Max's long waits and the shared pool cause most of the errors people hit, and there's a fallback that covers them: Qwen3.8 Free on AIHubMix: Fix 429s, "Rate Limited by Provider", and a Drained Token Pool

Sources

Qwen3.8 Max (free) vs Qwen3.8 Flash (free) (AIHubMix)
Free AI models and quotas (AIHubMix)
Qwen3.8-Max: Features, Benchmarks, and Pricing (DataCamp)
Qwen3.8-Flash-Next: Features, Benchmarks, and Pricing (DataCamp)
Qwen3.8 Max (0902): Intelligence, Performance & Price Analysis (Artificial Analysis)

Qwen3.8 Free on AIHubMix: Fix 429s, "Rate Limited by Provider", and a Drained Token Pool

AIHubMix — Fri, 16 Oct 2026 06:34:30 +0000

TL;DR: If you're calling qwen3.8-max-free or qwen3.8-flash-free on AIHubMix, almost every failure comes from one of three sources: the free-tier caps (10 requests a minute, 100 a day, 1M tokens a day, all shared across the free catalog), the upstream campaign capacity GMI Cloud has reserved, or thinking tokens and agent context draining the daily pool. The single most useful fix is key-level fallback to the paid qwen3.8-max and qwen3.8-flash. It also covers the end of the free window, around November 13, 2026 (Pacific Time). The everyday API errors still apply on top of that: a wrong key or model ID, a context that's too long, a broken tool-call history, JSON mode, content moderation, and images that are too small. Failure 5 covers them.

Prerequisites

An AIHubMix account with a top-up of $1 or more. Before that you only get 10 trial calls, shared across every free model.
AIHUBMIX_API_KEY exported in your shell.
The OpenAI Python SDK, or curl. Base URL: https://aihubmix.com/v1.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key=os.environ["AIHUBMIX_API_KEY"],
    timeout=900,
)

The long timeout is there for long streamed answers from Max. It won't rescue a non-streaming one: a non-streaming request that runs past about 125 seconds gets a 524 whatever your timeout is. See failure 4.

Failure 1: 429 "Sorry, you have reached the limit of the free model quota"

The free models page says: "Past a cap the API returns 429 until the next minute or day starts." The caps are per account, so a batch job on any other free model spends the same minute and the same day. In AIHubMix's gateway logs, a request past a cap comes back with this message and a top-up link:

Sorry, you have reached the limit of the free model quota. Please switch to a paid model to enjoy unlimited concurrency.

It doesn't say which cap you hit. AIHubMix's HTTP status code reference gives a different frequency-limit message, "The xx model Too many requests; please try again later.", so match on the 429 status, not the text.

Reproduce it with 11 quick requests. This costs 11 of your 100 daily requests:

for i in $(seq 1 11); do
  curl -s -o /dev/null -w "%{http_code}\n" https://aihubmix.com/v1/chat/completions \
    -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model":"qwen3.8-flash-free","messages":[{"role":"user","content":"hi"}],"max_tokens":16}'
done

Inside one minute, the first ten print 200 and the eleventh prints 429.

Fix: rate-limit batch jobs to under 10 requests a minute. For the daily cap, wait for the reset or let fallback absorb the overflow.

Failure 2: "Rate limited by provider"

On October 16, AIHubMix's own test call to qwen3.8-max-free came back as HTTP 429 with this body, while the same key kept working on qwen3.8-flash-free:

{"error":{"message":"Model qwen3.8-max-free rate limited by provider – contact support to request higher concurrency or try again later. (tid: …)","type":"service_unavailable","param":"","code":"rate_limit_exceeded"}}

The status code reference lists the same message under 503, so match on both codes, or on code: rate_limit_exceeded plus the message.

The free IDs run on capacity GMI Cloud has set aside for the campaign. When many callers hit Max at once, that pool fills up for a while. Your quota isn't the problem.

Fix: exponential backoff, then fallback for anything that can't wait. Log the tid; support can use it to find the request.

import time
from openai import RateLimitError, InternalServerError

def call_with_backoff(**kwargs):
    for delay in (30, 60, 120):
        try:
            return client.chat.completions.create(**kwargs)
        except (RateLimitError, InternalServerError) as e:
            if e.status_code == 524:  # long non-streaming request cut off upstream; a retry fails the same way
                raise
            print(f"retrying in {delay}s: {e}")
            time.sleep(delay)
    return client.chat.completions.create(**kwargs)

Failure 3: no error, but the reply says your trial is used up

This one doesn't throw. After the 10th trial call on an account that hasn't topped up, the API keeps answering, but the answer is a note that the trial is used up. If your app renders model output, your users will see that note. Top up $1 or more and the account switches permanently to daily quotas.

Failure 4: 524 "bad response status code 524" on non-streaming requests

A non-streaming request hangs for about two minutes, then fails with HTTP 524. AIHubMix's gateway records it as:

{"message":"bad response status code 524","type":"upstream_error","param":"524","code":"bad_response_status_code"}

In AIHubMix's gateway logs for October 18–19, this was the most frequent error on qwen3.8-max-free, and it shows up on qwen3.8-flash-free too, less often.

The free route's upstream sits behind Cloudflare, which closes a request after about 125 seconds without a response and returns 524 ("A timeout occurred"). Every 524 AIHubMix traced was a non-streaming request that got nothing back in those 125 seconds. Non-streaming means no response until the whole answer is ready, and Max is slow to finish: about 55 seconds of latency and about 9 tokens a second on the free route, per AIHubMix. That leaves roughly 70 seconds, or about 600 tokens including thinking, before the cutoff (an estimate from those two figures). A bigger client timeout doesn't help, since the cutoff is upstream, and resending the same request hits it again.

Fix: stream Max requests and long Flash requests, and keep Max off interactive paths.

stream = client.chat.completions.create(
    model="qwen3.8-max-free",
    messages=[{"role": "user", "content": "Review this diff for bugs: ..."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Failure 5: everyday API errors

Not every error on the free IDs is about quotas. These hit the free and paid IDs alike. Per AIHubMix's status code reference, most 400s are passed through from the upstream model. The free IDs run on GMI Cloud and the paid ones on Alibaba Cloud, so 400 wording can differ between routes. Messages below are quoted from AIHubMix's reference, Alibaba Cloud's error code reference, and AIHubMix's gateway logs.

Status	Error	Usual cause
401	Unauthorized	Wrong or missing key
503	Incorrect model ID	Typo, or another platform's ID
403	Key not authorized for the model	Model not enabled on the key
400	Range of input length	Context over the limit
400	Role "tool" without "tool_calls"	Broken tool-call history
400	JSON mode errors	Prompt wording or thinking
400	Inappropriate content	Content moderation
400	Image length and width	Image 10px or less on a side

401: "Unauthorized – access token is invalid or expired."

Wrong, revoked or expired key. With no Authorization header at all, you get "Unauthorized – no access token supplied; please log in and include a valid token." Usual causes: the env var isn't set in the shell running the code, so an empty key goes out, or a QwenCloud or GMI Cloud key gets sent to AIHubMix.

echo ${AIHUBMIX_API_KEY:0:3}   # should print sk-

AIHubMix keys only work on https://aihubmix.com/v1; other platforms' keys don't work there.

503: "Incorrect model ID. Please request to view the model page or you do not have permission to use this model"

IDs must match exactly: qwen3.8-max-free and qwen3.8-flash-free, all lowercase, hyphen before free. GMI Cloud's Qwen/Qwen3.8-Max doesn't exist on AIHubMix. The quiet variant: QwenCloud's qwen3.8-max is a valid AIHubMix ID, but it's the paid model, so the request bills you without any error.

curl -s https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen-3.8-max-free","messages":[{"role":"user","content":"hi"}]}'

Copy the ID from the model page. And because this is a 503, retry logic that treats every 5xx as transient will retry a typo forever. Treat this message as permanent.

403: "Forbidden – key(last 6 digits of request key) not authorized to access the requested model."

Keys can be restricted to a model list. A key made for another project won't reach the Qwen3.8 free IDs until you add qwen3.8-max-free and qwen3.8-flash-free in API key management. If you use fallback, add the paid backups too: fallback skips models outside the key's list.

400: "Range of input length should be [1, xxx]"

Alibaba's message for input over the context limit; xxx is the limit. Agent sessions are the usual cause. Alibaba also notes that long prompts with thinking on "may cause response truncation or request timeout." Trim history, start a new session, or turn on compaction, but trim carefully, or you hit the next error.

400: messages with role "tool" must be a response to a preceeding message with "tool_calls"

Alibaba's reference lists this message, typo included, plus its mirror: "An assistant message with "tool_calls" must be followed by tool messages responding to each "tool_call_id"". Qwen Code users hit the first one in issue #2360. The cause is a tool result whose call was trimmed, or a call whose result is missing, usually from hand-rolled trimming or compaction. Keep each call and its results together:

messages = [
    {"role": "user", "content": "What's the weather in Hangzhou?"},
    {"role": "assistant", "content": None, "tool_calls": [{
        "id": "call_1", "type": "function",
        "function": {"name": "get_weather", "arguments": "{\"city\": \"Hangzhou\"}"},
    }]},
    {"role": "tool", "tool_call_id": "call_1", "content": "{\"temp_c\": 21}"},
]
# When trimming, drop messages[1] and messages[2] together, never just one of them.

400: JSON mode

Two messages from Alibaba's reference:

"'messages' must contain the word 'json' in some form, to use 'response_format' of type 'json_object'."
"Json mode response is not supported when enable_thinking is true"

The first is OpenAI's JSON-mode rule too. The second matters for Qwen3.8 because thinking is on by default, so a json_object request that works elsewhere can fail here. Alibaba doesn't list which models return it, so test on your ID. Fix both at once:

curl -s https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash-free",
    "messages": [{"role": "user", "content": "Reply in JSON with the city and date: meet in Hangzhou on Nov 3."}],
    "response_format": {"type": "json_object"},
    "enable_thinking": false
  }'

400: "Input text data may contain inappropriate content."

Content moderation, on the free IDs as well as the paid ones. In AIHubMix's gateway logs for October 18–19, it was the error the most people hit on the free IDs, with exactly this text. On the paid route, Alibaba prefixes its code: "InternalError.Algo.DataInspectionFailed: Input text data may contain inappropriate content." Alibaba's reference lists the code as data_inspection_failed, with output variants "Output data may contain inappropriate content." and "Input or output data may contain inappropriate content." User-generated text in the prompt (scraped pages, support tickets) is the usual trigger. Fallback won't route around it: the paid IDs screen the same way. Bisect the input to find the passage, then filter or rephrase it; resending gets the same answer.

400: "The image length and width do not meet the model restrictions."

Every image in the request must be more than 10 pixels on each side. The message ends with the rejected size, for example "[height:8 or width:8 must be larger than 10]". AIHubMix's gateway logs show it on both free IDs. Images that small usually slip in by accident: icons or tracking pixels picked up with a scraped page. Check sizes before sending, and drop or upscale anything 10 pixels or less on either side.

Failure 6: the token pool drains quietly

There are no errors until the 1M-token pool is empty; then every free call returns 429 at once. Three things drain it.

Thinking tokens. Both models think by default, and Alibaba bills thinking as output tokens; on the free route they count toward your pool. In AIHubMix's test, a two-sentence answer from qwen3.8-flash-free used 89 output tokens, 36 of them on thinking. Artificial Analysis measured Max at 190M output tokens on its index, against an 87M median. Turn thinking off with enable_thinking, Alibaba's documented switch, passed through extra_body:

resp = client.chat.completions.create(
    model="qwen3.8-flash-free",
    messages=[{"role": "user", "content": "Return only the invoice number: INV-2026-0042, due Nov 3"}],
    extra_body={"enable_thinking": False},
)
print(resp.choices[0].message.content)
print(resp.usage.completion_tokens_details)

Verify that reasoning_tokens is 0. If it isn't, the switch didn't reach the model on that route.

Agent context. Agents resend the whole conversation every turn. A session at 40K tokens, run for 20 more turns, sends 800K input tokens. Cap the context, start new sessions, and use compaction where the tool has it.

One big request. The 1M context window is the same size as the daily pool. One full-window request spends the day.

The fix that covers most of it: key-level fallback

AIHubMix can switch models at the gateway, per API key, with no client change (model mapping and fallback):

In the console's API key management, edit the key your app uses.
Under "Fallback models on error", add qwen3.8-max, then qwen3.8-flash.
Keep requesting qwen3.8-max-free.

Don't list free IDs as backups: a free model can only be the primary model, and the backup list skips it silently.

Situation	Falls back?
Free model hits a quota or rate limit	Yes, to a paid backup
Every upstream channel fails before the reply starts	Yes
The stream has already started	No
Your client timed out	No
Your own key is invalid or out of balance	No

Fallback requests are billed at the answering model's price, so keep a balance. If fallback requests start failing with 403 "Your account balance is insufficient. Please recharge your account to continue using the API.", top up: fallback doesn't route around your own balance. Below -$1, the free models stop working too until you top up.

Check which model answered:

curl -s -i https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3.8-max-free","messages":[{"role":"user","content":"hi"}]}' \
  | grep -i -E 'x-aihubmix-(model|fallback)'

X-Aihubmix-Fallback: true means it fell back; X-Aihubmix-Model is the model that answered and was billed. After the window closes around November 13 (or earlier if GMI Cloud's credits run out), the same setup keeps your app running. Without it, drop -free from the model ID.

Coding tools

OpenCode, Cline, Kilo Code, Qwen Code and Hermes Agent all work with the free IDs as an OpenAI-compatible provider; the OpenCode guide shows the pattern.

Setting	Value
Provider type	OpenAI-compatible
Base URL	https://aihubmix.com/v1
Model ID	qwen3.8-flash-free or qwen3.8-max-free
Context window	Up to 1M; set lower to save the pool
Max output	Up to 131K

Agent loops drain the pool, and Max is slow as an interactive main model. Where a tool splits planning and editing models (Cline's Plan and Act modes, for example), put Max on planning and Flash on edits.

Smoke test, about 15 minutes: point the tool at qwen3.8-flash-free, ask it to add one unit test for a small function in a real repo, and run it. Pass means it reads the file, writes the test, runs it via a tool call, and the AIHubMix usage log shows the requests under the free model at $0. Then rerun the planning step on qwen3.8-max-free and compare time and tokens.

What this post can't verify

The behaviour of the -free IDs after the campaign ends: AIHubMix hasn't published the exact response.
Whether enable_thinking passes through on every route. Check reasoning_tokens yourself, as shown above.
The exact 400 wording on the free route, beyond the moderation and image-size messages taken from AIHubMix's gateway logs. The other quotes come from AIHubMix's and Alibaba Cloud's references, and GMI Cloud may word them differently; Alibaba doesn't say which models return the JSON-mode thinking error.
That streaming avoids the 524. It follows from how Cloudflare's timeout works (it waits for the first response, and a stream starts responding early), but every 524 AIHubMix traced was non-streaming, and no streamed request was timed against the cutoff.
The provider rate limit is load-dependent. A single test on October 16 doesn't tell you how often it happens.

Keep reading: the Qwen3.8 Free series

For the quota rules, the end date and a working first request: Free Qwen3.8 Max and Flash API on AIHubMix: Limits, End Date, and Your First Call
To stop hitting Max's waits on work Flash can handle: Qwen3.8 Max Free vs Qwen3.8 Flash Free: Is Flash Enough?

Sources

HTTP status codes (AIHubMix docs)
Model mapping and fallback (AIHubMix docs)
Free AI models and quotas (AIHubMix)
Error codes (Alibaba Cloud Model Studio)
Use deep thinking models via API (Alibaba Cloud Model Studio)

Free Qwen3.8 Max and Flash API on AIHubMix: Limits, End Date, and Your First Call

AIHubMix — Fri, 16 Oct 2026 06:34:06 +0000

TL;DR: qwen3.8-max-free and qwen3.8-flash-free are $0 per million tokens on AIHubMix's OpenAI-compatible endpoint until around November 13, 2026 (Pacific Time), or until GMI Cloud's campaign credits run out. You get 10 trial calls, or after a $1+ top-up, 100 requests a day, 10 a minute and 1M tokens a day, shared across all free models. Stream Max, budget for thinking tokens, and plan the one-line switch to the paid IDs.

GMI Cloud is funding a 30-day campaign that went live on October 14, 2026 (Pacific Time). It puts Alibaba's flagship Qwen3.8 Max and its fast sibling Qwen3.8 Flash on AIHubMix at no cost. This post covers what you need to call them today and keep your code working after the window closes.

Prerequisites

An AIHubMix account and API key (quick start)
The key exported as AIHUBMIX_API_KEY
Optional: a top-up of $1 or more, to switch from 10 trial calls to daily quotas
curl, or Python with the openai package

The model IDs and what they replace

Model	Free ID	Paid ID	AIHubMix paid (in / out)	Qwen list (in / out)
Qwen3.8 Max	qwen3.8-max-free	qwen3.8-max	$1.69 / $5.07	$2.00 / $6.00
Qwen3.8 Flash	qwen3.8-flash-free	qwen3.8-flash	$0.1126 / $0.38	$0.16 / $0.47

Prices are per million tokens; Qwen list prices are QwenCloud's.

The free IDs carry the standard capabilities of the paid ones: 1M-token context, up to 131K output tokens, tool calling, and thinking on by default. They're served by GMI Cloud instead of Alibaba Cloud, so latency differs. The Qwen3.8 Max (free) and Qwen3.8 Flash (free) pages show live latency and uptime for the free route.

First request

curl https://aihubmix.com/v1/chat/completions \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash-free",
    "messages": [{"role": "user", "content": "In two sentences, what is a mixture-of-experts model?"}]
  }'

The response is a normal Chat Completions object. Because thinking is on, the message also carries a reasoning_content field, and usage.completion_tokens_details.reasoning_tokens counts what the model spent thinking.

Calling Max: stream it

Max thinks before its first visible token. AIHubMix's own measurement of the free route puts latency at about 55 seconds, against about 5 seconds for Flash. Stream the response and raise the client timeout:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key=os.environ["AIHUBMIX_API_KEY"],
    timeout=600,
)

stream = client.chat.completions.create(
    model="qwen3.8-max-free",
    messages=[{"role": "user", "content": "Find the bug in this function:\n\ndef mean(xs):\n    return sum(xs) / len(xs) - 1"}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Thinking arrives in delta.reasoning_content, so this loop prints only the answer.

Quotas, and how they bite

From the AIHubMix free models page:

Before any top-up: 10 trial calls in total, shared across every free model, no expiry.
After a top-up of $1 or more: 100 requests/day, 10 requests/minute, 1M tokens/day, shared across the whole free catalog, reset daily. The switch is permanent.
Past a cap: HTTP 429 until the next minute or day starts.

Failure modes worth handling in code:

The trial runs out silently. After the tenth trial call, the API keeps replying with a note that the trial is used up, not an error. If you pipe output straight to users, they'll see that note.
Thinking eats the pool. Alibaba bills thinking as output tokens, and every token counts toward the 1M/day pool. In a test on October 16, a two-sentence answer from qwen3.8-flash-free used 89 output tokens, 36 of them on thinking. For simple requests, pass extra_body={"enable_thinking": False}, which is Alibaba's documented switch for Qwen3.8.
One request can drain the day. The context window (1M) is as large as the daily token pool.
The pool is shared. Calls to any other free model come out of the same 1M tokens and 100 requests.

Which model gets your tokens

Benchmark figures here are Qwen's own launch numbers as compiled by DataCamp; nobody has reproduced them independently.

Qwen3.8 Max (Aug 3, 2026): 2.4T-parameter MoE, about 95B active. SWE-bench Pro 67.7, CoWorkBench 74.8, GPQA Diamond 92.6. A 0902 post-training update shipped on September 2. Artificial Analysis ranks it 33rd of 217 and flags it as "very verbose" (190M output tokens on its index vs an 87M median).
Qwen3.8 Flash (Aug 26, 2026): the hosted version of open-weight Flash-Next (125B total, 6B active). SWE-bench Pro 62.5, CoWorkBench 73.9.

Priced at AIHubMix's paid rates, a full day's 1M tokens (750K in, 250K out) is worth:

Model	750K input	250K output	Per day	Full 30 days
Qwen3.8 Max	$1.27	$1.27	$2.54	about $76
Qwen3.8 Flash	$0.08	$0.10	$0.18	about $5.40

A Max token is worth about 14 Flash tokens. Spend the shared pool on Max where quality matters, and use Flash where latency matters.

After the window closes

The -free IDs stop being free around November 13, 2026 (Pacific Time), or earlier if the campaign credits run out. Either:

change qwen3.8-max-free to qwen3.8-max (or qwen3.8-flash-free to qwen3.8-flash); nothing else changes, or
configure key-level fallback in AIHubMix now, so a free model that hits a quota or rate limit falls back to a paid one with no code change. The third post in this series has the setup.

What this post doesn't verify

Latency figures are AIHubMix's own measurements of the free route; they move with load.
Benchmarks are vendor-reported.
Whether enable_thinking takes effect on the free route is something to check per request: look for reasoning_tokens dropping to 0.

Keep reading: the Qwen3.8 Free series

The pool is shared, so it pays to know which model deserves your tokens: Qwen3.8 Max Free vs Qwen3.8 Flash Free: Is Flash Enough?
Once you're calling it every day, here's what goes wrong and the one setting that covers most of it: Qwen3.8 Free on AIHubMix: Fix 429s, "Rate Limited by Provider", and a Drained Token Pool

Sources

Qwen3.8 Max (free) model page (AIHubMix)
Free AI models and quotas (AIHubMix)
Use deep thinking models via API (Alibaba Cloud Model Studio)
Qwen3.8-Max: Features, Benchmarks, and Pricing (DataCamp)
Qwen3.8 Max (0902): Intelligence, Performance & Price Analysis (Artificial Analysis)