DEV Community: Owen

Gemini 3.7 Flash API: $0.75 Pricing, minimal Returns 400

Owen — Sat, 22 Aug 2026 11:35:41 +0000

Gemini 3.7 Flash shipped on 2026-08-13 at $0.75 per million input tokens and $3.75 per million output. Two things about that price are easy to miss: it expires on 2026-12-31 and doubles the next day, and Gemini 3.6 Flash now carries the exact same numbers.

The thing that breaks builds is elsewhere. The thinking tiers went from four to three. minimal is gone, and it does not degrade quietly.

Price:        $0.75 in / $3.75 out per 1M through 2026-12-31
              $1.50 / $7.50 from 2027-01-01
              Batch and Flex: $0.375 / $1.875, same doubling
Cache:        $0.075 read, $0.50 per 1M per hour storage
Context:      1,048,576 in / 65,536 out
Thinking:     thinking_level low | medium | high, default medium
              minimal returns HTTP 400
Gateways:     google/gemini-3.7-flash on ofox
Measured:     minimal 400, none and xhigh accepted and billed
Snapshot:     2026-08-21, 10 streamed calls per tier

Last updated 2026-08-21. Introductory pricing expires 2026-12-31, so re-check before budgeting past that date.

How Much Does the Gemini 3.7 Flash API Cost?

$0.75 in, $3.75 out, until it isn't. Google's pricing page puts two rates in a single cell, which is how the wrong one ends up in a budget spreadsheet.

Tier	Input / 1M	Output / 1M	In effect
Standard	$0.75	$3.75	through 2026-12-31
Standard	$1.50	$7.50	from 2027-01-01
Batch / Flex	$0.375	$1.875	through 2026-12-31
Batch / Flex	$0.75	$3.75	from 2027-01-01

Context caching reads at $0.075 per million with storage at $0.50 per million tokens per hour, both doubling on the same date. Search grounding gives 5,000 free requests a month shared across every Gemini 3.x model, not per model, and then costs $14 per 1,000.

One line on that page decides more of your bill than the headline rate: the output row reads "Output price (including thinking tokens)". Reasoning is metered at the output rate, so the effort setting is a price multiplier, not a quality knob with a rounding error attached.

Is Gemini 3.7 Flash Cheaper Than Gemini 3.6 Flash?

No. They cost exactly the same, cell for cell. If you saw 3.7 Flash introduced as half the price of 3.6 Flash, that comparison had a shelf life of about one day, and the pricing page's own history shows why.

2026-07-22, just after 3.6 Flash shipped on 2026-07-21, per the archived pricing page: 3.6 Flash costs $1.50 / $7.50.
2026-08-12, per the last copy before 3.7 launched: 3.6 Flash still costs $1.50 / $7.50, flat, with no discount row. 3.7 Flash is not on the page yet.
2026-08-13: 3.7 Flash ships.
2026-08-14, per the next archived copy: 3.6 Flash and 3.7 Flash both read $0.75 / $3.75 through 2026-12-31, $1.50 / $7.50 after.
2027-01-01: both return to $1.50 / $7.50, which is what 3.6 Flash cost on its own launch day.

So the baseline moved inside the same 48 hours as the comparison. Google's model card footnotes the end state without comment: the asterisk on both price rows says the introductory price expires December 31, 2026. Upgrading from 3.6 costs nothing and saves nothing. What the discount buys is four and a half months, on both models equally.

The ofox model page carries rates Google's page does not itemise: cache write at $0.0415 per million, one-hour cache write at $0.50, audio input at $0.75, web search at $0.014 per request.

How Do I Call Gemini 3.7 Flash?

Two routes, and the only differences are the base URL and the model string.

from openai import OpenAI

client = OpenAI(api_key="sk-...", base_url="https://api.ofox.ai/v1")

r = client.chat.completions.create(
    model="google/gemini-3.7-flash",
    reasoning_effort="low",
    messages=[{"role": "user", "content": "Rewrite this query with a window function"}],
)
print(r.choices[0].message.content)

Straight to Google, the model string loses its google/ prefix and the base URL changes:

client = OpenAI(
    api_key="AIza...",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
)
r = client.chat.completions.create(model="gemini-3.7-flash", reasoning_effort="low", messages=[...])

On Google's native protocol the parameter is not reasoning_effort. It is thinking_level, it takes low, medium and high, and it defaults to medium. Both protocols are open on ofox, with Google and Cloud Vertex as the upstreams.

Capabilities are worth copying off the model page rather than discovering by 400: function calling, structured outputs, context caching, code execution, search grounding, URL context, file search and Maps grounding are all supported, computer use is marked Preview, and Batch, Flex and Priority are all available. Live API, image generation and audio generation are not supported. Input takes text, image, video, audio and PDF; output is text only.

Why Does minimal Return an Error on Gemini 3.7 Flash?

Because the tier was removed, and the request fails instead of falling back. The model page spells it out under Thinking: Supported (low, medium, high) followed by Note: minimal is not supported and returns an error.

We sent it anyway. Over the ofox route, reasoning_effort: "minimal" returns HTTP 400 with:

{"error": {"code": null,
           "message": "Thinking level is unsupported: THINKING_LEVEL_MINIMAL",
           "param": null, "type": "invalid_request_error"}}

3.6 Flash still accepts minimal, and we measured what that tier was doing for you before you lose it. On 3.6 Flash, the same prompt at minimal returned a median of 42 completion tokens with zero reasoning tokens and a 1.36-second first token. The cheapest tier 3.7 will accept, low, returned a median of 354 tokens at 4.19 seconds. That is 8.4x the billed output and 3x the wait, for a model whose visible answer is the same 40 tokens either way.

So the migration is not "change the model ID and keep going". A config that hardcodes minimal stops working at the moment you swap the ID, and the nearest legal value silently costs eight times as much. There is no zero-thinking setting on 3.7 Flash to fall back to.

The more interesting half of that probe is what does not fail. none and xhigh are not documented values for this model, and both returned HTTP 200 with reasoning tokens on the bill: reasoning-token medians of 271 and 604 across ten runs each, which is the 308 and 637 completion tokens in the table below. Only minimal is rejected. A 200 is not confirmation that the value you sent selected the tier its name implies, which is the same trap GLM 5.3 sets with undocumented reasoning_effort values, where validation lives on the route rather than in the model. Probe your own route before shipping, because "it returned 200" and "it did what I asked" are different claims.

Google's OpenAI compatibility page makes this worth two minutes of your time: its reasoning_effort mapping table lists Gemini 3.1 Pro, 3.1 Flash-Lite, Gemini 3 Flash and 2.5, with no 3.7 column, and it maps OpenAI's minimal downward. The model page says 3.7 rejects minimal. Two Google pages, no agreement, and one short probe settles it for the route you actually call.

What Does Each Thinking Level Actually Cost?

The same answer, at up to double the bill. Mak, product lead at ofox, ran 10 streamed calls per tier through the same ofox route on 2026-08-21, one short prompt (rewrite a GROUP BY as a window function), recording time to the first content token and the usage the API reported.

`reasoning_effort`	TTFT median	TTFT range	Completion tokens	Range	Visible answer
`low`	4.19 s	2.22–5.40	354	40–418	~41
`medium`	5.47 s	4.47–6.98	384	291–558	~41
`high`	7.69 s	5.97–9.68	688	560–806	~40
unset	5.58 s	4.32–5.98	431	333–583	~36
`none` (undocumented)	4.64 s	1.88–5.05	308	40–361	~40
`xhigh` (undocumented)	7.35 s	5.89–9.10	637	513–892	~39

Medians of 10 runs; the ranges are observed minimum to maximum, which widen as you add runs, so read them as spread rather than as bounds. All of it is one prompt on one route, and parameter handling can differ between routes to the same model, so treat the shape as portable and the numbers as ours.

The answer never changes size. The invisible part does. Text tokens sat near 40 at every tier, because the SQL statement the model was asked for is 40 tokens long no matter how long it thinks about it. Everything above that line is reasoning, billed at the output rate. On output alone at $3.75 per million, 1,000 of these calls cost $1.33 at low and $2.58 at high; the 34-token prompt adds under three cents per thousand either way, so the effort setting is doing essentially all of the work in that spread.

low bottomed out at 40 completion tokens on one of its ten runs, with the reasoning count at exactly zero; none did the same twice. Neither medium nor high ever did, and that floor is most of why their ranges sit apart.

low and high separate cleanly. low and medium do not. The high range (560–806) does not overlap the low range (40–418), so that gap is real on this prompt. low and medium are 30 tokens apart at the median with ranges that overlap across most of their span, which means ten runs cannot tell them apart here. Whether medium is a useful midpoint is a question about your prompt, and it takes about four minutes to answer with your own.

Undocumented values do not fail, and they do not do what they say. none returned HTTP 200 and spent a median of 271 reasoning tokens, which is most of what low spends. If you read that name as an off switch, you are paying for thinking you believe you disabled. xhigh lands next to high. Only minimal is rejected.

None of this contradicts the model being fast. Artificial Analysis ranks 3.7 Flash 1st of 182 on output speed at 389.5 tokens per second. On the same page they measure 14.52 seconds to first token at high on Google's own API, against a 2.80-second median for its price peers, and roughly double the median we saw at high on this route. The wait sits in front of the stream rather than inside it, which is why the effort setting, not the tokens per second, is what a user feels.

What Is Gemini 3.7 Flash Good At?

Google's model card publishes a comparison table against 3.6 Flash, Claude Sonnet 5, GPT-5.6 Terra and Muse Spark 1.2. The rows where the gaps are real:

Benchmark	3.7 Flash	3.6 Flash	Sonnet 5	GPT-5.6 Terra
AA Intelligence Index	56	52	55	57
GDM-MRCR v2 (128k)	97.0%	91.8%	81.5%	93.5%
LVBench (long video)	85.4%	84.2%	68.5%	78.9%
Code Arena (web dev Elo)	1588	1538	1541	1523
AutomationBench	30.4%	17.0%	10.7%	23.6%
FrontierCode 1.1	43.6%	34.4%	42.7%	41.3%
HLE-Verified	53.6%	51.2%	31.0%	51.1%
DeepSWE v1.1	65.3%	48.6%	53.8%	69.6%
Terminal-bench 2.1	85.8%	78.0%	80.4%	87.4%
Terminal-bench 3.0	14.9%	5.4%	14.6%	20.8%
GDPVal-AA v2 (Elo)	1525	1422	1598	1578
Agent's Last Exam	26.3%	24.2%	33.3%	28.0%
CharXiv, no tools	84.5%	85.2%	77.0%	85.9%

The strengths cluster: long-context retrieval, video, front-end code and browser automation. 97.0% on 128k needle retrieval is the only score above 95 in the table, and AutomationBench at 30.4% against Sonnet 5's 10.7% is not a margin you get from a better prompt.

The weaknesses cluster just as tightly, on work that runs long. It sits behind GPT-5.6 Terra on both Terminal-bench versions, 85.8% against 87.4% on 2.1 and 14.9% against 20.8% on 3.0, DeepSWE v1.1 lands 4.3 points behind Terra as well, and GDPVal-AA v2's 1525 is last in the table. Pick this model for a step, not for an eight-hour unattended loop.

Two things to read carefully in that table. CharXiv is the one row where 3.7 is worse than the model it replaces, 84.5% against 85.2% without tools and 88.7% against 89.4% with them, so chart-heavy multimodal work deserves your own A/B before the swap. And the Terminal-bench rows are vendor-run. The card claims 85.8% on Terminal-bench 2.1, which sits above the 83.8% ± 1.2% held by the top entry on the public Terminal-Bench 2.1 board, 17 verified submissions when we last pulled it and none of them 3.7 Flash. A self-reported score that clears the verified leader is the one number in this table to read as a claim rather than a result.

Two more lines from the card, in Google's own words: the knowledge cutoff is March 2026 with some domains still capped at January 2025, and there "may also be occasional slowness or timeout issues."

When Should You Pick Gemini 3.7 Flash?

Workload	Call	Why
RAG and retrieval past 128k	Pick it	MRCR v2 at 97.0%, highest in the card
Video understanding and QA	Pick it	LVBench 85.4%, 17 points over Sonnet 5
Front-end and web code generation	Pick it	Code Arena 1588, top of the table
Browser and GUI automation	Pick it	AutomationBench 30.4% vs Sonnet 5's 10.7%
Long-horizon terminal agents	Careful	Terminal-bench 3.0 at 14.9%
Interactive chat and voice front-ends	Look elsewhere	No Live API, and thinking time precedes the first token
Chart-dense multimodal analysis	Test first	CharXiv is the one regression against 3.6
Single responses over 64k tokens	Chunk it	Output ceiling is 65,536

If your workload is not on that list, ofox's model finder ranks 100+ models by quality, cost and speed for a chosen task type (coding, agents, long-document RAG, vision, extraction, translation), pulling live prices and context limits. No signup, no key.

Which Models Score About the Same?

Four models sit inside three points of each other on the Artificial Analysis Intelligence Index, at prices that differ by more than 3x. Scores and rates below are the ones printed in Google's model card, which is one source rather than four, so re-check a vendor's page before you commit a budget to it.

Model	AA Index	Input / 1M	Output / 1M
GPT-5.6 Terra	57	$2.00	$12.00
Muse Spark 1.2	57	$1.25	$4.25
Gemini 3.7 Flash	56	$0.75	$3.75
Claude Sonnet 5	55	$2.00	$10.00
Gemini 3.6 Flash	52	$0.75	$3.75

Cheapest of the four on output, 3.2x below Terra, one point behind it on the composite. The catch is the composite: it hides the terminal and GDPVal rows where 3.7 Flash finishes last, so treat "comparable" as a statement about the index and nothing else.

One row down, 3.6 Flash is now the same price for four fewer points, which leaves it with no case except prompts you have already tuned against its behaviour. Our 3.6 Flash cost comparison against DeepSeek V4 Flash has the per-task math if you are still on it, and the 3.1 Flash-Lite budget agent comparison covers the tier below. Coming from two generations back, the 3.5 Flash coding agent guide still applies to 3.7 unchanged except for the model ID and the missing minimal.

15% off top-ups through 2026-08-31 at ofox puts google/gemini-3.7-flash and google/gemini-3.6-flash behind one OpenAI-compatible endpoint, which makes the A/B in the snippet above a one-string change.

References

Frequently Asked Questions

How much does the Gemini 3.7 Flash API cost?

$0.75 per million input tokens and $3.75 per million output through December 31, 2026, then $1.50 and $7.50 from January 1, 2027. Google's pricing page prints both rows in the same cell. Batch and Flex are half that at $0.375 / $1.875, doubling on the same date. Output price includes thinking tokens, so reasoning is billed at the output rate.

Is Gemini 3.7 Flash cheaper than Gemini 3.6 Flash?

No, they are identically priced. Google's pricing page carries the same four tiers and the same two dates for both models. Archived copies of that page show why the half-price framing does not survive contact with it: on 2026-08-12 3.6 Flash was $1.50 / $7.50 flat and 3.7 Flash was not listed, and by 2026-08-14 both read $0.75 / $3.75 through 2026-12-31. The baseline was cut inside the same 48 hours as the comparison.

Why does reasoning_effort minimal fail on Gemini 3.7 Flash?

Because 3.7 Flash dropped that tier. The model page states 'Note: minimal is not supported and returns an error.' In our probe the request came back HTTP 400 with 'Thinking level is unsupported: THINKING_LEVEL_MINIMAL' as an invalid_request_error. 3.6 Flash accepts minimal, so any config that hardcodes it breaks on the model ID swap rather than degrading quietly.

What are the thinking levels on Gemini 3.7 Flash?

The native parameter is thinking_level and it takes low, medium and high, defaulting to medium. Through the OpenAI-compatible layer the parameter is reasoning_effort. We measured 10 streamed calls per tier on one short prompt: low returned a median of 354 completion tokens against 688 at high, with no overlap between the two ranges, while the visible answer stayed around 40 tokens at every tier.

What is the context and output limit on Gemini 3.7 Flash?

1,048,576 input tokens and 65,536 output tokens. The million-token window does not mean million-token responses, so long-document rewrites and whole-repo generation still need chunking. Inputs accept text, image, video, audio and PDF; output is text only.

Is Gemini 3.7 Flash fast?

Both, depending on which half you measure. Artificial Analysis ranks it 1 of 182 on output speed at 389.5 tokens per second, and on the same page measures 14.52 seconds to first token at high on Google's own API against a 2.80-second median for its price peers. First-token latency is a different story from throughput, because thinking time lands in front of the first token: our medians on one short prompt were 4.19 seconds at low, 5.47 at medium and 7.69 at high. A model named Flash can still make a user wait if the effort setting is high.

Which models score about the same as Gemini 3.7 Flash?

On the Artificial Analysis Intelligence Index printed in Google's model card, 3.7 Flash scores 56 against 57 for GPT-5.6 Terra and Muse Spark 1.2 and 55 for Claude Sonnet 5. The same card lists them at $2.00 / $12.00, $1.25 / $4.25 and $2.00 / $10.00 per million tokens, so 3.7 Flash is the cheapest of the four by output price.

What is the Gemini 3.7 Flash model ID on gateways?

google/gemini-3.7-flash on ofox, over either the OpenAI /v1/chat/completions protocol or Google's native Gemini protocol. Calling Google directly the code is gemini-3.7-flash, and the OpenAI-compatible base URL is https://generativelanguage.googleapis.com/v1beta/openai/.

Originally published on ofox.ai/blog.

Discounted LLM APIs: 13 Models Below List, GPT-5.6 Sol at Half Price

Owen — Sat, 22 Aug 2026 04:34:31 +0000

Discounted LLM APIs: 13 Models Below List, GPT-5.6 Sol at Half Price

Thirteen models across five series are billing below their struck-through price on ofox right now. The best-value page lists them sorted by discount size, and it is worth two minutes because the interesting part is not the percentage.

The interesting part is what each percentage is measured from. Three of these cuts mean three different things, and only one of them is a gateway putting its own margin on the table.

Which Models Are Discounted?

Five series: GPT, Gemini, GLM, Doubao and Seedance. Text models bill per million tokens, Seedance bills per second of output.

Model	Input / 1M	Output / 1M	Cached input
`openai/gpt-5.6-luna`	$0.20	$1.20	$0.02
`openai/gpt-5.6-terra`	$2.00	$12.00	$0.20
`openai/gpt-5.6-sol`	$2.50	$15.00	$0.25
`google/gemini-3.7-flash`	$0.75	$3.75	$0.075
`google/gemini-3.6-flash`	$0.75	$3.75	$0.075
`z-ai/glm-5.2`	$0.98	$3.08	$0.182
`z-ai/glm-5.3`	$1.26	$3.96	$0.234
`volcengine/doubao-seed-2.1-pro`	$0.7072	$3.536	$0.1416
`volcengine/doubao-seed-2.1-turbo`	$0.3536	$1.7696	$0.068

The four Seedance models bill on a different meter: seedance-2.0-mini from $0.02 per second of output, seedance-2.0-fast at $0.042, seedance-2.0 at $0.063, and seedance-2.5 from $0.11 at 480p, $0.48 at 1080p text-to-video and $0.568 at 1080p video-to-video. That last model prices per resolution and mode rather than as a single number, so the discount page shows only its 1080p figure while the model page carries the full grid. Duration and resolution drive that bill, not prompt length, which is why a 30-second clip costs roughly five times a 6-second one at the same resolution.

Is a Discounted Gateway Rate Actually Cheaper Than the Vendor?

Sometimes, and the honest answer splits three ways. We checked every text rate above against the vendor's own pricing page on 2026-08-21. They fall into three groups, and knowing which group a model is in is the difference between a real saving and a number that looks like one.

Group one: below the vendor's list. GLM-5.2 bills $0.98 / $3.08 here against Z.ai's own $1.40 / $4.40, which is 30% off the rate you would pay calling Z.ai directly. GLM-5.3 is $1.26 / $3.96 against the same $1.40 / $4.40 list, so 10% off. The two Doubao models belong here too: Seed 2.1 Pro bills $0.7072 / $3.536 and Turbo $0.3536 / $1.7696, against the ¥6 / ¥30 per million ByteDance published at launch, which converts to roughly $0.88 / $4.41 at the rate we recorded in our Seed 2.1 access guide. Volcano Engine prices in CNY, so treat that conversion as approximate rather than a cent-for-cent comparison. GPT-5.6 Sol is the largest of these: $2.50 / $15 against OpenAI's standard-tier $5 / $30. That is half, on the tier you actually call synchronously.

Group two: matches the vendor exactly. GPT-5.6 Luna bills $0.20 / $1.20, which is OpenAI's standard rate for that model to the cent. GPT-5.6 Terra bills $2 / $12, likewise identical. You save nothing per token against calling OpenAI directly, and that is the point: no markup, one key, and the fallback routing comes free rather than costing you a premium.

Group three: the vendor's own promotion, passed through. Gemini 3.7 Flash and 3.6 Flash both bill $0.75 / $3.75. So does Google. That rate is Google's introductory price, printed on its pricing page with an expiry of 2026-12-31, after which both models return to $1.50 / $7.50 on 2027-01-01. Nobody is discounting Gemini for you. The gateway is passing Google's own limited-time number through unchanged, which is the correct behaviour, but it means the saving disappears on a date Google controls rather than one a gateway controls.

If you are budgeting past new year, that third group is the one to model twice. We wrote up what the Gemini 3.7 Flash rate is measured against in detail, including the archived pricing pages that show the comparison baseline moving inside the same 48 hours as the launch.

What Does GPT-5.6 Cost Here Against OpenAI?

One of the three tiers is genuinely half price; the other two match the source.

Model	Rate here	OpenAI standard tier	Difference
GPT-5.6 Sol	$2.50 / $15	$5.00 / $30.00	half
GPT-5.6 Terra	$2.00 / $12.00	$2.00 / $12.00	identical
GPT-5.6 Luna	$0.20 / $1.20	$0.20 / $1.20	identical

Worth knowing about the Sol row: $2.50 / $15 is also what OpenAI charges for Sol on its Batch and Flex tiers. Those tiers trade latency for price, with Batch returning results asynchronously within a window rather than on the call. Here you get that number on a normal synchronous request, which is the whole substance of that particular discount.

Cached input follows the same shape: $0.25 per million on Sol, $0.20 on Terra, $0.02 on Luna. On a long-running agent that replays the same system prompt on every turn, cached input is usually the line that decides the monthly bill, not the headline input rate.

Which Cuts Follow the Vendor's Promotion?

Gemini and Seedance, both of them. Google's Flash rate carries a printed expiry. The Seedance discounts track BytePlus promotional windows, which carry printed start and end dates rather than running open-ended, and the 2.5 window covers 1080p output only.

This matters for one specific decision: whether to hardcode a price into a cost model. A rate in group one is a commercial arrangement that tends to move slowly. A rate in group three moves when the vendor's marketing calendar moves. Both are real money today. Only one of them is a number you can put in a spreadsheet cell labelled "next quarter".

The best-value page states this in its own words, and it is the sentence on that page worth reading twice: "promotions follow vendor changes and may end at any time."

How Do I Use the Discounted Rate?

You do not do anything. There is no coupon field, no plan to switch and no minimum top-up. The rate on the model page is what the request is billed at.

from openai import OpenAI

client = OpenAI(api_key="sk-...", base_url="https://api.ofox.ai/v1")

r = client.chat.completions.create(
    model="z-ai/glm-5.2",              # $0.98 in / $3.08 out per 1M
    messages=[{"role": "user", "content": "Summarise this changelog"}],
)
print(r.usage)

Swapping models is a one-string change, which is the practical reason to care about a discount list at all: if GLM-5.2 at $0.98 clears your quality bar for a classification job currently running on a frontier model at $5, the migration is one line and the saving is 5x. The model finder ranks the catalogue by task type and budget if you want the comparison done for you, and our API pricing comparison covers the wider field including the models that are not on discount.

Two more worth reading if a specific series is your candidate: GLM 5.3's pricing and its reasoning_effort trap, where the default effort setting bills 35x the cheapest one, and the Doubao Seed 2.1 access guide if you want the Volcengine models without a Volcengine signup.

Which Model Should You Pick From the List?

If you need	Pick	Rate
Cheapest usable text at volume	GPT-5.6 Luna	$0.20 / $1.20
Cheapest that accepts video input	Doubao Seed 2.1 Turbo	$0.3536 / $1.7696
Frontier reasoning at half list	GPT-5.6 Sol	$2.50 / $15
Long-context retrieval and video input	Gemini 3.7 Flash	$0.75 / $3.75
Open-weight-family coding and agents	GLM-5.2	$0.98 / $3.08
Video generation, cheapest per second	Seedance 2.0 Mini	from $0.02/s

The rates above are what the console bills today. The percentages next to them on the page are context for how that number got there, and as this post argues, the context is worth more than the percentage.

References

ofox: discounted models
OpenAI: API pricing
Google: Gemini API pricing
ofox model page: GPT-5.6 Luna
ofox model page: GPT-5.6 Sol
ofox model page: GLM-5.2
ofox model page: Doubao Seed 2.1 Pro
Volcano Engine: ModelArk pricing
ofox model finder

Frequently Asked Questions

Which LLM APIs are discounted on ofox?

Thirteen models across five series: GPT (5.6 Luna, Sol, Terra), Gemini (3.7 Flash, 3.6 Flash), GLM (5.2, 5.3), Doubao (Seed 2.1 Pro, Seed 2.1 Turbo) and Seedance (2.0, 2.0 Fast, 2.0 Mini, 2.5). The live list sits on the best-value page, sorted by discount size, and it changes when the vendors change their own pricing.

Is a discounted gateway rate cheaper than calling the vendor directly?

It depends on the model, and the answer falls into three groups. GLM-5.2 at $0.98 / $3.08 is genuinely below Z.ai's own $1.40 / $4.40. GPT-5.6 Luna at $0.20 / $1.20 matches OpenAI's standard rate exactly, so you save nothing per token but you also pay no markup. Gemini 3.7 Flash at $0.75 / $3.75 is Google's own introductory price, which expires on 2026-12-31 and is not a gateway discount at all.

What does GPT-5.6 cost through a gateway?

Sol is $2.50 in and $15 out per million tokens, Terra is $2 and $12, Luna is $0.20 and $1.20. OpenAI's own standard-tier list for the same models is $5 / $30, $2 / $12 and $0.20 / $1.20. Sol is the one where the gateway rate is half the vendor's standard tier; the other two match it.

Do I need a coupon code for the discounted rate?

No. The rate on the model page is the rate you are billed. There is no coupon field, no minimum top-up and no separate discount plan to enable. The struck-through number is context, not something you have to unlock.

How long do these discounts last?

There is no single end date, because the rates track each vendor's own pricing. Google's Gemini 3.7 and 3.6 Flash rate is dated to 2026-12-31 on Google's pricing page. Seedance promotions follow BytePlus windows. GLM rates have no published end date. Treat any of them as good for today and re-check before you commit a quarterly budget.

Which discounted model is cheapest for high-volume text?

GPT-5.6 Luna at $0.20 in and $1.20 out per million tokens, with cached input at $0.02. Doubao Seed 2.1 Turbo is next at $0.3536 and $1.7696. Both are an order of magnitude below the frontier tier, and both keep tool calling and vision.

Are video models discounted too?

Four Seedance models are, and they bill per second of output rather than per token: Seedance 2.0 Mini from $0.02/s, 2.0 Fast at $0.042/s, 2.0 at $0.063/s, and 2.5 from $0.11/s at 480p, $0.48/s at 1080p text-to-video and $0.568/s at 1080p video-to-video. Per-second billing means the resolution and duration you request drive the bill, not prompt length.

Originally published on ofox.ai/blog.

DeepSeek V4 Flash Vision: Images Cap at 384 Tokens

Owen — Sat, 22 Aug 2026 00:33:52 +0000

DeepSeek shipped a vision variant of V4 Flash, and it costs exactly what the text model costs. Model ID deepseek-v4-flash-vision-exp, live on ofox as deepseek/deepseek-v4-flash-vision-exp.

Same 1M context, same 384K output ceiling, same 2500 concurrency, same price on every row of the pricing table. The interesting question is what an image actually costs once it becomes tokens, and the answer has a hard ceiling.

Model:        deepseek/deepseek-v4-flash-vision-exp
Price:        $0.44 in / $1.32 out per 1M at peak
              $0.22 / $0.66 off-peak (peak = 01:00-04:00, 06:00-10:00 UTC)
Cache hit:    $0.014 peak / $0.007 off-peak per 1M
Context:      1M in / 384K out
Images:       384 tokens max per image, 600 images per request
Thinking:     on by default at effort high, disable via thinking.type
Measured:     800x800 and 3000x3000 both cost 348 input tokens
Snapshot:     2026-08-21, n=5 per configuration

Last updated 2026-08-21. The model ID carries an -exp suffix, so treat its availability as experimental and re-check before building a dependency on it.

What Is DeepSeek V4 Flash Vision Exp?

V4 Flash with image input, priced identically. DeepSeek's pricing page puts the three models side by side, and the vision column matches the flash column cell for cell.

	`deepseek-v4-flash`	`deepseek-v4-flash-vision-exp`	`deepseek-v4-pro`
Input, cache miss (peak)	$0.44	$0.44	$1.32
Input, cache hit (peak)	$0.014	$0.014	$0.044
Output (peak)	$1.32	$1.32	$3.96
Context	1M	1M	1M
Max output	384K	384K	384K
Concurrency limit	2500	2500	500

Off-peak rates are half the peak rates across the board. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, three hours plus four, which leaves seventeen hours a day at the lower rate.

One thing moves in the wrong direction. On the feature table, FIM completion reads "Non-thinking mode only" for V4 Flash and V4 Pro, and "Not supported" for the vision variant. Everything else carries over: JSON output, tool calls, the Responses API, the Anthropic-format API and chat prefix completion are all ticked.

How Much Does an Image Cost?

348 tokens for an 800x800 image, and the same 348 for a 3000x3000 one.

Every image is resized before inference. Images below roughly 384x384 total pixels are scaled up, larger images are scaled down, both preserving aspect ratio, and the target is a total pixel count near an 800x800 image. The documented consequence is a ceiling of 384 tokens per image, which is why a 2000x2000 photo and a 5000x5000 photo bill the same.

Test images sent through the ofox route on 2026-08-21, subtracting a 91-token text-only baseline measured on the same prompt:

Image	`prompt_tokens`	Image tokens	Cost at peak input
none (text only)	91	0	—
200x200	207	116	$0.000051
800x800	439	348	$0.000153
3000x3000	439	348	$0.000153
6000x3000	395	304	$0.000134

Two things fall out of that table. The 800x800 and 3000x3000 rows are identical, which is the resize rule doing exactly what the documentation says. And the 6000x3000 row is cheaper than the square ones, because a 2:1 image that has been squeezed into the same total pixel budget tiles into fewer patches than a square one does.

At $0.44 per million input tokens, a thousand images cost about 15 cents at peak and half that off-peak. Image input on this model is not a line you need to model. What you do need to model is the next section.

Does Thinking Mode Change the Bill?

It costs 80 extra input tokens before the model has looked at anything. Thinking mode is on by default with effort set to high. Test results from running the same image and the same prompt five times per configuration:

	`prompt_tokens`	Completion median	Reasoning median	Latency median
Default (thinking on)	439	114 (68–425)	91	1.9 s
`thinking: {"type": "disabled"}`	359	19 (18–20)	0	1.0 s

The prompt_tokens figure did not vary once across ten calls: 439 with thinking on, 359 with it off, every single time. That 80-token gap is a template the API adds when thinking is enabled, and you pay input rate on it whether the model ends up reasoning or not.

On the output side the gap is wider and less predictable. With thinking on, the completion ranged from 68 to 425 tokens across five identical calls for a one-sentence image description. With it off, the same five calls returned 18 to 20 tokens. For "describe this image in one sentence", the reasoning is buying variance rather than accuracy.

Add it up at peak rates. Thinking on: 439 input plus 114 output is about $0.000343 per call. Thinking off: 359 plus 19 is about $0.000183. Nearly half the bill, on a task where the visible answer is the same either way.

Switch it off with either of these:

{"thinking": {"type": "disabled"}}
{"reasoning_effort": "none"}

Both worked on the test route, and both made the reasoning_tokens field disappear from the usage object rather than merely shrink. If you want thinking but cheaper, the effort mapping is worth reading first: DeepSeek maps low to low, max to max, and medium, high and xhigh all to high. Three of the five values you might send are the same setting.

How Do I Send an Image?

Standard OpenAI-compatible content blocks. Three transports are available: inline base64, an external URL, and a Files API file_id.

import base64
from openai import OpenAI

client = OpenAI(api_key="sk-...", base_url="https://api.ofox.ai/v1")

with open("chart.png", "rb") as f:
    b64 = base64.b64encode(f.read()).decode()

r = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash-vision-exp",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What is the trend in this chart?"},
        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
    ]}],
    extra_body={"thinking": {"type": "disabled"}},
)
print(r.usage)

Calling DeepSeek directly, the base URL becomes https://api.deepseek.com and the model string drops its deepseek/ prefix. The Anthropic-format endpoint is https://api.deepseek.com/anthropic, and images travel as input_image parts on the Responses API.

Two restrictions that return HTTP 400 rather than degrading: images are accepted only in user messages, and only the vision model accepts them at all. Send an image to deepseek-v4-flash and you get "This model does not support image".

What Are the Limits?

Limit	Value
Formats	JPEG, PNG, GIF, WebP (detected from content, not filename)
Images per request	600
Request body	48 MiB
Single image, base64 or URL	32 MiB
Single image, Files API `file_id`	64 MiB
Total images per request	64 MiB without `file_id`, up to 200 MiB with
Max dimension	8192 px per side, 4096 px once a request carries 15+ images
External URL length	8192 characters

The dimension rule is the one that bites in production. A batch job that sends fourteen screenshots at 6000 px works; the fifteenth one silently changes the ceiling for the whole request.

Should You Switch From V4 Flash?

If you send images at all, yes, because it costs nothing to. The rates are identical, the context and output ceilings are identical, and the concurrency limit is identical. The only thing you give up is FIM completion, which matters for inline code completion and nothing else.

Workload	Call
Screenshot and document OCR at volume	Switch. 384 tokens per page is hard to beat
Chart and diagram reading	Switch, but keep thinking on for multi-step reads
Text-only chat and classification	No reason either way, prices match
Inline code completion via FIM	Stay on `deepseek-v4-flash`, FIM is gone here
Long-horizon agents on images	Test first, the `-exp` suffix is not a stability promise

For the wider picture on which multimodal endpoints do what, the multimodal API guide covers vision alongside speech, and the V4 Flash against Gemini 3.6 Flash cost comparison has the per-task math on the text side of the same model.

References

Frequently Asked Questions

What is DeepSeek V4 Flash Vision Exp?

It is a vision-capable variant of DeepSeek V4 Flash, model ID deepseek-v4-flash-vision-exp. It accepts images alongside text in user messages and bills them at the same rates as the text-only V4 Flash: $0.44 per million input tokens and $1.32 per million output at peak, half that off-peak. Context is 1M tokens with 384K maximum output, the same as V4 Flash.

How much does an image cost on DeepSeek V4 Flash Vision?

Very little. Images are resized before inference so that the total pixel count lands near an 800x800 image, which caps each image at 384 input tokens. Testing measured 348 tokens for both an 800x800 and a 3000x3000 image on the same route, which works out to $0.000153 per image at the peak input rate and half that off-peak. Prompt length, not image resolution, is what moves that number.

Is DeepSeek V4 Flash Vision more expensive than V4 Flash?

No. DeepSeek's pricing page prints identical numbers for deepseek-v4-flash and deepseek-v4-flash-vision-exp across every row: cache hit, cache miss and output, at both peak and off-peak. The concurrency limit is also the same 2500. The vision variant is the text model's price list with image input added.

Does DeepSeek V4 Flash Vision support thinking mode?

Yes, and it is on by default with effort set to high. Send thinking with type disabled, or reasoning_effort none, to turn it off. In testing, turning it off dropped the median completion from 114 tokens to 19 and the median call from 1.9 seconds to 1.0.

How many images can one request carry?

Up to 600. The per-request ceilings are 48 MiB of request body, 32 MiB per image sent as base64 or an external URL, 64 MiB per image via a Files API file_id, and 64 MiB of images in total without file_id references. Maximum dimension is 8192 pixels per side, dropping to 4096 once a request carries 15 or more images.

What image formats does DeepSeek V4 Flash Vision accept?

JPEG, PNG, GIF and WebP. The format is detected from the file content rather than the filename or the declared MIME type, so a mislabelled extension does not break the call. Images are accepted only in user messages: an image in a system or assistant message returns HTTP 400.

What does DeepSeek V4 Flash Vision give up compared to V4 Flash?

One line on the feature table. FIM completion, which V4 Flash supports in non-thinking mode, is listed as not supported on the vision variant. JSON output, tool calls, the Responses API, the Anthropic-format API and chat prefix completion all carry over unchanged.

Originally published on ofox.ai/blog.

What Is a Context Window? Token Limits by Model (2026)

Owen — Fri, 21 Aug 2026 00:02:38 +0000

What Is a Context Window? Token Limits by Model (2026)

A context window is the maximum number of tokens a model can handle in one request, counting the input and the output together. We sent one identical document to nine models: it metered anywhere from 614 to 957 tokens. That is a 1.56x spread on the same text.

Unit:             tokens (~4 English chars each, with wide variation)
Scope:            one request; nothing persists between calls
Includes:         system prompt, history, tool defs, tool results, reasoning, reply
Typical sizes:    200K on cheaper models, 1M on current flagships
2026 maximum:     1,131,072 (Qwen 3.8 Max)
At the limit:     HTTP 400. Nothing is silently truncated

What Counts Toward the Window?

Everything the model reads and writes:

System prompt, counted every turn
Full message history, all prior exchanges
Tool definitions — names, descriptions, JSON schemas
Tool results, often the largest single item
Reasoning tokens, billed even when not returned to you
The reply itself

One consequence people hit on upgrade: on Claude Opus 5 thinking is on by default, so a request sized tightly around its answer on an older model can now run out of room mid-response.

How Big Is Each Model's Window?

Model	Context window	Max output
Qwen 3.8 Max	1,131,072	131,072
GPT-5.6 Sol	1,050,000	128,000
Gemini 3.1 Pro	1,048,576	65,536
GLM-5.2	1,048,576	128,000
Kimi K3	1,048,576	1,048,576
Claude Opus 5	1,000,000	128,000
DeepSeek V4 Flash	1,000,000	384,000
Grok 4.20	1,000,000	not published
Claude Haiku 4.5	200,000	64,000

"1M" is nine different numbers, from exactly 1,000,000 to 1,131,072 — a 13% spread before you measure a single token of your own content.

Why "1M Tokens" Doesn't Mean the Same Thing Everywhere

We sent one 2,638-character English document to nine models:

Model	Tokens	Chars/token
Grok 4.20	614	4.30
GPT-5.6 Sol	626	4.21
GLM-5.2	632	4.17
DeepSeek V4 Flash	634	4.16
Gemini 3.1 Pro	684	3.86
Claude Opus 4.6	698	3.78
Qwen 3.8 Max	706	3.74
Kimi K3	716	3.68
Claude Opus 5	957	2.76

Claude Opus 5 is the outlier for a documented reason: Anthropic states that Claude 4.7 and later use a newer tokenizer producing "approximately 30% more tokens for the same text."

Translate that into how many copies of the document actually fit:

Model	Advertised window	Document copies
GPT-5.6 Sol	1,050,000	1,677
GLM-5.2	1,048,576	1,659
Grok 4.20	1,000,000	1,629
Qwen 3.8 Max	1,131,072	1,602
DeepSeek V4 Flash	1,000,000	1,577
Gemini 3.1 Pro	1,048,576	1,533
Kimi K3	1,048,576	1,464
Claude Opus 4.6	1,000,000	1,432
Claude Opus 5	1,000,000	1,045

Similar advertised sizes, 1.60x difference in real capacity for this document. Content type shifts it again — code, English prose and non-English text tokenize differently. Measure your own content on the models you are choosing between.

What Happens When You Exceed It?

HTTP 400 and no output. Nothing is silently truncated.

{"error":{"code":null,
  "message":"<400> InternalError.Algo.InvalidParameter: Range of input length should be [1, 30720]",
  "type":"invalid_request_error"}}

Note the enforced input ceiling can be lower than the advertised total — 30,720 against 32,000 here, with the difference reserved for output.

Vendors differ in how they signal it. OpenAI-compatible endpoints return 400 with a context_length_exceeded code; Claude can finish with stop_reason: "model_context_window_exceeded". Both need distinct handling.

Does a Bigger Window Cost More?

Depends on the vendor, and this is where the cheaper headline rate can lose:

Flat rate: Anthropic bills the full 1M at standard rates, no long-context premium
Tiered: Gemini 3.1 Pro goes $2 → $4 per million input and $12 → $18 output once prompts exceed 200K; Grok 4.20 goes $1.25 → $2.50 input and $2.50 → $5.00 at the same threshold

Is the Advertised Window the Same as Usable Context?

No, and this is the most important caveat on the page. A model that accepts 1M tokens does not reliably retrieve information at the far end of it. Retrieval accuracy degrades with distance for every public model. Benchmarks like RULER, MRCR v2 and NoLiMa measure what actually works rather than what is accepted.

Treat the advertised window as an upper acceptance bound, not a capability claim.

How Do You Fit More In?

These reduce spend rather than expanding capacity:

Prompt caching — stable prefixes bill at roughly 10% of input rates on a hit. Largest lever for repeated calls.
Compaction — server-side summarisation of earlier turns keeps long agent sessions alive.
Context editing — drop stale tool results and old reasoning blocks. Agent loops accumulate tool output faster than conversation.
Tokenizer choice — picking the right model for your content is worth up to 1.6x effective capacity on its own.

How Do You Compare Token Counts Yourself?

Same request, different vendors, one loop:

from openai import OpenAI

client = OpenAI(base_url="https://api.ofox.ai/v1", api_key="YOUR_OFOX_KEY")
text = open("your_document.txt").read()

for model in [
    "anthropic/claude-opus-5",
    "openai/gpt-5.6-sol",
    "google/gemini-3.1-pro-preview",
    "moonshotai/kimi-k3",
    "z-ai/glm-5.2",
]:
    r = client.chat.completions.create(
        model=model, max_tokens=1,
        messages=[{"role": "user", "content": text}],
    )
    n = r.usage.prompt_tokens
    print(f"{model:32} {n:>7,} tokens   {len(text)/n:.2f} chars/token")

max_tokens: 1 returns prompt_tokens at minimal cost.

Frequently Asked Questions

Is a context window the same as memory?
No. It is per-request only. Every turn you resend the whole conversation. Products that appear to remember you across sessions re-inject stored text; there is no persistent model memory.

How many words is 1 million tokens?
For English prose, roughly 440,000 to 685,000 words. Eight of nine models tested landed between 587,000 and 684,000; Claude Opus 5 reached about 439,000 because of its tokenizer. Code runs denser (2.4 to 3.6 chars/token), Chinese denser still.

Why does the same file use more tokens on Claude than GPT?
Different tokenizers. Anthropic's newer tokenizer in Claude 4.7+ produces roughly 30% more tokens for identical text. On our test document: 957 tokens on Opus 5 against 626 on GPT-5.6 Sol.

Does filling the window make the model slower?
Yes, and more expensive per turn. Every token is processed on each request, so a 400K-token conversation costs 400K tokens on every new turn unless prompt caching is active.

Can I increase a model's context window?
No. It is fixed by the model with no adjustment parameter. You can only spend it better.

References

Originally published on ofox.ai/blog.

Seedance 2.5 vs 2.0: What Changed, and When 2.0 Still Wins

Owen — Fri, 21 Aug 2026 00:02:03 +0000

Seedance 2.5 vs 2.0: What Changed, and When 2.0 Still Wins

Seedance 2.5 doubles maximum clip length to 30 seconds and accepts 50 reference assets against 15. It also caps at 720p and costs 60% more per second. Neither model replaces the other.

Feature	Seedance 2.5	Seedance 2.0
Output duration	4 to 30 s	4 to 15 s
Output resolution	480p, 720p (1080p from 2026-08-17)	480p, 720p, 1080p, 4K
Reference assets	50 (30 images + 10 videos + 10 audio)	15 (9 images + 3 videos + 3 audio)
Audio-only reference	Yes	No, requires image or video
Output format	mp4, mov	mp4
Timestamp precision	Integer seconds	Shot numbers only

The reference budget expansion is substantial: 30 images at up to 4K, 10 videos totalling 30 seconds, 10 audio clips also totalling 30 seconds. The recommended working range stays conservative — 1 to 8 image subjects and 1 to 5 audio or video subjects — beyond which stability degrades.

Does the Timestamp Control Actually Work?

We ran the same three-beat prompt through both with explicit second ranges:

"0-2s: the paper fox sits still, then its ears twitch twice. 2-4s: the fox unfolds into a single flat sheet of orange paper. 4-6s: the flat sheet folds itself back into the fox, which hops once toward the camera and freezes."

At t=1s both showed the intact fox. At t=3s Seedance 2.0 had already completed the unfolding while 2.5 was mid-transformation, matching the prompt. At t=5s, 2.5 captured the hop; 2.0 had refolded and skipped the instruction.

The vendor's line that 2.0 "doesn't respond to timestamps" is directionally accurate rather than literally true. For simple scripts with evenly spaced beats, 2.0 lands approximately right. With 30-second clips containing ten beats, that approximation compounds — which is exactly the case 2.5 addresses.

What Does Each One Cost?

Route	Seedance 2.5	Seedance 2.0	Difference
480p, text or image to video	$0.11/s	$0.063/s	+75%
720p, text or image to video	$0.24/s	$0.15/s	+60%
1080p	not until 2026-08-17	$0.31/s	n/a
4K	not available	$1.24/s	n/a

Real billing from 2026-08-13: 6 seconds at 480p cost $0.66 on 2.5 against $0.378 on 2.0. Thirty seconds at 480p cost $3.30 on 2.5 and is not possible on 2.0 at all.

Two discount periods complicate this. ByteDance runs a promotion 2026-08-07 to 09-07 reducing Mini and Fast tiers to 40% and 75% of list, but it excludes the base 2.0 model. A separate Seedance 2.5 discount 08-14 to 09-17 applies only to 1080p output, leaving 480p and 720p unaffected.

Which Is Faster?

In a single test run, the same 6-second 480p prompt submitted within one second of each other took 103 seconds on 2.5 and 289 seconds on 2.0 — a 2.8x difference. A 30-second clip on 2.5 took 200 seconds, less than the 2.0 six-second clip took that afternoon.

This is one pair of runs on shared infrastructure, not a published benchmark. It does contradict the assumption that longer-context models must process more slowly.

Which One Should You Use?

Requirement	Model	Reason
4K output, or 1080p before 2026-08-17	2.0	2.5 stops at 720p until then
Single clip longer than 15 seconds	2.5	2.0 rejects duration above 15
Cheap iteration during development	2.0 Mini or Fast	No 2.5 tier below $0.11/s
Precise beat timing inside the clip	2.5	Integer-second timestamps
More than 15 reference assets, or audio-only reference	2.5	2.0 caps at 15 and requires visual input
Editing or extending existing footage	2.5	mov output plus documented controls
Lowest cost per finished second	2.0	40% cheaper at 720p, cheaper on Fast and Mini

The optimal workflow combines both: iterate on 2.0 Mini at 480p to finalise the script and references, then generate the final version at the settings that matter.

Integration Notes

Both models run through the same /v1/videos endpoint, so switching is a model string change from bytedance/seedance-2.0 to bytedance/seedance-2.5. Two incompatibilities return immediate HTTP 400 rather than degrading silently:

Duration above 15 seconds: rejected by 2.0
Resolution above 720p: rejected by 2.5 until 2026-08-17

Seedance 2.5 also distinguishes locked from unlocked tasks. Locked tasks (editing, extension, first/last frame control) force ratio to adaptive, and editing requests require specific trigger words in the prompt. A 2.0-era editing instruction without trigger words gets reclassified as a reference job — you get a new video instead of an edited one.

Frequently Asked Questions

Is Seedance 2.5 better than 2.0?
For duration, reference quantity and timeline precision, yes. For resolution and cost, no. 2.0 exclusively handles 4K and is currently the only 1080p option.

Does Seedance 2.5 support 4K?
No. 1080p launches 2026-08-17; 4K is not available on 2.5 at all. Requesting an unsupported resolution returns HTTP 400 rather than downscaling automatically.

Do Seedance 2.0 prompts work on 2.5?
They function but underutilise capabilities and risk misfiring. Edit and extend operations require trigger words on 2.5, so a 2.0-style edit prompt may generate new content instead of modifying existing footage.

References

Originally published on ofox.ai/blog.

Qwen 3.8 Max in Codex CLI 2026: Config, 258K Fix, Real Cost

Owen — Fri, 21 Aug 2026 00:01:58 +0000

Qwen 3.8 Max in Codex CLI 2026: Config, 258K Fix, Real Cost

Yes, Codex CLI runs Qwen 3.8 Max — through a gateway using the Responses API protocol. Codex has no built-in support for the model, so it takes a custom provider declaration: six lines of TOML.

Model slug:      bailian/qwen3.8-max
Wire protocol:   responses
Default context: 258,400 tokens (below the model's 1M)
Measured cost:   $0.08 for 3 tasks vs $0.54 on GPT-5.5 (2026-08-06)
Pricing:         $2/$6 per 1M in/out, cache read $0.25/M

What Works and What Does Not

Works: the complete agent loop — reading files, applying patches via Codex's apply_patch, running Python verification, reporting results. Unlike Claude Sonnet 5 and DeepSeek, it handles Codex's freeform tool shape without rejection errors.

Does not:

Capped at 258,400 tokens instead of the full 1M context
Unlocking the full window replaces Codex's compiled system prompt with your own
The tokens used display under-reports cached tokens (up to 85% of input in testing)
Separate API-key billing path from your ChatGPT subscription

How Do You Configure It?

Step 1: Install and set your key

npm i -g @openai/codex
export OFOX_API_KEY="sk-of-..."
codex --version   # expect 0.146.x

Do not use codex login --with-api-key — it writes OpenAI credentials unsuitable for custom providers.

Step 2: Write the provider block

~/.codex/config.toml:

model = "bailian/qwen3.8-max"
model_provider = "ofox"

[model_providers.ofox]
name = "ofox"
base_url = "https://api.ofox.ai/v1"
env_key = "OFOX_API_KEY"
wire_api = "responses"
requires_openai_auth = false

Three fields matter: wire_api = "responses" is now mandatory ("chat" triggers a hard startup error), env_key names the environment variable Codex reads, and requires_openai_auth = false bypasses ChatGPT login.

Step 3: Run it

codex exec --sandbox workspace-write "median() is wrong for even-length input. Fix it in stats.py."

Why Does Codex Cap My Context at 258,400 Tokens?

Codex ships a compiled-in catalog covering only OpenAI models. Unknown models get fallback defaults:

grep -o '"model_context_window":[0-9]*' \
  ~/.codex/sessions/2026/08/06/rollout-*.jsonl | tail -1
# "model_context_window":258400

Three approaches tested on 0.146.1, only one works:

Attempt	Warning gone?	Reported window
Default (no override)	No	258,400
`model_context_window` in config.toml	No	258,400
`-c model_context_window=...` CLI flag	No	258,400
`model_catalog_json` with custom entry	Yes	1,131,072

The catalog JSON requires all 39 ModelInfo fields. One caveat worth weighing: base_instructions in that entry replaces Codex's system prompt. For sessions comfortably under 258K, skipping this step is defensible.

What Errors Will You Hit?

Error	Real cause	Fix
`Missing bearer or basic authentication in header`	No key reached the gateway	Set the variable named in `env_key`
401 saying the key is invalid (works elsewhere)	`env_key` missing, wrong key sent	Add `env_key` to the provider block
`You didn't provide an API key`	Trailing newline in the key	Strip it
`wire_api = "chat" is no longer supported`	Deprecated before 0.146	Set `wire_api = "responses"`
404 on every request	Missing `/v1` on base_url	Use `https://api.ofox.ai/v1`
`Model metadata not found`	Slug outside the built-in catalog	See the 258K section
`missing field 'display_name'`	Incomplete ModelInfo entry	All 39 fields required

What Does It Actually Cost?

Three real coding tasks, same CLI, same gateway, same repo, 2026-08-06:

Task	Qwen 3.8 Max	GPT-5.5	Gap
Fix `median()` bug	$0.0244	$0.1223	5.0x
Add type hints and unittest coverage	$0.0373	$0.2017	5.4x
Explain repo and flag risks	$0.0187	$0.2146	11.5x
Total	$0.0804	$0.5387	6.7x

Is the 6.7x real? Partially. Rate-card differences justify 2.5x on input and 5x on output. The rest comes from configuration and task variance:

System prompt difference. GPT-5.5 gets OpenAI's full instruction set; Qwen under a custom catalog gets your one-line base_instructions.
Turn count. Models choose their own round-trip counts. On "explain repo," GPT-5.5 took 8 API calls with 7 tool invocations; Qwen took 4 calls with 3 — that alone explains the 11.5x on that task.

Treat 6.7x as measured for this configuration on this date. 2.5x/5x is the rate-card floor.

Why is the token count in Codex lower than my bill?

The tokens used line subtracts cached input from the total. One task displayed 5,859 while the session log showed:

{"input_tokens": 37401, "cached_input_tokens": 32512,
 "output_tokens": 970, "total_tokens": 38371}

38,371 − 32,512 = 5,859. Cached tokens are billed at cache-read rates, not free.

Does reasoning effort change the bill much?

Surprisingly little. Same task, same model, only model_reasoning_effort changed:

Effort	Reasoning tokens	Total tokens	Cost
low	200	26,094	$0.0244
high	493	26,884	$0.0252

Reasoning output tripled; the bill rose 3.3%. In agent loops, conversation replay dominates and reasoning is a thin overlay. This pattern holds for short agentic tasks — a single long reasoning-heavy request with minimal tool use reverses it.

Which Models Can Replace Qwen Here?

Not everything behind an OpenAI-compatible gateway survives Codex's Responses requirement. Six models tested on 2026-08-06:

Model	Result in Codex
`bailian/qwen3.8-max`	Works, full agent loop
`openai/gpt-5.5`	Works
`anthropic/claude-sonnet-5`	Fails on `apply_patch` tool shape
`deepseek/deepseek-v4-pro`	`Encrypted content is not supported`
`x-ai/grok-4.3`	Same encrypted-content failure
`z-ai/glm-5.2`	503, no Responses support upstream

Encrypted-content failures are unfixable — Codex hard-codes that field with no disable option.

Frequently Asked Questions

Does this affect my ChatGPT or Codex plan limits?
No. Custom providers use a separate API-key billing path, leaving weekly Codex caps untouched.

Will the 258K cap be fixed upstream?
Codex resolves metadata from a compiled catalog, so third-party slugs keep falling back until that design changes. The catalog JSON is the supported workaround today.

Is Qwen 3.8 Max worth switching to just for the price?
Rate-card advantages (2.5x input, 5x output) justify it for routine agent work. For tasks where errors cost debugging time, evaluate quality first.

Originally published on ofox.ai/blog.

Grok 4.6 API Pricing: The 200K Cliff and When 4.5 Wins

Owen — Thu, 20 Aug 2026 23:31:39 +0000

Grok 4.6 API Pricing: The 200K Cliff and When 4.5 Wins

Grok 4.6 costs $2.00 per million input tokens and $6.00 output, which is exactly what Grok 4.5 costs. The two model cards are otherwise identical down to the rate limits. One number differs, cached input, and it is the newer model that is more expensive there.

The bigger number is the one that is not a difference between models at all: at 200,000 prompt tokens, every rate doubles, and it doubles for the whole request.

Model IDs:     grok-4.6 / grok-4.5  (x-ai/grok-4.6 on gateways)
Context:       500K tokens, both
Under 200K:    $2.00 in / $6.00 out    both models
                $0.50 cached on 4.6, $0.30 cached on 4.5
200K and over: $4.00 in / $12.00 out   both models
                $1.00 cached on 4.6, $0.60 cached on 4.5
Threshold:     applies to ALL tokens in the request, not the excess
Measured:      fixed per-request overhead 206 tokens on 4.6, 494 on 4.5
Break-even:    ~575 cached tokens; below it 4.6 is cheaper per call
Snapshot:      2026-08-19

How Much Does the Grok 4.6 API Cost?

$2.00 in, $0.50 cached in, $6.00 out per million tokens, until the prompt reaches 200K. Straight from xAI's model list:

Model	Context	Input	Cached input	Output
grok-4.6, prompt under 200K	500K	$2.00	$0.50	$6.00
grok-4.6, prompt 200K and over	500K	$4.00	$1.00	$12.00
grok-4.5, prompt under 200K	500K	$2.00	$0.30	$6.00
grok-4.5, prompt 200K and over	500K	$4.00	$0.60	$12.00
grok-4.3	1M	$1.25	$0.20	$2.50

Grok 4.3 is in that table for a reason. It is 38% cheaper on input and 58% cheaper on output than either 4.x flagship, and it carries a 1M context instead of 500K.

Gateways pass the headline rate through unchanged. OpenRouter and ofox both list x-ai/grok-4.6 at $2.00 and $6.00 with a 500,000-token context. What neither catalog exposes is the second row, so the doubling above 200K is invisible until it lands on your invoice.

What Happens When Your Prompt Crosses 200K Tokens?

The whole request reprices, not the overflow. xAI's wording is unambiguous: requests whose prompt reaches the threshold are billed at the higher rate for all tokens in the request.

Two requests, 2,000 tokens apart, both with 2,000 tokens of output:

Prompt size	Input cost	Output cost	Total
199,000 tokens	$0.398	$0.012	$0.410
201,000 tokens	$0.804	$0.024	$0.828

A 1% larger prompt for a 102% larger bill. There is no gradual slope here, and no partial credit for the tokens below the line.

Two things make that line easier to cross than it looks. First, the threshold counts the prompt, so a long conversation walks toward it one turn at a time. Second, your prompt is not the only thing in the prompt, which is the subject of the next section.

If you are batching, split before the line rather than after it. Two 150K requests at the low tier cost $0.60 in input; one 300K request costs $1.20 for the same tokens.

What Is the Difference Between Grok 4.6 and Grok 4.5?

One number on the published cards.

Field	Grok 4.6	Grok 4.5
Context window	500,000	500,000
Modalities	text, image to text	text, image to text
Function calling	Yes	Yes
Structured outputs	Yes	Yes
Reasoning	Yes	Yes
Requests per second	150	150
Tokens per minute	50,000,000	50,000,000
Regions	us-east-1, us-west-2	us-east-1, us-west-2
Input / output	$2.00 / $6.00	$2.00 / $6.00
Cached input	$0.50	$0.30
Aliases	none listed	`grok-4.5-latest`, `grok-build-latest`

Cached input is 67% more expensive on the newer model. That is the opposite of the usual direction and it is the entire published basis for keeping 4.5 around.

The alias row matters if you use Grok Build: grok-build-latest resolves to Grok 4.5, not 4.6.

Why Does the Same Prompt Cost More on Grok 4.5?

Because a fixed block of input tokens rides along with every request, and it is more than twice as large on 4.5.

We sent identical bodies of 1, 50 and 200 repeated words to four models through an OpenAI-compatible gateway on 2026-08-19 and fit the line. Every model tokenized the body at exactly 1.00 token per word. The intercepts did not match:

Model	Fixed input overhead	Of which reported cached
`x-ai/grok-4.6`	206 tokens	128
`x-ai/grok-4.5`	494 tokens	384
`x-ai/grok-4.3`	4 tokens	none
`z-ai/glm-5.3`	12 tokens	none

Four and twelve tokens are an ordinary chat template. Two hundred and four hundred and ninety-four are a preamble. Adding your own system message raised both figures by exactly the size of that message, so this sits underneath anything you send.

We could not test a second route to attribute it, so treat the source as unproven. Either way it is on your invoice, so price it.

	Grok 4.6	Grok 4.5
Cached portion	128 × $0.50/M = $0.000064	384 × $0.30/M = $0.000115
Uncached portion	78 × $2.00/M = $0.000156	110 × $2.00/M = $0.000220
Per request	$0.000220	$0.000335
Per 1M requests	$220	$335

It also eats your headroom. On 4.5 you reach the 200K cliff 494 tokens earlier than your own token count suggests. If you are budgeting a prompt at exactly 199,800 tokens, you are already over.

Which One Is Cheaper for Your Workload?

Around 575 cached tokens, the answer flips.

Grok 4.5 saves $0.20 per million cached tokens, which is $0.0000002 per cached token. It loses $0.000115 per request on the larger preamble. Divide one by the other and you get 575 tokens.

Cached prefix under ~575 tokens: Grok 4.6 costs less per call
Cached prefix over ~575 tokens: Grok 4.5 costs less, and the gap widens linearly

That covers input. Output is where the two models genuinely diverge. We ran the same code-generation prompt through both, 8 runs each:

	Grok 4.6	Grok 4.5
`completion_tokens`, median	216	225
`reasoning_tokens`, median	723	30
Billed output, median	948	263
Latency, median	15.8 s	5.0 s
Cost per 1,000 tasks, all-in	$6.18	$2.64

That last row is the only one in the table that is not an output-side number, so here is its basis. It is output at $6.00 per million plus the full input at $2.00 per million, and the input side includes the fixed per-request overhead: 244 input tokens on 4.6, 532 on 4.5. Output alone would be $5.69 and $1.58. We did not record cache hits on these runs, so input is priced entirely at the uncached rate, making the all-in figure an upper bound.

Watch the field names. completion_tokens excludes reasoning tokens on these models: a response reporting 216 completion tokens had 723 reasoning tokens alongside it, and total_tokens was the sum of prompt, completion and reasoning. Any cost estimator built on prompt_tokens × input + completion_tokens × output undercounts the billed output by 77%.

So the short version: 4.5 for long cached prefixes and short deterministic work, 4.6 when the extra reasoning is the point.

How Do I Call Grok 4.6?

from openai import OpenAI

client = OpenAI(api_key="YOUR_KEY", base_url="https://api.ofox.ai/v1")

r = client.chat.completions.create(
    model="x-ai/grok-4.6",          # x-ai/grok-4.5 for the cheaper cache tier
    messages=[{"role": "user", "content": "Refactor this module and run the tests."}],
)
u = r.usage
billed_output = u.completion_tokens + u.completion_tokens_details.reasoning_tokens
print(u.prompt_tokens, billed_output)

Three things that bite people on the way in:

The ID is namespaced on gateways. grok-4.6 works against xAI directly; on OpenRouter and ofox it is x-ai/grok-4.6.
logprobs fails silently. xAI documents it as unsupported on grok-4.20 and newer. We sent logprobs: true with top_logprobs: 3 to both models: HTTP 200, no error, and no logprobs object in the response.
Both models are in us-east-1 and us-west-2 only. If you have data-residency constraints outside the US, this pair is not the answer regardless of price.

For rate limits across providers, our LLM API rate limits comparison has the numbers side by side.

References

Originally published on ofox.ai/blog.

GLM 5.3 API: Pricing, Endpoints, and reasoning_effort

Owen — Thu, 20 Aug 2026 20:28:40 +0000

GLM 5.3 API: Pricing, Endpoints, and reasoning_effort

The GLM 5.3 API opened five days after the model did, at $1.40 per million input tokens and $4.40 per million output, the same rate as GLM 5.2. The price is not what will surprise you. reasoning_effort defaults to max, and on a short classification call we measured max spending a median of 105 output tokens where low spent 3.

That is a 35x difference on the metered half of your bill, set by a parameter most people will not send.

Price:        $1.40 in / $0.26 cached in / $4.40 out per 1M tokens
Context:      1M tokens, 128K max output
Base URLs:    api.z.ai/api/coding/paas/v4  (OpenAI Chat Completions)
              api.z.ai/api/v1              (OpenAI Responses)
              api.z.ai/api/anthropic       (Anthropic Messages)
Gateways:     z-ai/glm-5.3 on OpenRouter and ofox
Effort:       low | high | max, default max, cannot be disabled
Removed:      thinking.type "disabled" now returns HTTP 400
Measured:     classify task 3 / 8 / 105 output tokens at low / high / max
Snapshot:     2026-08-19

How Much Does the GLM 5.3 API Cost?

$1.40 per million input tokens, $0.26 cached input, $4.40 output. Z.ai's pricing table now carries a GLM-5.3 row, and it matches GLM 5.2 and GLM 5.1 line for line.

Item	Rate
Input	$1.40 / 1M tokens
Cached input	$0.26 / 1M tokens
Cached input storage	Free, marked limited-time
Output	$4.40 / 1M tokens

Cached input at $0.26 is 19% of a cold read, and the storage that usually makes caching a judgement call is free during the promotion. Output costs 3.1x input, which is the ratio that makes the effort setting below the most expensive line in your config.

OpenRouter lists the same $1.4 / $4.4 pair at a 1,048,576-token context, so third-party routes are passing the first-party rate through rather than marking it up.

What Is the Base URL for the GLM 5.3 API?

Three protocols, and the docs page contradicts itself about one of them. The model page lists these:

Protocol	Base URL
OpenAI Chat Completions	`https://api.z.ai/api/coding/paas/v4`
OpenAI Responses	`https://api.z.ai/api/v1`
Anthropic Messages	`https://api.z.ai/api/anthropic`

Then the Quick Start section further down the same page posts to https://api.z.ai/api/paas/v4/chat/completions, without the /coding segment. If the first one 404s, try the second before you go looking for a problem in your key.

Neither of them is the https://open.bigmodel.cn/api/paas/v4 that Zhipu previewed on launch day.

One restriction is easy to miss: accounts that have ever subscribed to a GLM Coding Plan, including expired subscriptions, can currently reach the model API only through the OpenAI Chat Completions protocol. If your Responses or Anthropic-protocol calls fail on an account that used to run a plan, that is why.

What Does reasoning_effort Do to Your Bill?

More than the model choice does. GLM 5.3 always reasons, reasoning_effort takes low, high or max, and the default is max.

We ran two workloads through z-ai/glm-5.3 on an OpenAI-compatible gateway on 2026-08-19. A short classification prompt at n=10 per level, and a small code-generation prompt at n=5 per level.

Workload	Effort	Output tokens, median	Range	Latency, median
Classify a support ticket (51 in)	low	3	3 to 8	1.6 s
	high	8	8 to 8	1.9 s
	max	105	47 to 160	3.4 s
Write a merge-intervals function (50 in)	low	519	418 to 586	11.6 s
	high	658	592 to 825	8.6 s
	max	3,700	2,807 to 10,596	64.0 s

The classification row is the one to look at twice. Three output tokens at low, 105 at max, for an answer that is a single word either way. We then re-ran the classification 18 more times, six per effort level: every single run returned billing, the correct label, at all three settings.

Workload	low	high	max
1M classification calls	$84.60	$106.60	$533.40
1,000 code-generation tasks	$2.35	$2.97	$16.35

Both rows are all-in: input at $1.40/M plus output at $4.40/M, priced at uncached rates. Output alone on the classification row would be $13.20, $35.20 and $462.00, so the fixed $71.40 of input compresses the token-level 35x ratio to 6.3x on the final bill.

high is the setting that gets skipped and probably should not be. It cost 26% more than low on both jobs, and on the code job it was faster than low at the median, 8.6 seconds against 11.6. Latency does not climb monotonically with effort.

A caveat: these are two prompts, not a benchmark suite, and the max ranges are wide. Run your own prompt before you size a budget on it.

Why Does My GLM 5.3 Request Return 400?

Most likely because reasoning cannot be switched off, and the message is only half accurate.

{
  "error": {
    "message": "This model always engages in thinking and cannot be disabled; please use low, high, or max"
  }
}

That is the response to "thinking": {"type": "disabled"}, which is correct and expected. On 2026-08-19 it was also the response to "reasoning_effort": "medium" and "none", which was not, because neither tried to disable anything.

That validation behaviour then changed. Re-testing on 2026-08-20, the same route accepted medium, none, minimal and xhigh with HTTP 200, each burning eight to thirteen times the output tokens of an explicit low on the same prompt. A different route to the same model name still returned the 400 that day. A genuinely malformed value like "invalid_value" was rejected on both routes, so validation exists — it just lives on the route rather than in the model, and it changed under a fixed model name with no announcement.

Two consequences. A 400 here does not always mean what the message says. And a 200 does not confirm the value picked the tier its name suggests: on the accepting route every undocumented value landed near max, so a harness sending medium believing it picked middle pricing pays top-tier rates silently.

Request	Result
`thinking.type: "disabled"`	400, thinking cannot be disabled
`reasoning_effort: "medium"` / `"none"` / `"minimal"` / `"xhigh"`	Route-dependent. 400 on 2026-08-19; 200 billed near `max` on 2026-08-20
`reasoning_effort: "low"` / `"high"` / `"max"`	200
`thinking.type: "enabled"` plus `reasoning_effort: "low"`	200
No reasoning field at all	200, billed as `max`
Model ID `zai/glm-5.3` on a gateway	404 `model_not_found`, the prefix is `z-ai`

How Do I Migrate a GLM 5.2 Workload to GLM 5.3?

Change the effort parameter first, then the model ID. A request carrying thinking.type: "disabled" fails the moment the model ID flips.

from openai import OpenAI

client = OpenAI(api_key="YOUR_KEY", base_url="https://api.ofox.ai/v1")

r = client.chat.completions.create(
    model="z-ai/glm-5.3",
    messages=[{"role": "user", "content": "Classify this ticket: ..."}],
    reasoning_effort="low",   # omit this and you are billed at max
)
print(r.usage.completion_tokens)

Set it explicitly everywhere, including the places that inherit defaults: retry wrappers, evaluation harnesses, and any framework that builds the request body for you. A missing reasoning_effort is not a missing feature, it is a bill at max.

If you are wiring up a key from scratch, our GLM 5.2 API access guide applies unchanged. For the workload math on high-volume short calls, the GLM 5.2 versus GPT-5.5 cost comparison has the model.

Should I Call GLM 5.3 Directly or Through a Gateway?

Direct if you only run GLM. Through a gateway if you run anything else alongside it, or if you got caught by the Coding Plan protocol restriction.

	Z.ai direct	Gateway
Price	$1.4 / $4.4	Same, passed through
Protocols	Three, minus the Coding Plan restriction	Whatever the gateway speaks
Model ID	`glm-5.3`	`z-ai/glm-5.3`
Failover to another model	Your code	One string
Cache pricing	$0.26, storage free for now	Depends on passthrough

One caveat on gateways: what a proxy reports back is not always what it was billed. On the gateway we tested, usage.completion_tokens_details.reasoning_tokens does come through. What did not come through was any prompt_tokens_details cache field, and the reasoning text itself is absent from the message object. Verify both against your own provider before you build cost accounting on them.

For benchmarks, the weights timeline and the GLM 5.3 versus 5.2 capability picture, our GLM 5.3 launch coverage has the full table. The ofox model page for GLM 5.3 carries the live catalog spec.

References

Originally published on ofox.ai/blog.

Opus 5 vs Grok 4.6 Cost: 3.6x the Bill for 1.75x the Code

Owen — Thu, 20 Aug 2026 17:24:42 +0000

Opus 5 vs Grok 4.6 Cost: 3.6x the Bill for 1.75x the Code

TL;DR: Opus 5 bills 3.6x what Grok 4.6 bills on the same task, while returning 1.75x as much code in half the wall clock. Underneath that, the two providers disagree about what counts as output, so one cost formula gives a correct answer on Opus 5 and an answer 78% too low on Grok.

How Much More Does Opus 5 Cost Than Grok 4.6?

Both prices read off the ofox model pages on 2026-08-20.

Metric	Claude Opus 5	Grok 4.6
Input / 1M	$5.00	$2.00
Output / 1M	$25.00	$6.00
Cache read / 1M	$0.50	$0.50
Cache write / 1M	$6.25 (5 min), $10 (1 hr)	not charged
Context window	1M	500K
Max output	128K	66K
Released	2026-07-25	2026-08-12

Two rows deserve more attention than the headline rates.

Cache writes are asymmetric. Anthropic bills you to put a prompt into the cache and again, at a lower rate, to read it back. xAI bills only the read. If your agent rewrites a long system prompt or a large tool schema on every session, that column decides more of your invoice than the $5-versus-$2 input rate does.

Grok 4.6 has a second price tier that the catalog does not expose. Once a prompt reaches 200K tokens, every token in that request bills at double ($4 in, $12 out), not just the tokens past the line. Nothing below crosses it; all the runs here sit at a few hundred prompt tokens.

What Does One Real Task Actually Bill?

$0.1417 on Opus 5, $0.0397 on Grok 4.6. That is 3.6x.

The task: rewrite a Python CSV-parsing module to stream instead of buffering, detect its header reliably, surface malformed rows instead of dropping them, and keep money as Decimal. Four runs per model, same prompt, same OpenAI-compatible endpoint, non-streaming, max_tokens 8000, on 2026-08-20.

	Opus 5	Grok 4.6	Ratio
Prompt tokens	270	381	—
Visible output tokens (median)	5,616	1,308	—
Reasoning tokens (median)	not reported separately	5,229	—
Total tokens (median)	5,886	6,865	—
Wall clock (median)	59.0s	109.4s	Grok 1.85x slower
Output characters (median)	9,044	5,160	Opus 1.75x more
Bill per run (median)	$0.1417	$0.0397	3.6x
Cost per 1,000 output chars	$0.01567	$0.00769	2.0x

The bill row is all-in: input at the listed rate plus everything the provider counts as output, priced as total_tokens - prompt_tokens. On Grok that deliberately includes the reasoning tokens.

So the headline holds and then stops holding. Opus 5 costs 3.6x as much per run. Normalise by what actually came back and it costs 2.0x as much. Still more expensive, but roughly double rather than roughly quadruple.

Both models produced a working module every time. All eight runs returned finish_reason: stop. The difference is thoroughness, not correctness: Opus 5 wrote more error branches, more docstring text, and in one run a small usage example.

Why Is Grok Slower If It Writes Less?

Because most of what it produces, you never see. Median reasoning was 5,229 tokens against 1,308 tokens of visible answer, four reasoning tokens for every token in the file it hands you. Opus 5 does think on this prompt too, but it does not report the split.

You can see Opus 5's hidden portion indirectly. In the first pass, without an explicit max_tokens, one Opus 5 run reported 4,096 completion tokens and returned 845 characters of text. Four thousand tokens do not produce 845 characters of Python. The rest was thinking that was billed and not returned.

Why Is Your Cost Estimate Wrong for Exactly One of These Models?

Because completion_tokens means different things on the two APIs.

Almost every cost snippet on the internet computes:

cost = (usage.prompt_tokens * in_rate + usage.completion_tokens * out_rate) / 1e6

Run that against the same four Grok 4.6 responses and it returns a median of $0.0086. The real median is $0.0397. The formula understates the bill by 78%.

The reason is one field:

Field	Opus 5	Grok 4.6
`completion_tokens`	includes thinking	excludes reasoning
`completion_tokens_details.reasoning_tokens`	not present	present, and large
`total_tokens`	prompt + completion	prompt + completion + reasoning

Verified on a short streamed request to both: Grok returned prompt 227 + completion 189 + reasoning 444 = total 860, and 227 + 189 alone is 416. Opus 5 returned prompt 40 + completion 891 = total 931, with no reasoning field at all.

The portable formula is total_tokens - prompt_tokens for the output side. It is correct on both, and it survives a provider adding a reasoning field later.

out_tokens = usage.total_tokens - usage.prompt_tokens
cost = (usage.prompt_tokens * in_rate + out_tokens * out_rate) / 1e6

Does the Same Prompt Cost the Same Tokens on Both?

No. Opus 5 charges fewer tokens for identical English text.

The 1,130-character prompt metered at 270 tokens on Opus 5 and 381 on Grok 4.6. Grok 4.6 carries a fixed per-request overhead of roughly 206 tokens that is not your text. Subtract it and your 1,130 characters cost about 175 tokens on Grok against 270 on Opus 5, or 6.5 versus 4.2 characters per token.

Two practical consequences:

At a few hundred characters per call, 206 tokens of preamble is most of your input bill on Grok.
Input is the small half here anyway. These runs produced 15-25x more output tokens than input tokens. Tokenizer differences move the total by single-digit percent.

What Do the Benchmarks Actually Say?

Neither model is on the Terminal-Bench 2.1 leaderboard.

A widely circulated summary this month put Opus 5 at 86.7% on Terminal-Bench 2.1. Pulling the official board on 2026-08-20:

Rank	Agent	Model	Accuracy
1	Claude Code	Fable 5	83.8% ± 1.2%
2	Codex	GPT-5.5	83.1% ± 1.1%
3	Terminus 2	Fable 5	80.4% ± 1.2%
4	Cursor CLI	Grok 4.5	79.3% ± 1.5%
5	Claude Code	Opus 4.8	78.9% ± 1.3%

Seventeen entries in total, all verified by a Terminal-Bench team member, most recent dated 2026-07-11. No Opus 5. No Grok 4.6. The top score is 83.8%, so an 86.7% would sit above the top of a board it is not on.

That does not make 86.7% fabricated. Vendors run these suites internally and publish before submitting. It does mean the number is vendor-reported rather than a verified board entry.

The one thing the official board does say about the family is a detail nobody quotes: the Grok 4.5 entry at rank 4 carries a -9.0% hack rate, the largest on the board by a factor of ten, meaning the graders found that share of its passes came from gaming the test. Rank 5, Opus 4.8, is at -0.0%.

What Breaks When You Switch?

Symptom	Cause	Fix
Output stops mid-file at exactly 4,096 tokens	No `max_tokens` set; that is the default	Set it explicitly. Opus 5 allows 128K, Grok 4.6 allows 66K
Bill is ~4x your estimate on Grok	`completion_tokens` excludes `reasoning_tokens`	Use `total_tokens - prompt_tokens`
No reasoning text in the response on Opus 5	Thinking is billed inside `completion_tokens` and not returned in non-streaming responses	Stream if you need it
Prompt over 200K suddenly doubles on Grok	Second price tier applies to the whole request	Keep prompts under 200K or budget for $4/$12

The switch itself is a string change if you are already on an OpenAI-compatible endpoint:

from openai import OpenAI
client = OpenAI(base_url="https://api.ofox.ai/v1", api_key=OFOX_KEY)

def run(model: str, prompt: str) -> tuple[str, float]:
    r = client.chat.completions.create(
        model=model, max_tokens=8000,
        messages=[{"role": "user", "content": prompt}],
    )
    u = r.usage
    rates = {"anthropic/claude-opus-5": (5, 25), "x-ai/grok-4.6": (2, 6)}
    ri, ro = rates[model]
    out = u.total_tokens - u.prompt_tokens        # correct on both APIs
    return r.choices[0].message.content, (u.prompt_tokens * ri + out * ro) / 1e6

Which One Should You Actually Pick?

Split by task, and let output length be the deciding variable rather than the price.

Grok 4.6 for:

Routine agent passes where a shorter, more focused answer is fine: test scaffolding, mechanical refactors, code explanation
Anything with a long cached system prompt, where the absent cache-write charge compounds every session
Batch and offline jobs where 109 seconds versus 59 seconds does not matter to anyone

Opus 5 for:

Passes where completeness is the product: the run that has to enumerate all the error branches, not most of them
Interactive work where a human is waiting. Half the wall-clock on this task
Anything above 500K of context, which Grok 4.6 cannot hold at all

Neither, if: you are picking on a leaderboard number. Neither model is on the board that number came from.

Four runs on one task, summarised honestly: the expensive model is genuinely more thorough, the cheap model is genuinely cheap, and the ratio between those two facts is 2.0x, not 3.6x. Measure your own workload before you commit to either.

Frequently Asked Questions

Is Grok 4.6 cheaper than Claude Opus 5?
Yes, substantially. On list price Grok 4.6 is 26.7% of the combined rate. Measured on the same task, the median bill came out at 28.0% of Opus 5. But Opus 5 returned 1.75x as much code, so per thousand characters of output the gap narrows to 2.0x.

Why is my Grok 4.6 cost estimate too low?
Because completion_tokens does not include reasoning_tokens on Grok, while total_tokens does. The standard formula understates the bill by 78%.

Does Grok 4.6 or Opus 5 answer faster?
Opus 5, on this workload. Median wall-clock was 59.0 seconds for Opus 5 and 109.4 seconds for Grok 4.6 across four runs each.

Does Terminal-Bench 2.1 show Opus 5 ahead of Grok 4.6?
Neither model is on the leaderboard. Any 86-88% figure attributed to this benchmark for either model is vendor-reported, not a verified board entry.

Do both models charge for cache writes?
No. Anthropic charges separately to write a prompt into the cache ($6.25/M for the 5-minute TTL, $10/M for the 1-hour TTL) on top of $0.5/M cache reads. Grok 4.6 lists cache reads at $0.5/M and no write charge.

References

Originally published on ofox.ai/blog.

Pi Coding Agent Custom Provider: Setup, Cost, and 3 Fixes

Owen — Wed, 19 Aug 2026 04:34:57 +0000

Pi Coding Agent Custom Provider: Setup, Cost, and 3 Fixes

Pi ships with 36 API-key providers and six subscription logins already wired up, and there is still a decent chance yours is not among them. Pointing it somewhere else takes one JSON file and about five minutes, which is the easy part. The interesting part is the three things that go wrong afterwards, none of which announce themselves as configuration problems.

Everything below was run on 2026-08-18 against pi 0.84.1 on macOS, with a gateway that serves 131 models over an OpenAI-compatible endpoint.

Config file:        ~/.pi/agent/models.json
Provider fields:    baseUrl, api, apiKey, models[]
Protocols:          openai-completions, openai-responses,
                    anthropic-messages, google-generative-ai
Key from env:       "$OFOX_API_KEY"
Key from keychain:  "!security find-generic-password -ws ofox"
Unlisted model:     runs, with a warning, at 128K context
Cost accounting:    $0.00 until you add a cost block
Reasoning + Claude: 500 until you add supportsDeveloperRole: false
Built-in override:  baseUrl only, stop before /v1
Reload:             automatic, every time /model opens

What Can You Do After This Setup, and What Can't You?

You get every model your gateway sells, in Pi's own loop, billed to one key. You do not get a model list fetched from the gateway, working cost numbers, or any warning when a model quietly runs at an eighth of its real context window.

Works right away:

Any endpoint that speaks OpenAI chat completions, OpenAI Responses, Anthropic Messages or Google Generative AI.
Model switching mid-session through /model, including across providers, because the file is re-read each time the picker opens.
Keys pulled from the environment or from a shell command, so nothing secret has to sit in the JSON.
Thinking levels, image input and tool calling, as long as you declare them per model.

Does not work right away:

No catalogue discovery. Pointed at a local server that logs every request, Pi made four POSTs to /v1/chat/completions per run and not a single GET to /v1/models. What you type is what it knows.
No cost numbers. Token counts are exact, money is zero, until you write the rates yourself.
No protocol sniffing. Override a built-in provider with the wrong base path and the error you get back describes auth, not protocol.

Should You Point Pi at a Gateway or Just Use Its Built-In Providers?

Use the built-ins if you already pay Anthropic, OpenAI or Google directly. Add a custom provider when the model you want is not in that set, or when one key across every tool matters more than per-vendor dashboards.

When a custom provider earns its keep:

You run models that no first-party provider carries, which in practice means most Chinese open-weight flagships and anything hosted rather than official.
You already route Claude Code or Codex CLI through a gateway and want one key and one bill rather than four.
You want to A/B a cheap default against an expensive escalation model without opening a second account for the second model.

When it is not worth the file:

You use one vendor and one plan. /login covers six subscriptions directly, including ChatGPT Plus and Pro, Claude Pro and Max, GitHub Copilot, xAI and OpenRouter, without any of this.
You are on a local runtime. Ollama, vLLM and llama.cpp are the documented cases and need baseUrl plus a model id, nothing else in this post.
You only wanted to change the key on a built-in provider. That is a one-line override, covered near the end.

Stop rule: if pi --list-models already shows the model you intend to run, close this tab. Everything here exists to add models Pi does not know about.

What Do You Need Before You Start?

Node 22 or newer, a key, and a base URL you have already curled once.

Requirement	What we used	Notes
Node.js	24.14.1	Package declares `engines: node >=22.19.0`
Pi	0.84.1 (latest 0.84.2)	`@earendil-works/pi-coding-agent`, MIT
Endpoint	`https://api.ofox.ai/v1`	Must answer `/chat/completions`, not just `/models`
Key	one gateway key	Held in `$OFOX_API_KEY`, never inline
Model ids	exact strings	Gateway ids, not vendor ids

Install, if you have not:

npm install -g @earendil-works/pi-coding-agent
pi --version

One thing worth deciding before you write the file: the provider name you pick becomes part of every --provider flag and every session record. Rename it later and old sessions point at a provider that no longer exists.

How Do You Add a Custom Provider to Pi?

Four fields in one file, then one command to prove it works.

Step 1: Write the provider block

~/.pi/agent/models.json holds everything. The minimum viable entry:

{
  "providers": {
    "ofox": {
      "baseUrl": "https://api.ofox.ai/v1",
      "api": "openai-completions",
      "apiKey": "$OFOX_API_KEY",
      "models": [
        { "id": "deepseek/deepseek-v4-flash", "contextWindow": 1000000, "maxTokens": 384000 }
      ]
    }
  }
}

openai-completions is the one to reach for first. It is the most widely implemented shape, and on our gateway openai-responses also worked for the same model, which is not something you can assume elsewhere.

Step 2: Put the key in the environment, not the file

export OFOX_API_KEY=sk-...

apiKey resolves three ways: a literal string, $VAR or ${VAR} interpolation, and !command, which runs a shell command and uses stdout. The third form is the one to use on a shared machine:

"apiKey": "!security find-generic-password -ws ofox"

Step 3: Confirm Pi sees the models

pi --list-models ofox

provider  model                       context  max-out  thinking  images
ofox      deepseek/deepseek-v4-flash  1M       384K     no        no
ofox      moonshotai/kimi-k3          1M       1M       no        no
ofox      z-ai/glm-5.2                1M       128K     yes       no

Those columns come from your file, not from the gateway. Delete contextWindow and maxTokens from an entry and the same command prints 128K and 16.4K for it, which are Pi's documented defaults. If thinking says no on a model that reasons, that is your declaration missing, not the endpoint refusing.

Step 4: Run something that touches the disk

Print mode is the fastest proof, because it exercises the tool loop rather than just the completion endpoint:

pi --provider ofox --model deepseek/deepseek-v4-flash -p \
  "Read buggy.py, run it, and state the one-line bug. Do not edit files."

In a scratch directory holding a two-line file with return a - b in an add function, DeepSeek V4 Flash read the file, ran the interpreter through the bash tool, and answered correctly on the first try. That is the whole integration test: file read, shell execution, answer.

Does `openai-responses` Work Too?

On our gateway, yes, for the same model, with the protocol name as the only change. Swapping "api": "openai-completions" for "api": "openai-responses" and re-running the same prompt returned the same answer.

Do not generalise that. Responses support is decided per model by whoever hosts it, not per gateway, so an endpoint that answers /v1/responses for one model can have no Responses route at all for the next one. openai-completions is the shape with the widest coverage, and there is no advantage to picking anything else unless a specific model needs it. Codex CLI is the tool that forces the question, because it speaks Responses and nothing else.

Why Does `pi auth check` Say Ready With a Key That Does Not Work?

Because it checks that a key is present, not that it is valid. We pointed the provider at a deliberately invalid key and asked:

pi auth check --provider ofox
# ready

The same config, one request later:

401: {"message":"Invalid or expired API key","type":"invalid_api_key","code":401}

ready means Pi resolved something into the apiKey slot. Treat it as a spelling check on your environment variable and nothing more. The real readiness test is Step 4.

Why Does Pi Report $0 for Every Session?

Because a custom provider has no price list, and Pi will not invent one. Token accounting is exact. Here is the usage record Pi wrote for the two turns of that first run, straight from the session file under ~/.pi/agent/sessions/:

Turn	input	output	cacheRead	reasoning	total	cost
1	2,840	122	0	12	2,962	$0.00
2	52	56	2,944	0	3,052	$0.00

Two things in that table are worth separating. The cacheRead figure is real: the gateway returned prompt_tokens_details.cached_tokens on the second call, and Pi recorded it. The cost column is not real, it is absent. Every field under cost sits at zero because the model entry never declared rates.

Add them and the arithmetic starts working:

{
  "id": "anthropic/claude-sonnet-5",
  "contextWindow": 1000000,
  "maxTokens": 128000,
  "cost": { "input": 2, "output": 10, "cacheRead": 0.2, "cacheWrite": 2.5 }
}

Rates are per million tokens, taken from the provider's own pricing page rather than from the vendor's. The next run against Claude Sonnet 5 recorded 4,111 input and 4 output tokens and priced them at $0.008222 plus $0.00004, total $0.008262, which is those counts multiplied by $2 and $10 per million. Pi does that arithmetic locally, so the number is only as honest as the rates you typed. Type the gateway's rates, not the model maker's, and re-check them when the page changes.

The same applies to contextWindow. Sonnet 5 is a 1M-context model on this gateway, and the entry has to say so, otherwise the 128K default quietly takes over.

Why Does a Model Fail With "unsupported message role: developer"?

Because reasoning: true makes Pi send the system prompt as a developer role message, and not every upstream accepts that role. The failure is loud and looks like a server fault:

500: {"code":null,"message":"Request error: failed to convert messages:
unsupported message role: developer","param":null,"type":"api_error"}

Nothing in that string points at your config, which is why it is worth isolating properly. Three runs, same gateway, same model, one field at a time:

Model entry	Result
`reasoning: true`	500, `unsupported message role: developer`
`reasoning: true` plus `compat: { supportsDeveloperRole: false }`	Works
`reasoning: false`	Works

So the trigger is the developer role, and there are two fixes with different costs. Running the same three configs against a local server that logs request bodies shows exactly what changes:

Model entry	`messages[].role`	`reasoning_effort` sent
`reasoning: true`	`["developer", "user"]`	`"medium"`
plus `supportsDeveloperRole: false`	`["system", "user"]`	`"medium"`
`reasoning: false`	`["system", "user"]`	absent

The compat switch moves the system prompt to a system message and leaves reasoning_effort in place, so thinking survives. Setting reasoning: false also clears the error, by dropping reasoning_effort from the request entirely, which is usually the wrong trade.

The same capture answers a question people ask about maxTokensField: on openai-completions Pi sends max_completion_tokens, not max_tokens. If your endpoint only understands the older field, that is the switch to flip.

The role is only rejected on part of the catalogue. Same gateway, same reasoning: true, three model families:

Model	`reasoning: true` result
DeepSeek V4 Flash	Works
GLM 5.2	Works
Claude Sonnet 5	500 until `supportsDeveloperRole: false`

The pattern is upstream shape, not gateway policy. Anthropic's API has no developer role, so a gateway translating OpenAI-shaped requests into Messages has nothing to map it to. OpenAI-shaped upstreams take it and move on. This is the same class of problem as Codex CLI emitting an empty tool description that some upstreams validate and others ignore, which we hit while testing nine harnesses against one gateway. The lesson repeats: when a client and an endpoint disagree, read the body before you change settings.

Pi's docs list two more switches in the same family, supportsReasoningEffort for servers that reject reasoning parameters and maxTokensField for servers that want max_completion_tokens instead of max_tokens. If a model 400s the moment thinking is enabled, those are the next two to try.

Do You Have to List Every Model?

No, and on a gateway with 131 of them you should not try. An id Pi has never seen still runs:

pi --provider ofox --model z-ai/glm-5.2 -p "say ok"
# Warning: Model "z-ai/glm-5.2" not found for provider "ofox". Using custom model id.
# ok

That fallback is the difference between a five-line config and a five-hundred-line one. It also hides a cost. An unlisted model inherits Pi's defaults, documented as 128,000 context and 16,384 max output, and pi --list-models prints exactly those two figures for any entry that omits them. Auto-compaction then fires at contextTokens > contextWindow - reserveTokens, with reserveTokens defaulting to 16,384, so a 1M-context model summarises itself somewhere around 111,600 tokens instead of near a million. Nothing in the output says why. People do report compaction arriving sooner than expected in the project's community; this is at least one mechanism that produces it, and it is cheap to rule out before blaming the model.

The practical split: let unlisted ids cover exploration, then write a real entry for the two or three models you run daily, with contextWindow, maxTokens, reasoning, input and cost filled in. Everything Pi displays about a model, including whether it will accept an image, comes from that entry rather than from the endpoint.

Can You Point Pi's Built-In Anthropic Provider at a Gateway?

Yes, and it is the better route for Claude models, as long as you give it the Anthropic base path rather than the OpenAI one. The override is one line and no model list of your own:

{ "providers": { "anthropic": { "baseUrl": "https://api.ofox.ai/anthropic", "apiKey": "$OFOX_API_KEY" } } }

pi --provider anthropic --model claude-sonnet-5 -p "Reply with exactly: ok"
# ok

Pi keeps its entire built-in Claude catalogue, with the windows already correct, Claude Fable 5 at 1M and the Opus and Haiku entries at 200K. Nothing to declare, nothing to keep in sync, and no developer role in sight because Messages is the native shape here. The vendor id works as-is, no gateway prefix.

Getting the base URL wrong produces two errors that both describe the wrong problem. Point it at the OpenAI path:

401 {"error":{"message":"You didn't provide an API key. You need to provide your API key
in an Authorization header using Bearer auth ...","type":"invalid_request_error","code":401}}

There is no auth bug there. Pi is speaking Messages, so it sends x-api-key, and the OpenAI path only accepts Authorization: Bearer. Add a Bearer header through the provider's headers field and the honest answer appears: 404 Unsupported OpenAI API endpoint. The 401 was a protocol mismatch wearing an auth costume.

The other way to get it wrong is doubling the version segment:

404 {"error":{"message":"Unsupported Anthropic API endpoint. ...","code":404}}

That is .../anthropic/v1 in the config. Pi appends /v1/messages itself, so the base URL stops at /anthropic.

`baseUrl`	Result
`https://api.ofox.ai/anthropic`	Works, full built-in Claude catalogue
`https://api.ofox.ai/anthropic/v1`	404, `Unsupported Anthropic API endpoint`
`https://api.ofox.ai/v1`	401 that is really a 404 on the wrong protocol

So Claude has two routes through the same key: the built-in override above, or a custom openai-completions entry with the gateway's own ids, which is what the cost example used. The override is less typing and avoids the developer role entirely. The custom entry is the one to use when you want per-model cost and contextWindow values Pi does not already know.

Should You Run Claude Models in Pi at All?

They work, and Pi's own author has documented a schema problem on the newest ones. Writing on 2026-07-04, Armin Ronacher reported that "newer Claude models sometimes call Pi's edit tool with extra, invented fields in the nested edits[] array", with the result that "the model invents made-up keys and Pi thus rejects the tool call and asks to try again". His summary of the trend is the uncomfortable part: "this is getting worse with newer Anthropic models as both Opus 4.8 and Sonnet 5 show it but none of the older models."

That is a training-and-tooling mismatch, not something a base URL can fix, and it costs a retry each time it fires. It does not make Claude unusable in Pi. It does mean that if you are picking a default model for a harness whose edit tool is its own, the newest Claude is not automatically the safest choice, and it is worth watching your session log for repeated tool calls on the same edit.

How Do You See What Pi Actually Sends?

Reproduce the call with curl, then compare it to what Pi recorded. Two files and one command cover most of what you need, and neither requires a proxy.

The session log is the first stop. Every run writes a JSON Lines file under ~/.pi/agent/sessions/<project>/, one record per event, including a model_change line naming the provider and model id Pi resolved and an assistant message carrying the usage block. If the model id in that file is not the one you meant to run, the problem is your flag or your fallback, and no amount of provider tuning will fix it.

The endpoint is the second. Send the same shape yourself:

curl -s https://api.ofox.ai/v1/chat/completions \
  -H "Authorization: Bearer $OFOX_API_KEY" -H 'Content-Type: application/json' \
  -d '{"model":"deepseek/deepseek-v4-flash","messages":[{"role":"user","content":"hi"}],"max_tokens":8}' \
  | python3 -c 'import sys,json; print(json.load(sys.stdin)["usage"])'

Two things in usage are worth reading closely. prompt_tokens_details.cached_tokens is what Pi maps to its cacheRead column, so if that key never appears, the cache figures in your session log will stay at zero no matter how stable your prefix is. And completion_tokens_details.reasoning_tokens tells you whether thinking is actually running, which is a faster check than reading output and guessing.

Doing this before you edit config is the whole lesson from every harness integration we have written up. An error string is written by whoever raised it, and that is frequently not the component that is wrong.

What Breaks During Setup, and How Do You Fix It?

Six failures, five of them reproduced against a live endpoint on 0.84.1, and one demonstrated with Pi's own model table.

Symptom	Cause	Fix
`401: {"message":"Invalid or expired API key"...}`	Key resolved but wrong, or the variable is empty in this shell	`echo $OFOX_API_KEY` before blaming the file; `pi auth check` will not catch this
`404 404 page not found`	`baseUrl` missing the version segment	Use `https://host/v1`, not `https://host`
`500 ... unsupported message role: developer`	`reasoning: true` on a model whose upstream has no `developer` role	Add `compat: { supportsDeveloperRole: false }`
`401 ... provide your API key ... using Bearer auth` on the `anthropic` provider	Built-in override pointed at the OpenAI path, so Pi sends `x-api-key` where only Bearer is accepted	Use the gateway's Anthropic base path, ending at `/anthropic`
`404: {"message":"Model 'openai/gpt-5.6' not found","type":"model_not_found"}`	The id is well formed but not in this gateway's catalogue	Read the id off the gateway's own model page; a vendor announcing a model does not put it in every catalogue
Session compacts far earlier than the model's real window	Unlisted model fell back to the 128K default	Declare `contextWindow` and `maxTokens` for that model

The fourth and fifth rows are the ones that cost the most time, because both error messages describe something other than the actual problem.

How Do Teams Share a Pi Provider Config?

Share the file, never the key. models.json holds no secret when every apiKey is a $VAR or a !command, which makes it safe to commit into a dotfiles repo or a bootstrap script.

A split that survives contact with more than one developer:

Commit the provider block: base URL, protocol, and full model entries with contextWindow, maxTokens, reasoning and cost. These are facts about the endpoint, identical for everyone, and getting them wrong is what produces silent early compaction and fake $0 bills.
Never commit the key. "apiKey": "$OFOX_API_KEY" in the shared file, real value in each developer's shell profile or keychain.
Pin the version you validated. Pi ships roughly weekly, 0.82.1 through 0.84.2 in under a month. Record the version your config was tested against.
Give everyone the same base URL. One endpoint means one model catalogue, one rate limit pool and one place to see spend, instead of a per-developer guess.

That last point is the one teams skip, and it is the one that turns "which model are you on?" from a question into a lookup.

How Do You Point Every Harness at the Same Key?

Every harness stores model access in its own dialect. Claude Code reads ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN. Codex CLI wants a model_providers block in config.toml and refuses anything that is not the Responses API. Cline has a settings pane. DeepSeek Harness wants a custom provider form or DEEPSEEK_BASE_URL. Pi wants the JSON file above. Five tools, five places to rotate a key, five model lists drifting apart.

They all speak HTTP against an OpenAI-compatible or Anthropic-compatible endpoint, so the fix is identical in each: one base URL, one key, and the model string as the only thing that changes. That is the entire reason the custom-provider form in every one of these tools has the same four fields.

On ofox that endpoint is https://api.ofox.ai/v1 with openai-completions, and one key reached 131 models on 2026-08-18, including Kimi K3 and MiniMax M3 alongside the DeepSeek, GLM and Claude entries used above. The equivalent setup for the other tools is in our Codex CLI custom provider guide, the OpenCode configuration walkthrough, and the Cursor, Claude Code and Cline setup.

How Does Pi Compare to the Harness You Already Run?

Same job, much smaller surface, and a config file that is honest about how little it assumes. Pi gives the model four tools and an extension API, where Claude Code gives it hooks, subagents, skills and MCP servers out of the box. Neither is better in the abstract. The question is whether you want assembly or assembly required.

What the custom-provider path shows is where that minimalism has a price. No catalogue fetch, no pricing table, no protocol sniffing. Every one of the three problems in this post is Pi declining to guess something on your behalf, and every fix is you writing the fact down once.

For where Pi sits against the rest of the field, including the OpenRouter usage data on which models people actually run inside each harness, see the nine-harness roundup. For the terminal agents specifically, Claude Code vs Codex CLI vs Cursor covers the trade in more depth.

References

Frequently Asked Questions

What is the Pi coding agent?

A terminal coding agent from Armin Ronacher and Mario Zechner, MIT licensed, now developed under Earendil at github.com/earendil-works/pi. It gives the model four built-in tools (read, write, edit, bash) and ships almost nothing else, exposing an extension API instead of hooks, subagents and skills. As of 2026-08-18 the repository has 92,619 stars and the npm package pulls 1.37 million downloads a week.

Which npm package installs Pi?

@earendil-works/pi-coding-agent, currently 0.84.2, engines node >=22.19.0. The older @mariozechner/pi package stops at 0.70.6 and gets a few hundred downloads a week; it is the pre-acquisition channel and installing it gets you a version from before the move to Earendil.

Does Pi support third-party API endpoints?

Yes, through ~/.pi/agent/models.json. A provider entry takes baseUrl, api, apiKey and a models array, where api is one of openai-completions, openai-responses, anthropic-messages or google-generative-ai. No code changes and no fork are required, and the file reloads every time the /model picker opens.

Can Pi read an API key from an environment variable?

Yes. apiKey accepts $VAR and ${VAR} interpolation, and it also accepts !command, which runs a shell command and takes stdout as the key. That second form is how you read from a system keychain instead of leaving a secret in a JSON file. Use $$ for a literal dollar sign.

Does Pi need every model listed in models.json?

No. Passing a model id that is not in the list prints Warning: Model not found for provider, then runs it as a custom model id. The catch is that an unlisted model inherits the defaults, 128,000 context and 16,384 max output, so a 1M-context model will compact far earlier than it needs to.

Why does Pi show $0 cost for every request?

Because a custom provider carries no pricing metadata. Token counts are recorded correctly in the session file, but every field under cost stays at zero until you add a cost block to the model entry with input, output, cacheRead and cacheWrite rates per million tokens.

Can Pi point its built-in Anthropic provider at a gateway?

Yes, if you give it the gateway's Anthropic Messages base path rather than its OpenAI one. Overriding baseUrl on the built-in anthropic provider keeps Pi's whole Claude catalogue with correct context windows and needs no models array. Stop the URL before the version segment, because Pi appends /v1/messages itself, and pointing it at the OpenAI path returns a 401 that is really a protocol mismatch.

What does unsupported message role: developer mean in Pi?

It means the model entry has reasoning set to true, so Pi sends the system prompt as a developer role message, and something upstream refuses that role. Add compat with supportsDeveloperRole set to false to keep thinking, or set reasoning to false to drop it. On an OpenAI-shaped gateway this shows up only on Anthropic-family models.

Originally published on ofox.ai/blog.

DeepSeek Harness (dsh): Version, Updates, Stability (2026)

Owen — Wed, 19 Aug 2026 01:10:28 +0000

DeepSeek Harness (dsh): Version, Updates, Stability (2026)

DeepSeek Harness remains at version 0.1.0-rc.6, its launch build from August 13, 2026. The public repository has received no commits since that date, with no releases, tags, or active issue tracking. Pin your version before building anything with this tool.

Current Status Summary

The tool launched with six published versions between August 10-13, 2026, all available on npm under both latest and next dist-tags. The only branch in the repository is master, and discussions have grown to 2,713+ threads while the codebase remains static since launch.

Key facts:

Current version: 0.1.0-rc.6 (August 13, 2026 12:35 UTC)
Total versions published: 6
Last public commit: August 13, 2026 11:38 UTC
Releases/tags: 0 / 0
License: MIT
Official status: Developer preview with promised breaking changes
Entry point: npx @deepseek-ai/dsh web on 127.0.0.1:3080

Version History

Version	Published (UTC)
0.0.1-rc.1	2026-08-10 19:41
0.0.1-rc.2	2026-08-11 15:24
0.0.1-rc.5	2026-08-12 22:36
0.1.0-rc.2	2026-08-13 09:48
0.1.0-rc.3	2026-08-13 11:16
0.1.0-rc.6	2026-08-13 12:35

Every release predates or matches the public launch date.

Checking Status Independently

Three commands verify current state without requiring a GitHub account:

npm view @deepseek-ai/dsh dist-tags versions time

curl -s https://api.github.com/repos/deepseek-ai/deepseek-harness \
  | jq '{pushed_at, has_issues, open_issues_count}'

curl -s https://api.github.com/repos/deepseek-ai/deepseek-harness/releases
curl -s https://api.github.com/repos/deepseek-ai/deepseek-harness/tags

As of August 17, these commands show no movement since the initial publication.

Production Readiness

The project explicitly states it remains "in developer preview and is iterating rapidly. THERE WILL BE COMPATIBILITY-BREAKING CHANGES." This is not merely marketing language — structural choices reinforce it.

The repository disables issues entirely, routing all communication through Discussions and Discord. That works for signal gathering but provides no mechanism for tracking a regression you filed. The plugin architecture, built on Cordis, means breaking changes upstream can land in a surface you did not know you depended on.

The Paradox of Transparency and Opacity

The repository was created August 13 but arrived with complete history: 12,293 commits reaching back to June 10, 2026. The first commit reads "Initialize repo with README, AGENTS.md, and CLAUDE.md symlink." That is two months of visible development history.

What stayed private is the surrounding process. Merge commits reference pull requests (#2519, #2520, #2521) in a separate, non-public deepseek-harness organization. No branches exist beyond master, and nothing has shipped since launch day.

This creates an unusual situation: the code's development path is transparent while its future direction is opaque. "Iterating rapidly" is likely accurate but unobservable from outside. For consumers, that means you cannot distinguish "quiet because stable" from "quiet because actively developing."

Community Size and Patterns

GitHub Discussions grew from roughly 620 threads three days earlier to 2,713 by August 17. Common themes:

Theme	Requests	Implication
Native client instead of browser	Real CLI, desktop app, editor extensions	Web-UI-first design is the most contested choice
Install failures	Windows, Arch Linux, Termux reports	Non-macOS platforms are unverified
Third-party plugins	Marketplaces, knowledge bases, UI skins	Ecosystem outrunning core
Cost visibility	Per-turn tokens, peak-hour indicators	Shipped build lacks this
Sandbox and permissions	Multiple independent reports	Preview disclaimer applies

The ecosystem is expanding faster than the core, which carries a consequence: when plugins ship faster than the foundation they depend on, plugins are the first casualty when breaking changes arrive.

Cost Transparency Gap

The shipped build provides no per-turn token count or cost display. A highly upvoted Ideas thread filed August 14 requests exactly this. A community cost-tracker plugin appeared on launch day to fill the gap.

The timing matters. DeepSeek shifted its entire V4 family to peak and off-peak pricing on August 16, 2026. Cache hits on deepseek/deepseek-v4-pro increased 12.1x at peak; deepseek/deepseek-v4-flash rose 5x. An agent harness that resends identical system prompts and file contents every turn is precisely the workload that pricing change targets.

Until the harness surfaces cost data, you consult provider dashboards, proxy logs, or community plugins. None ship with dsh.

When dsh Is Safe to Use

The practical distinction is what breaks when the next version appears:

Safe to explore:

Evaluating the plugin model on scratch repositories
Comparing DeepSeek models against your own tasks
Building or testing dsh-plugin projects
Local experiments you can redo in an afternoon

Hold off on:

Anything with a delivery date attached
Shared team configurations others will inherit
CI or unattended scheduled jobs
Work where an unexpected sandbox change would be costly

The dividing line is whether an upgrade that breaks your setup costs you an afternoon or a deadline. DeepSeek has told you in capital letters which it is planning.

Recommended Setup Approach

Before integrating dsh into production workflows:

Pin the version: Use npx @deepseek-ai/dsh@0.1.0-rc.6 exclusively, never bare dsh
Control the endpoint: Configure DEEPSEEK_BASE_URL and DEEPSEEK_API_KEY pointing to a base URL you manage, not a hardcoded vendor default
Maintain a backup harness: Keep a second working harness for deadline-critical work
Monitor npm, not GitHub: The next version appears on npm first
Review release notes: Reread the README after any upgrade, since breaking changes are announced there and nowhere else

Point 2 carries particular weight. dsh reads environment variables for its built-in route, and the custom-provider form accepts any OpenAI-compatible endpoint. That swappability only works if you configure it from the start. On ofox, that means deepseek/deepseek-v4-flash and deepseek/deepseek-v4-pro behind a single key, so on the day dsh breaks or pricing moves again, the model string is the only thing you edit.

Frequently Asked Questions

What is the current version?
0.1.0-rc.6, published August 13, 2026. Both npm's latest and next tags point to it.

Are there GitHub releases or tags?
No. Zero releases and zero tags exist. Version history lives entirely on npm.

Why are issues disabled?
The maintainers route all communication through GitHub Discussions and Discord instead, eliminating formal issue tracking.

Is dsh a fork?
Neither fork nor mirror. The repository was created August 13 with full commit history from June 10, but the surrounding development process remains private.

Does it run on Windows or Linux?
It ships as a Node package, so it starts anywhere Node runs. However, community reports of install failures on Windows, Arch Linux, and Termux are frequent enough to treat non-macOS platforms as unverified.

Can I pin to a known-good version?
Yes: npx @deepseek-ai/dsh@0.1.0-rc.6. Because no upstream tags exist, the npm version string is your only safeguard against promised breaking changes.

Is dsh free?
The harness itself is MIT licensed and free. Inference costs depend on your provider's rates. DeepSeek's pricing moved to a peak/off-peak structure on August 16, 2026.

Key References

Originally published on ofox.ai/blog.

DeepSeek API Price Increase: Up to 12x, Peak Hours (2026)

Owen — Tue, 18 Aug 2026 13:42:02 +0000

DeepSeek API Price Increase: Up to 12x, Peak Hours (2026)

DeepSeek implemented significant API pricing changes effective August 16, 2026 at 16:00 UTC, introducing a peak/off-peak billing model replacing previous flat rates. The most dramatic increase affected V4 Pro cache hits, which jumped 12.1x at peak ($0.003625 to $0.044 per million tokens).

Key Changes

Effective Date: 2026-08-16, 16:00 UTC (2026-08-17, 00:00 Beijing time)

Peak Hours (7 hours daily): 01:00–04:00 and 06:00–10:00 UTC

Billing Model: Off-peak rates are 50% of peak rates across all tiers

Pricing Comparison Table

Tier	Old Flat	New Off-peak	New Peak
V4 Flash cache hit	$0.0028	$0.007	$0.014
V4 Flash cache miss	$0.14	$0.22	$0.44
V4 Flash output	$0.28	$0.66	$1.32
V4 Pro cache hit	$0.003625	$0.022	$0.044
V4 Pro cache miss	$0.435	$0.66	$1.32
V4 Pro output	$0.87	$1.98	$3.96

Price Increase Multipliers

Tier	Off-peak vs Old	Peak vs Old
V4 Flash cache hit	2.5x	5.0x
V4 Flash cache miss	1.6x	3.1x
V4 Flash output	2.4x	4.7x
V4 Pro cache hit	6.1x	12.1x
V4 Pro cache miss	1.5x	3.0x
V4 Pro output	2.3x	4.6x

Real-World Impact: Sample Monthly Bill

For a typical agent workload (300M input tokens at 90% cache hit rate, 20M output):

Scenario	Cache Hits	Cache Misses	Output	Total
Old flat rate	$0.76	$4.20	$5.60	$10.56
New, all off-peak	$1.89	$6.60	$13.20	$21.69
New, all peak	$3.78	$13.20	$26.40	$43.38

Peak Hours by Time Zone (Aug 2026)

Location	Peak Window 1	Peak Window 2	Workday Impact
Beijing/Singapore (UTC+8)	09:00–12:00	14:00–18:00	7 of 9 hours
Tokyo/Seoul (UTC+9)	10:00–13:00	15:00–19:00	6 of 9 hours
India (UTC+5:30)	06:30–09:30	11:30–15:30	4.5 of 9 hours
Berlin/Paris (UTC+2, CEST)	03:00–06:00	08:00–12:00	3 of 9 hours
London (UTC+1, BST)	02:00–05:00	07:00–11:00	2 of 9 hours
New York (UTC-4, EDT)	21:00–00:00 prev	02:00–06:00	0 of 9 hours
San Francisco (UTC-7, PDT)	18:00–21:00 prev	23:00–03:00	0 of 9 hours

Third-Party Hosts Comparison

V4 Flash (on OpenRouter, 2026-08-17)

Host	Input	Output	Cache Read
DeepInfra	$0.08	$0.18	$0.016
DigitalOcean	$0.08	$0.252	$0.0252
GMICloud	$0.084	$0.168	$0.0168
DeepSeek	$0.44	$1.32	$0.014

Finding: 26 of 28 third-party listings undercut DeepSeek's peak input rate.

Break-even analysis: At 94% cache hit rate off-peak, DeepInfra becomes cheaper; at 99.4% peak. Previously, this threshold was 77%.

V4 Pro

DeepSeek's off-peak rate ($0.66 input) undercuts all nine available third-party listings.

Historical Context

DeepSeek has adjusted pricing three times in eighteen months:

Date	Change	Direction
2025-02-26	Off-peak discounts introduced (16:30–00:30 UTC)	Down
2025-09-05	New pricing, off-peak discounts ended	Up
2026-08-16	Peak/off-peak billing (off-peak = 50% of peak)	Up

This represents the first instance where time-of-day pricing increased rates rather than offered discounts.

Why Cache Hits Increased Most

The previous cache hit rate was an outlier: V4 Flash hits at $0.0028 were 50x cheaper than a miss. That disproportionate pricing supported the cost model for agent loops with 90%+ cache hit rates. The new structure reflects market realignment, where caching remains valuable but no longer dominates billing.

Caching Still Viable?

Yes. A cache hit remains approximately 31x cheaper than a miss at peak ($0.014 vs $0.44 for Flash). However, this advantage narrowed from the previous 50x ratio. Output tokens now represent a larger portion of total costs.

Key Considerations

Timestamp Ambiguity: DeepSeek has not clarified whether requests billing during peak windows are determined by start time or completion time. Requests crossing 04:00 or 10:00 UTC boundaries represent an open question.

Off-Peak as Partial Relief: Off-peak rates represent a smaller increase, not a true discount. Even at off-peak, V4 Flash output costs $0.66 (2.4x the old flat $0.28).

No Grandfather Clause: Existing balances top up at new rates; no legacy pricing applies.

Gateway Strategy: Using an OpenAI-compatible API aggregator allows switching between providers via model string changes alone, avoiding lock-in to any single vendor's pricing schedule.

Frequently Asked Questions

Does the increase differ between V4 Flash and V4 Pro?

Yes substantially. Cache hit increases ranged from 5x (Flash) to 12.1x (Pro) at peak.

How does billing handle requests crossing peak boundaries?

Unknown. DeepSeek's documentation omits this; measure actual invoices for verification.

Are third-party hosts now cheaper?

For V4 Flash: nearly uniformly yes (26 of 28 endpoints). For V4 Pro: no — DeepSeek undercuts all current alternatives even at off-peak rates.

Is prompt caching still worthwhile?

Absolutely, though with diminished leverage. The economics shifted toward output token optimization.

Did previous balances retain old rates?

No documented grandfather provision exists. All consumption applies current pricing.

Originally published on ofox.ai/blog.