DEV Community: Yong Yu

Inkling 2 Small on Tinker Today: 594B/17B MoE, AA Index 31, Apache Weights Next Week

Yong Yu — Fri, 06 Nov 2026 14:41:26 +0000

Attributed compile + offline HTTP preflight on my box

Primary source: Introducing Inkling 2 Small (Nov 5, 2026) + Inkling 2 Small model card by Thinking Machines Lab.

Access / pricing: Tinker Pricing (page stamp â€œas of October 19, 2026â€); Tinker models & pricing docs (model id thinkingmachines/Inkling-2-Small); Tinker Playground (redirects to auth â€” no login on this box); tinker-cookbook.

Release policy: A Safe Path to Open Weights (Jul 31, 2026).

Independent index scrape: Artificial Analysis â€” Inkling 2 Small (intelligenceIndex â‰ˆ 30.63, isOpenWeights: false in our HTML/JSON scrape).

Secondary only: The Decoder (AA 31 vs predecessor Inkling Small 13); MarkTechPost URL intermittently Cloudflare-challenged â€” unused for numbers. Local copies: /workspace/reputation/runs/36-inkling-2-small/.

Numbers below from the announcement, model card, Tinker pricing/docs, or AA scrape are vendor / dashboard unless marked otherwise. This box did not authenticate to Tinker, call sampling/fine-tune APIs, or download weights. Offline preflight = public HTTP scrapes only.

Thinking Machines Labâ€™s second generation landed on 2026-11-05 as Inkling 2 Small: a multimodal MoE you can poke on Tinker today, with closed weights at launch and a company line that full Apache 2.0 weights should follow next week after external safety testing and red-teaming. For builders who care about agent loops, fine-tune surfaces, and â€œwhen do I self-host?â€, that is a sharper decision than another Daybreak-gated cyber demo. The useful checklist is: what actually shipped, how you reach it on Tinker (and what it costs), what the Apache cliff is promising vs guaranteeing, how to read the short vendor/AA score map, and when to wait for downloadable weights instead of burning playground tokens.

What shipped (card + announcement)

Label these as vendor card / announcement:

Field	Value
Architecture	Sparse MoE decoder â€” 594B total / 17B active
Routing (card)	48 layers; each token â†’ 8 of 384 experts; hybrid local + global attention
Modalities	Text + image in â†’ text out (no audio on this model)
Vision	292M encoder (Perception Encoder lineage); 20Ã—20 patches + 2Ã—2 pooling
Context	Up to 1M tokens (card); Tinker priced rows today emphasize 64K and 256K
Effort	Variable effort (RL conditioned on effort + length penalty)
Numerics (card)	MXFP8 and NVFP4
License at launch	Tinker Terms of Use (closed weights)
Intended Apache drop	Full weights under Apache 2.0 â€” company intent â€œnext weekâ€ after external safety / red-team (not a drop we verified)

Training color from the announcement (still vendor narrative, not our run): long pretrain on GB300 NVL72 in native NVFP4, then a single joint RL run (~1,075 steps, 17M+ rollouts, 2,048 GPUs, 9 days) mixing coding, knowledge work, vision, tool use, and safety. Early coding checkpoints were tested on OpenCode under the name Fledge-Alpha â€” useful signal that the lab optimized for real agent harnesses, not only unit-test rewards.

Access matrix (what this box actually opened)

Route	Preflight	Note
Announcement + model card	HTTP 200	Params, benches, limitations
Tinker Pricing + models docs	HTTP 200	$/M + model ids
Tinker Playground URL	302 â†’ auth	No session / no chat on this box
Safe-path blog	HTTP 200	Staged open-weights policy
Artificial Analysis model page	HTTP 200 (retry)	Independent index ~30.63; still not open-weights
OpenRouter `/api/v1/models`	HTTP 200	`thinkingmachines/inkling` + `inkling-small` listed; no Inkling 2 Small id yet
MarkTechPost	Cloudflare challenge / flaky	Unused for numbers

Practical pin strings from Tinker docs (as scraped):

thinkingmachines/Inkling-2-Small
thinkingmachines/Inkling-2-Small:peft:262144   # 256K context row

Cookbook path named on the card: thinking-machines-lab/tinker-cookbook plus the tml-renderers package for render-related workflows. Checkpoints from Tinker fine-tunes are described as downloadable when the base weights ship.

Tinker economics (hosted now)

Prefer the pricing page + docs over aggregators. Training & sampling table (USD per 1M tokens, page dated October 19, 2026):

Context row	Prefill	Cached prefill	Sample	Train
Inkling 2 Small 64K	$0.30	$0.03	$1.00	$1.50
Inkling 2 Small 256K	$0.30	$0.03	$1.00	$3.00

Serverless inference beta (same page; Inkling family only): Inkling 2 Small 256K at $0.30 input / $0.03 cached input / $1.00 output per 1M tokens. Storage: $0.10 / GB / month for checkpoints. MoE note on the page: priced by active parameters, not total size â€” which is why a 594B/17B active model can sit near the Inkling-Small dollar band on sample rates.

For agent loops, cached prefill at $0.03 vs $0.30 is the real budget knob once you keep long tool transcripts warm. We did not measure cache hit rates or tok/s here.

The Apache cliff (intent, not a receipt)

Announcement wording, paraphrased: Inkling 2 Small starts on Tinker with closed weights, following the labâ€™s safe path to open weights staging story (API / hosted fine-tune before irreversible public weights). They intend to release full weights under Apache 2.0 next week after external safety testing and red-teaming.

Treat that as company intent dated Nov 5, not a calendar we verified. Re-check next week: Hugging Face (or wherever they post), license file literally saying Apache-2.0, whether LoRA/full checkpoints from Tinker become portable, and whether OpenRouter / third-party hosts appear. Until then, â€œopen-weights MoEâ€ headlines are premature â€” AAâ€™s scrape still had isOpenWeights: false / proprietary categorization on 2026-11-06.

Short score map (vendor + AA â€” not our eval)

Announcement prose claims an Artificial Analysis Intelligence Index score of 31 (vs prior Inkling models). The same postâ€™s comparison matrix lists AA Index (v5.0) = 30.6. Our AA.com scrape for inkling-2-small showed intelligenceIndex â‰ˆ 30.63. The Decoder (secondary) frames that as 31 vs Inkling Small 13 â€” cite only as aggregator color; we did not independently resolve the predecessorâ€™s AA page in this preflight.

Tiny coding slice from the vendor announcement table (effort 0.99 / temperature 1.0 / 1M trajectory limit â€” their harness, not ours):

Bench (vendor-reported)	Inkling 2 Small	DeepSeek-V4.1-Flash-1017	Kimi K3
FrontierCode v2.0	25.4%	28.5%	17.3%
DeepSWE v1.1	72.1%	77.0%	68.5%
SWEBench Pro v2 (Hard)	86.3%	â€“	88.2%
Vibe Code Bench v1.1	81.6%	87.7%	85.0%

Do not treat that matrix as a certificate. Use it to shortlist tasks for your golden eval once playground or API access is real. We invent no independent coding scores and we did not re-run any row.

Limitations they state (read before you demos)

Vendor limitations section, compressed: still not the most succinct communicator; can pick suboptimal tools in skill-heavy repos; no audio; chat UX is weaker (organization/presentation, slash overuse); can overreact on mental-health / safety-adjacent queries. Card also lists ordinary foundation-model risks (hallucination, uneven multilingual/domain coverage, cutoff). If your product is a polished consumer chat, assume extra formatting and refusal tuning work â€” even when coding-agent demos look strong.

Builder decision: Tinker now vs wait for Apache

Try Tinker now if you need agentic coding / vision-in-the-loop prototypes this week, want LoRA / custom RL on their stack before weights exist elsewhere, or youâ€™re validating whether Fledge-Alpha-class behavior helps your OpenCode / harness loop. Pin thinkingmachines/Inkling-2-Small (or the :peft:262144 256K id), keep effort explicit, and budget cached-prefill math on long rollouts.

Wait for Apache weights if you need air-gap, weight-level inspection, non-Tinker serving, or license certainty before a production bet. â€œNext weekâ€ is the intent; verify the artifact + Apache text before you plan a cluster. Self-host hardware for a 594B MoE (even at 17B active) will still be a data-center story â€” this preflight did not find a consumer GGUF path because weights are not public yet.

Skip theater if you only wanted OpenRouter one-liner access today: our models API snapshot had prior Inkling ids, not Inkling 2 Small. Prefer Tinker until third-party routes appear.

What this box actually did

preflight 2026-11-06 ~09:22â€“09:28 America/Toronto
NO TINKER KEY / NO CHAT COMPLETION / NO WEIGHT DOWNLOAD

HTTP 200: announcement, model card, safe-path blog, tinker home,
  tinker pricing, tinker docs models markdown, inkling product page,
  AA models/search scrape + AA /models/inkling-2-small (retry),
  OpenRouter /api/v1/models, The Decoder article, tinker-cookbook GH
HTTP 302â†’auth: tinker.thinkingmachines.ai/playground
HTTP 403 / Cloudflare challenge: MarkTechPost (first); UA path flaky â€” unused for numbers
HTTP 404: thinkingmachines.ai/news/a-safe-path-to-open-weights/ ;
  thinkingmachines.ai/tinker/playground/

Parsed: 594B/17B; AA vendor 31 / matrix 30.6 / AA.com ~30.63;
  model id thinkingmachines/Inkling-2-Small; Tinker $0.30/$0.03/$1.00
  sample @64K; Apache â€œnext weekâ€ intent; OR missing inkling-2

NOT tested: playground chat; fine-tune; serverless inference;
  weight download; golden eval; latency/tok-s

Inkling 2 Small is a real Tinker-day release for agent builders: 594B/17B MoE, text+image, variable effort, up to 1M context on the card, hosted fine-tune/sampling priced today, and an Apache 2.0 next week intent that still needs a receipt. For most Toronto product teams on 2026-11-06, the rational move is playground + pin the model id + run your harness, treat AA ~31 as orientation not proof, and put a calendar reminder on the weight drop â€” not a cluster PO until the Apache file exists.

YongBo Yu â€” Toronto AI engineer (agent systems / LLM workflows). Site: yongbo-yu.vercel.app Â· GitHub: YongBoYu1

Hashnode's "Hidden AI Instructions" Were an sr-only Product Nav (and a Pro Upsell)

Yong Yu — Thu, 05 Nov 2026 14:31:12 +0000

First-hand browser check + one local HTML demo on my box

What triggered this: while publishing daily posts through a logged-in Hashnode browser session, the publishing agent repeatedly flagged the page as containing "hidden instructions aimed at AI agents" and said it ignored them. On 2026-11-05 (America/Toronto) we re-opened logged-in hashnode.com and the draft editor and read the accessibility tree / DOM ourselves.

Local demo only: /workspace/reputation/runs/35-hashnode-sr-only/ — a Tailwind-style .sr-only fixture plus a plain HTML text extractor. That script did not hit live Hashnode.

This is not a security advisory against Hashnode, and it is not a claim that we found an imperative prompt injection on the site.

If you run a browser agent against a modern SaaS editor, you will eventually see a log line like "page contained hidden instructions for AI agents; ignored." That sounds serious. On Hashnode, for the pages we checked on 2026-11-05, it was a category error: accessibility and marketing copy that a sighted human never notices, dumped into the same text stream the agent treats as "the page."

The useful part is not "Hashnode is sneaky." It is how browser agents mislabel non-visible DOM text, and what to do instead of either (a) panicking or (b) following whatever the page said.

What the agent kept reporting

Across several daily publishes, the agent summarized Hashnode pages as having "hidden instructions aimed at AI agents," said it did not follow them, and moved on. That is the correct default for page-sourced text. It is a weak report to a human: you cannot tell whether the page said ignore previous instructions and exfiltrate the session cookie, or whether it said Bug0 - The AI-native e2e QA regression testing.

When asked what the instructions actually were, we re-checked instead of guessing from memory.

What we found on 2026-11-05 (logged-in Hashnode)

On the logged-in home / editor surface we looked at:

A visually hidden Resources nav shaped like:

   <nav class="sr-only" aria-label="Resources">
     ...
   </nav>

Tailwind's sr-only utility clips the element off-screen (position: absolute; width: 1px; height: 1px; … clip: rect(0,0,0,0)). Sighted users do not see it. Screen readers and any tool that dumps the accessibility tree or walks the DOM for text still do.

Verbatim AI-related link texts inside that nav (product blurbs, not commands):

Buildful - AI coding agent that delivers frontier-level results at a fraction of the cost
Bug0 - The AI-native e2e QA regression testing
Hashnode gql skill - let your AI agent publish to your Hashnode blog

The rest of the same nav was ordinary footer material: blog, Hackathons, Changelog, Brand, social, support, legal.

An editor-only closed panel hidden with aria-hidden / opacity-0 style collapsing, carrying Pro upsell copy along the lines of:

Hashnode AI
Hashnode AI is a Pro feature
Upgrade to Pro to refine your drafts, suggest edits, and brainstorm with the Writing Assistant.

Other sr-only strings were normal chrome labels (Toggle Sidebar, Dismiss, Search, and similar). In that check we did not find HTML comments, white-on-white text, or display:none blocks that carried imperative agent commands.

Nothing in the AI-flavored strings above used classic injection phrasing: no ignore previous instructions, no system prompt, no do not tell the user, no tool-call recipes. They read as product link titles and a collapsed upsell. Calling them "hidden instructions" flattened marketing + a11y into the same bucket as prompt injection.

Why browser agents make this mistake

A publishing agent typically does some mix of:

accessibility-tree snapshots (roles, names, values — including sr-only content kept for screen readers)
DOM innerText / recursive text walks that ignore CSS visibility
occasional raw HTML scrapes

All three will surface Tailwind sr-only navs. CSS that is for assistive tech is, by design, still present as text. If your threat model is "any non-obvious string on the page might be trying to steer me," then a Resources footer that happens to advertise an "AI coding agent" and a "gql skill" will light up the same heuristic as a real injection.

That heuristic is too coarse. The right split is:

Signal	Example from this check	Treat as
Marketing / a11y copy	`Buildful - AI coding agent…`, Pro Writing Assistant blurb	Untrusted data; do not execute; optional to quote
Imperative injection	`Ignore previous instructions and…` / secret-exfil recipes	Untrusted data that you also refuse to follow; report verbatim to the human
Ordinary UI labels	`Toggle Sidebar`, `Dismiss`	Noise; do not escalate

Notice both of the first two rows stay untrusted. The difference is reporting quality and whether you escalate.

Local demo: `sr-only` still extracts as plain text

I did not re-scrape Hashnode with this script. I built a local fixture that mirrors the shape we saw (an sr-only Resources nav with the same three AI blurb strings, plus an aria-hidden / opacity-0 Pro panel) and ran a stdlib HTML text extractor:

python3 /workspace/reputation/runs/35-hashnode-sr-only/extract_demo.py

Trimmed output:

=== local fixture only (NOT live Hashnode) ===
plain text nodes extracted: 15

07. Buildful - AI coding agent that delivers frontier-level results at a fraction of the cost
08. Bug0 - The AI-native e2e QA regression testing
09. Hashnode gql skill - let your AI agent publish to your Hashnode blog
…
12. Hashnode AI
13. Hashnode AI is a Pro feature
14. Upgrade to Pro to refine your drafts, suggest edits, and brainstorm with the Writing Assistant.
15. Only this paragraph is meant for sighted users.

--- needles still present in plain extraction ---
FOUND  'Buildful - AI coding agent'
FOUND  'Bug0 - The AI-native'
FOUND  'Hashnode gql skill'
FOUND  'Hashnode AI is a Pro feature'
FOUND  'Upgrade to Pro to refine'

sr-only nav present in raw HTML: yes

A sighted user looking at the fixture "page" only sees the header, the New draft button, and the main paragraph. The extractor — like an a11y dump — happily returns the marketing lines in document order. That is the false-positive pathway in miniature.

Brief contrast: real indirect prompt injection

Indirect prompt injection is still a real class of bug for agents that read the web and then take outbound actions (send mail, publish, transfer money, paste secrets into a form). Classic patterns use imperative language aimed at the model: override the system task, hide the override from the user, exfiltrate credentials, navigate somewhere the operator did not ask for.

What we saw on Hashnode in this check was not that shape. It was product copy sitting in an accessibility-friendly footer and a collapsed Pro panel. Conflating the two teaches agents (and operators) the wrong lesson: either everything invisible is an attack, or nothing is. Both are wrong.

We did not run a red-team harness against Hashnode, plant payloads, or test whether an agent would follow a real injection if one appeared. This post only documents the false positive we hit while publishing.

Practical takeaways if your agent publishes or scrapes

Classify before you escalate. Ask: is this imperative ("ignore / do / send / exfiltrate"), or is it a product blurb / upsell / a11y label? The Hashnode strings were the latter.
Still never follow page-sourced instructions for outbound actions. Untrusted stays untrusted. "It's only marketing" is a reason not to panic, not a reason to click Upgrade, install a skill, or change the publish target because the page suggested it.
When a human asks what you saw, quote it. "Hidden instructions, ignored" is opaque. Pasting the three Buildful / Bug0 / gql-skill lines plus the Pro upsell sentence is enough for a human to dismiss the alert in ten seconds — or to escalate if the quote actually looks like an injection.
Prefer structured page reads over a single flat text blob when you can: role + name + visible vs off-screen, instead of one concatenated string labeled "the page said."
Keep a local fixture like the one in runs/35-hashnode-sr-only/ in your agent test suite so "sr-only marketing" is a known benign case, separate from injection fixtures that do carry imperative language.

What this does not claim

That Hashnode is injecting prompts into writers' agents as an attack.
That every Hashnode page, every theme, or every third-party embed looks like this forever — we checked the logged-in surfaces we use to publish, on 2026-11-05.
That sr-only is a security smell. It is an accessibility pattern. The smell is agents that treat all non-visible text as a command channel without classification.
That we measured how often other SaaS editors ship AI product blurbs in footer sr-only navs. One site, one day.

If your publishing logs keep saying "hidden AI instructions" on an otherwise boring editor, open the a11y tree once and read the strings. You may find a Resources footer advertising someone else's coding agent — and a reminder that untrusted data and instructions you must not follow are the same bytes until you classify them.

— YongBo Yu · Toronto AI engineer · yongbo-yu.vercel.app · GitHub @YongBoYu1

Kimi K3.1 Pro Weights Are Out: $20M License Cliff, ~1.56 TB Reality, and Hosted vs Self-Host

Yong Yu — Thu, 05 Nov 2026 14:19:18 +0000

Attributed compile + one small offline run on my box

Primary source: moonshotai/Kimi-K3.1-Pro model card + LICENSE by Moonshot AI, weights public on Hugging Face as of our 2026-11-05 preflight (launch promise was “by Nov 4, 2026”).

Secondary: vLLM recipe — moonshotai/Kimi-K3.1-Pro; vLLM Day-0 blog; OpenRouter — moonshotai/kimi-k3.1-pro (models API + endpoints JSON); HN — “Kimi K3.1 Pro model weights are out” (579 points / ~165 comments in our scrape). Local copies: /workspace/reputation/runs/34-kimi-k3-1-pro-weights/.

Blocked / unused: r/LocalLLaMA search JSON — TLS failure then HTTP 403; not a source of record.

Numbers below from the HF card, LICENSE, vLLM recipe, or OpenRouter JSON are vendor / third-party dashboard unless marked otherwise. This box did not call chat completions, download weight shards, or use an API key. Offline preflight = public HTTP scrapes + HF tree/API + OpenRouter /api/v1/models + endpoints JSON only. This post is the weights-day follow-up to our earlier API migration / effort / cache note (series #26) — do not treat them as the same checklist.

Moonshot’s “full weights by Nov 4” line is no longer a calendar promise. On 2026-11-05 the Hugging Face repo moonshotai/Kimi-K3.1-Pro was public and ungated in our preflight: 96 safetensors shards, a real LICENSE file, tokenizer / processor code, and a model card that finally names the custom Kimi K3.1-Pro License. HN flipped hard the same window (579 pts). The useful builder question is not “is it open?” It is four concrete checks: (1) what the license actually gates at ~$20M MaaS revenue, (2) what ~1.56 TB on disk and ~1,874 GB recipe VRAM mean for self-host, (3) which hosted routes already bill you today, and (4) when a builder should stay on API, wait for community recipes, or skip the download theater entirely.

What landed on Hugging Face

Card summary (label as vendor card):

Field	Value
Architecture	MoE — 2.8T total / 104B activated
Experts	896 routed, 16 selected / token + 2 shared
Layers	93 (69 KDA + 24 Gated DSA)
Context	1,048,576
Quantization (card)	MXFP4 weights / MXFP8 activations (QAT)
Vision	MoonViT-V2 (401M); modality on card: Text, Image
License tag	`other` / `kimi-k3.1-pro` (not Apache/MIT)

Our HF tree/API scrape: gated: false, 96 weight shards totaling 1,561,293,160,568 bytes (~1.561 TB / ~1,454 GiB), plus a ~60 MB model.safetensors.index.json. Downloads / likes in the API snapshot were moving targets (~11.6k / 775 when we looked) — cite only as “alive,” not as a quality signal.

Recommended engines named on the card: vLLM, SGLang, TokenSpeed, with day-0 recipe links. Official API remains kimi-k3.1-pro on platform.kimi.ai (OpenAI- and Anthropic-compatible).

Card vs OpenRouter modality note. The HF card lists Text, Image. OpenRouter’s models API for moonshotai/kimi-k3.1-pro reports modality text+image+video→text. For weights trust the card; for a hosted route, pin whatever that provider’s schema actually accepts.

License cliffs (verified on the LICENSE file)

We fetched the raw LICENSE (HTTP 200). Plain-language summary — not legal advice; read the file before you ship:

Broad grant. Use, copy, modify, merge, publish, distribute, sublicense, sell; run, deploy, fine-tune, create derivatives — with notice retained.
MaaS + $20M / 12 months. If you (or affiliates) operate a Model as a Service business — third parties get meaningful control over inputs / parameters / training via API-style access — and aggregate revenue exceeds USD 20 million over any consecutive 12 months, you need a separate agreement with Moonshot before commercial use of the Software or derivatives. Embedded end-user features and mere request-relaying are carved out of the MaaS definition.
Brand display. Commercial products/services with >100M monthly active users or >USD 20M monthly revenue must display “Kimi K3.1-Pro” prominently in the UI.
Exemptions. Sections 2–3 do not apply to internal use (no third-party exposure of the model/outputs/capabilities) or use through Moonshot official products / certified inference partners.

So: a Toronto indie product that embeds the model inside a feature is not automatically the $20M MaaS case. A growing inference reseller that crosses the revenue line is. “Open weights” ≠ “Apache for every commercial topology.” HN commenters spent a lot of oxygen on enforceability; treat that as community chatter, not counsel.

Hardware reality (self-host is not a laptop story)

vLLM’s day-0 recipe (HTTP 200) is blunt: baseline is TP8 on two GB300 trays, one B300 node, or one MI355X node for the MXFP4 checkpoint. Recipe variant line: MXFP4 ≈ 1,874 GB total VRAM. Routed experts are MXFP4 on disk (~1.56 TB); attention, shared experts, and the vision tower stay BF16.

That matches the HN top-of-thread instinct: this release targets labs with racks, inference providers, and enterprises already renting H100/B300/MI355X class gear — not a 24 GB gaming box. Community GGUF / deep RAM-offload paths may appear later; our preflight did not find a consumer-ready GGUF on the official repo, and we did not download shards to measure load times.

Practical self-host checklist if you still want the download:

Confirm legal path (internal vs MaaS; certified partner vs raw weights).
Budget disk ≥ ~1.6 TB free before KV / scratch.
Follow the vLLM 0.34.0+ / vllm/vllm-openai:kimi-k31 (or SGLang / TokenSpeed) recipe — do not invent a single-GPU config.
Treat long-context knobs (DCP, NVFP4 KV, draft models) as recipe features, not defaults you cargo-cult from a blog screenshot.
Run your golden eval before you retire the hosted model string.

Access matrix (what we actually opened)

Route	Preflight	Note
HF `moonshotai/Kimi-K3.1-Pro`	HTTP 200, ungated	Weights + LICENSE + card
Moonshot API `kimi-k3.1-pro`	Named on card	Not authenticated here
OpenRouter `moonshotai/kimi-k3.1-pro`	models + endpoints JSON 200	Many third-party hosts live
vLLM recipe / Day-0 blog	HTTP 200	Hardware baseline above
SGLang cookbook / TokenSpeed	Linked from card	Not opened in depth
r/LocalLLaMA search API	403 / TLS fail	Unused

Hosted economics (OpenRouter snapshot)

Prefer OpenRouter JSON for callable numbers. Models API list-style pricing for moonshotai/kimi-k3.1-pro in our snapshot:

	$/M tokens
Input	$2.00
Output	$10.00
Cache read	$0.20

Context card 1,048,576; top_provider.max_completion_tokens 943,718 (very different from the Hy4-style 65K max-out cliff — still pin max_tokens deliberately). Supported params in the JSON include reasoning / reasoning_effort, tools, structured outputs.

Endpoints JSON showed 21 provider rows in our scrape — Moonshot AI (incl. highspeed at $4/$20), Together, Modal, Fireworks, DeepInfra, Parasail, Nebius, Phala, InferenceNet, Wafer, Relace, and others. Quant tags varied (mxfp4, fp4, fp8, bf16, unknown). Some third-party input rates sat below the $2 list (e.g. Relace ~$0.38 / $7.92 in the snapshot) with the same $0.20-class cache read on several routes. Pin provider + quant + uptime before you budget; these are dashboard snapshots, not our latency benches.

Cache math still dominates agent loops (same mechanism as #26, new surface): at ~95% cache hit on the $2 / $0.20 schedule, weighted input ≈ 0.05×2 + 0.95×0.20 = $0.29 / M, while output still bills at $10 / M. Hosted is how most builders should evaluate quality this week.

What a builder should do this week

Stay hosted (default). Call Moonshot or OpenRouter, keep reasoning_effort explicit, preserve full assistant messages (including reasoning) on multi-turn / tools as the card shows, and score your own tasks. You get weight-backed providers without buying a B300 node.

Self-host only if you already have the rack (or a cloud quote that survives finance review), your counsel is fine with the LICENSE topology, and you need air-gap / weight-level customization that API cannot give. Start from the vLLM/SGLang day-0 path; do not wait for a mythical single-GPU GGUF to make the headline true.

Wait / don’t bother if you needed a laptop-local 3T-class MoE, or if your only goal was “download the flagship tonight.” The weights being public is still a big ecosystem win — providers can compete, researchers can inspect, fine-tunes can exist — without every indie repo cloning 1.56 TB on day one.

Skip rehashing #26. Effort defaults, rejected K2.x sampling fields, and cache-write TTL math are already covered. Today’s delta is LICENSE + disk/VRAM + multi-host OR matrix.

Vendor benches (map, not certificate)

The HF card publishes a large comparison table at reasoning_effort=max (Terminal-Bench, SWE Marathon, HLE, BrowseComp, cyber suites, internal Kimi benches, etc.). Those are vendor figures with long footnotes about harnesses and judge models. We invent no independent scores here and we did not re-run any row. Use the table as a shortlist for your golden eval after the hosted path is wired.

What this box actually did

preflight 2026-11-05 ~09:05–09:10 America/Toronto
NO API KEY / NO CHAT COMPLETION / NO WEIGHT DOWNLOAD

HTTP 200: HF card HTML, raw LICENSE, raw README,
  HF API model + recursive tree, OpenRouter page,
  OpenRouter /api/v1/models + .../endpoints,
  vLLM recipe, vLLM Day-0 blog, HN item 50366999
HTTP 403 / TLS fail: Reddit LocalLLaMA search JSON

Parsed: 96 shards → ~1.561 TB; LICENSE $20M MaaS line;
  OR list $2/$10/$0.20; 21 endpoint rows; HN 579 pts

NOT tested: chat completion; Moonshot auth; weight download;
  vLLM/SGLang/TokenSpeed serve; golden eval; GGUF paths;
  any latency/tok-s measurement

Weights day is real: the repo is ungated, the LICENSE names the $20M MaaS cliff and the brand-display rule, the disk math is ~1.56 TB, and the vLLM baseline is still an 8× data-center GPU story. For most product teams the rational move on 2026-11-05 is hosted eval first, self-host only with rack + counsel, and no theater downloads “because HN is on fire.”

— YongBo Yu · Toronto AI engineer · yongbo-yu.vercel.app · GitHub @YongBoYu1

Tencent Hy4: Vision + Computer-Use API Today, $0.417/$1.251 Promo, 1M vs 65K Max-Out, Weights Pending

Yong Yu — Wed, 04 Nov 2026 14:18:02 +0000

Attributed compile + one small offline run on my box

Primary source: Tencent Launches Hy4, Joining the Ranks of the World's Leading Open-Source AI Models by Tencent, published 2026-11-04.

Secondary: TechNode — Tencent launches Hy4 with vision and computer-use capabilities (2026-11-04).

Callable surface: OpenRouter — tencent/hy4 (models API JSON + page FAQ / provider table). Local copies: /workspace/reputation/runs/33-hy4/.

Blocked in preflight: hy.tencent.ai/research/hy4 returned EdgeOne HTTP 567 Restricted Access — cite OpenRouter + press for pricing; do not treat the research page as opened.

Numbers below from press / TechNode / OpenRouter are vendor or third-party dashboard unless marked otherwise. This box did not call chat completions, download weights, or use an API key. Offline preflight = public HTTP scrapes + OpenRouter /api/v1/models JSON only.

Tencent shipped Hy4 on 2026-11-04: first vision + first computer-use for the Hy line, with the API live on Tencent Cloud TokenHub and third-party routes including OpenRouter. The useful builder story is not “another open-source flagship pitch.” It is four concrete checks: (1) today is an API / product day — weights and the system card are promised in the coming days / shortly, not a download you can pin yet, (2) OpenRouter model id tencent/hy4 is text+image→text with a 1,048,576 context card and a separate 65,536 max-completion cliff, (3) TokenHub / OR route pricing is on a 50% promo through 2026-12-31 where cache-read rates dominate agent-loop cost, and (4) vendor financial / hallucination / GameDev deltas are a map for your golden eval — not a merge-into-prod certificate.

TechNode reports ~770B parameters (vendor via TechNode — label as such). Press positions Hy4 among leading open-source models and acknowledges responsible-release framing around cyber and bio. Coverage around the launch also notes Hy4 still trails leading closed models on hard internal math / coding / self-improve / VQA benches (vendor / press framing); we invent no closed-model scores here.

What it is (short)

Hy4 adds fine-grained image understanding, complex chart analysis, and mathematical visual reasoning, plus computer-use across CLI and GUI. Press calls out specialized training on professional software such as Blender and CAD, and stronger long-horizon agentic behavior. Product surfaces named on launch day: Tencent Cloud TokenHub, WorkBuddy, CodeBuddy, Yuanbao, WeCom AI Assistant (Dayuan), ima; third-party API routes named: OpenRouter, Hermes, OpenCode. Promo windows: WorkBuddy + CodeBuddy free Nov 4–15; TokenHub Hy4 50% off through Dec 31, 2026. Hy4 Flash is scheduled soon (press body / TechNode — treat as upcoming, not a second GA you can call today from our preflight).

Sibling on OpenRouter: tencent/hy4-preview is still text→text only (no image), same 1M context card, and list-style pricing without the GA 50% we saw on the tencent/hy4 Tencent Cloud route. Do not reuse preview client assumptions for vision.

Access matrix

Route	What we saw	Note
OpenRouter `tencent/hy4`	models API + page HTTP 200	text+image→text; tools + structured outputs + reasoning params per OR FAQ
OpenRouter `tencent/hy4-preview`	models API HTTP 200	text→text only; same 1M context; no GA 50% on the route we saw
Tencent Cloud TokenHub / WorkBuddy / CodeBuddy / Yuanbao / WeCom Dayuan / ima	Named in press	Product day — we did not authenticate
Hermes / OpenCode	Named in press	Third-party labels — not opened in this preflight
Weights + system card	Promised “coming days” / “shortly”	Not released in our 2026-11-04 preflight
hy.tencent.ai/research/hy4	HTTP 567 EdgeOne	Restricted — not a source of record for this draft

Ecosystem notes around the launch mention partnership with vLLM and SGLang communities for when weights land; our box could not re-verify that wording on the research page (567). Until HF / vLLM / SGLang recipes appear, stay on API.

Price math (OpenRouter + press)

Prefer OpenRouter API JSON + OR page for callable numbers. Press approximate USD (~$0.90 / $2.70 / $0.045 cached) is close but not identical to OR list — slight press vs OR difference; pin the route you actually bill.

OpenRouter tencent/hy4 (Tencent Cloud route, 50% off in our snapshot):

	List (struck on OR)	Effective at 50% off
Input / M	$0.834	$0.417 (`0.000000417` / token)
Output / M	$2.501	~$1.251 (`0.0000012505` / token)
Cache read / M	$0.042	$0.021 (`0.000000021` / token)

OR provider table snapshot (not our measured bench): P50 latency ~3.30 s, throughput ~53 tok/s.

Why cache hit rate dominates agent loops. Illustrative weighted input at ~95% cache hit:

List: 0.05×0.834 + 0.95×0.042 ≈ $0.082 / M input
Promo: 0.05×0.417 + 0.95×0.021 ≈ $0.041 / M input

Output still bills at full completion rates (~$1.251 / M on promo, $2.501 / M list). An OR dashboard snapshot in our preflight showed an effective weighted average around ~$0.079 / M input vs ~$2.38 / M output under a ~95% cache-hit regime — treat as OR dashboard snapshot, not an independent bench. The mechanism point is the same: for long agent loops that re-send a stable prefix, cache-read pricing — not the brochure input rate — sets the floor.

Promo math ends 2026-12-31 on the TokenHub / OR 50% path we saw; after that, re-read the provider table before you budget Q1.

Context cliff: 1M card ≠ 65K max-out

OR FAQ: context window 1,048,576; supports up to 65,536 completion tokens. Architecture from models API: modality text+image→text; input modalities text + image; output text. Tools + tool_choice, structured outputs via response_format, and reasoning / related params are listed as supported on OR — still verify on your client against the live schema.

Do not confuse a 1M prompt window with a 65K max completion. Long computer-use traces that emit huge action JSON will hit max_out long before they fill the context card. Pin max_tokens / max_completion_tokens deliberately and watch finish_reason=length.

Call path (illustrative — not executed)

OpenAI-compat against OpenRouter with model tencent/hy4. Minimal shape for a text+image turn (we did not call chat completions):

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tencent/hy4",
    "max_tokens": 2048,
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "Extract the trend and units from this chart."},
        {"type": "image_url", "image_url": {"url": "https://example.com/chart.png"}}
      ]
    }]
  }'

# Illustrative only — not run in this preflight
from openai import OpenAI
client = OpenAI(base_url="https://openrouter.ai/api/v1", api_key="...")
resp = client.chat.completions.create(
    model="tencent/hy4",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Extract the trend and units from this chart."},
            {"type": "image_url", "image_url": {"url": "https://example.com/chart.png"}},
        ],
    }],
)

If your client still points at tencent/hy4-preview, you will not get the GA vision path. Swap the model string and re-test image payloads before you blame “Hy4 can’t see charts.”

Vendor benches (label as vendor)

From the 2026-11-04 Tencent press (and TechNode where noted). All scores below are vendor:

Blind financial eval (Tencent Hy + Tencent Financial Technology): 213 professionals, 579 tasks — Hy4 3.04, DeepSeek-V4.1-Flash-1017 2.97, Kimi K3.1 Pro 2.68, GLM-5.3 2.68.
iRaB +12.03 pp vs Hy4 Preview (vendor internal / Rabyte).
Hallucination rate Hy4 Preview 12.95% → Hy4 7.2%; unsupported-assumption errors 23.1% → 5.6% (vendor internal).
WorkBuddy: avg 83.18, pass rate 96.15%, first in 9/12 mainland CN scenarios (vendor).
GameDev +19.1%, GameLogic +9.8% vs Preview (vendor).
Cyber (high-level only): trained on defensive security; offensive exploit materials excluded; Xuanwu / Keen assessment found no significant offensive concerns in areas evaluated — no exploit detail here.
Bio (vendor): strong foundational bio knowledge; open-ended experimental design more limited vs frontier.

Useful as a map of where they want you to look. Useless as a substitute for your charts, multi-app computer-use tickets, and finance workflows.

Checklist before you trust it

Treat Hy4 today as a multimodal API + computer-use product story; open weights are a promise, not a shard path.
Call tencent/hy4 (not preview) for vision; confirm text+image→text on the live models card.
Budget from promo $0.417 / $1.251 and especially $0.021 cache-read through Dec 31, 2026; design agent loops for cache hits.
Separate 1,048,576 context from 65,536 max completion — pin max_out.
Freeze a golden eval: charts, multi-app computer-use, finance tickets you actually run — before trusting vendor financial / hallucination / GameDev numbers.
Put weights / system card / vLLM / SGLang on a watchlist; re-evaluate self-host only when recipes exist.
Do not invent closed-model scores from “still trails frontier” press language.

What I actually ran (offline)

/workspace/reputation/runs/33-hy4/ — 2026-11-04 09:05 America/Toronto (UTC-5) (box stamp Wed Nov 4 14:05:30 UTC 2026):

NO API KEY / NO CHAT COMPLETION / NO WEIGHT DOWNLOAD

HTTP 200: tencent.com/.../tencent-launches-hy4-... (press)
HTTP 200: technode.com/2026/11/04/tencent-launches-hy4-with-vision-and-computer-use-capabilities/
HTTP 200: openrouter.ai/tencent/hy4 (+ /api/v1/models JSON for tencent/hy4)
HTTP 567: hy.tencent.ai/research/hy4 (EdgeOne Restricted Access)

OR models API: tencent/hy4 ctx 1048576; pricing prompt 0.000000417 /
  completion 0.0000012505 / input_cache_read 0.000000021;
  arch text+image->text
OR FAQ: max completion 65536; tools + structured outputs; reasoning supported
OR provider snapshot: ~3.30s P50 latency, ~53 tok/s (dashboard — not our bench)

NOT tested: chat completion; TokenHub auth; WorkBuddy/CodeBuddy;
Hermes/OpenCode; weight download; vLLM/SGLang serve; golden eval re-score

When Hy4 might become a default API string

Only after a callable path and a golden eval win on your problems:

You need vision + computer-use on a Hy-line model and can live on API until weights land.
You have pinned promo vs list pricing and instrumented cache hit rate for agent loops.
You treat 1M vs 65K max-out as two different budgets.
Vendor financial / WorkBuddy / GameDev numbers are maps, not certificates.
You can roll back the model string without rewriting the harness.

If you needed open weights yesterday, this launch is the wrong trigger — watch for the system card and community recipes. If you already route through OpenRouter and your failures are chart reading, multi-app GUI/CLI agents, or finance tickets, Hy4 is a same-day candidate for a side-by-side, because the GA modality jump and the promo/cache math are concrete enough to instrument.

Hy4’s builder-relevant release is the vision + computer-use API, the $0.417/$1.251 promo with $0.021 cache-read, the 1M context vs 65K max-out cliff, the preview→GA modality jump, and vendor benches labeled as such — with weights still pending. Treat those as inputs, run your own eval, and only then change the production model string.

— YongBo Yu · Toronto AI engineer · yongbo-yu.vercel.app · GitHub @YongBoYu1

Hydrogen-1.0 MIT Open Weights: Gated BF16, NVFP4 262K Context Cliff, and Vendor FSR vs GPT-6 Astra

Yong Yu — Tue, 03 Nov 2026 14:16:50 +0000

Attributed compile + one small offline run on my box

Primary source: Introducing Hydrogen-1.0 by Deep Principle, published 2026-11-02.

Weights: deep-principle/Hydrogen-1.0 (BF16, gated: auto, MIT, base zai-org/GLM-5.3) · Hydrogen-1.0-NVFP4 (ungated) · Hydrogen-1.0-MXFP4 (ungated). Local USAGE / NVFP4 card copies: /workspace/reputation/runs/32-hydrogen-1.0/.

Secondary compile: forkalt — Hydrogen-1.0 (hardware / usedStorage notes; not a quality bench).

Tracker mention: The Agentic Weekly — models listed Hydrogen-1.0 among newest verified entries (Nov 2).

Benchmarks below are vendor-reported (blog prose / figures). This box did not download weights, load a checkpoint, or call chat completions. Offline preflight = public HTTP scrapes + HF API JSON only.

Deep Principle shipped Hydrogen-1.0 on 2026-11-02: an open-weight scientific MoE post-trained from zai-org/GLM-5.3, aimed at chemistry, materials science, and life sciences. The HF lead card was created around 2026-10-31; the useful builder story is not “another 万亿 science pitch.” It is four concrete checks: (1) MIT weights with a gated BF16 path and ungated NVFP4 / MXFP4 siblings, (2) official SGLang / ATOM recipes that actually cap deployable context, (3) a client surface that is OpenAI-compat but fussy about reasoning_effort placement, and (4) vendor claims that Hydrogen beats GPT-6-Astra on FrontierScience-Research (FSR) and improves over GLM-5.3 on GPQA-Diamonds — which is a reason to run your golden science eval, not a reason to paste their PNG into a go/no-go slide.

Four access routes are named on the blog: Hugging Face, ModelScope, NeuroSpark API, and Mira (Deep Principle’s AI Scientist). This box opened HF pages + APIs and the launch blog; ModelScope / NeuroSpark / Mira stay blog labels here — we did not authenticate or call them.

What it is (short)

Hydrogen-1.0 is a text-only (glm_moe_dsa / GlmMoeDsaForCausalLM) scientific problem-solving and research-assistance model. The chat-template language on the card reminds you there is no multimodal input. Domains called out: chemistry, materials, life sciences. Training story (vendor): SFT + RL on domain knowledge, research scenarios, laboratory records, and discovery trajectories — full datasets and recipes are not released with the weights. Card / API context claim: 1M tokens in, 128K max out. API config we saw via preflight needles: num_experts_per_tok 8. HF reports ~753B parameters; safetensors total 753,329,940,480 (same total forkalt cites vs the GLM-5.3 base).

Access matrix

Route	What we saw	Gate / license note
HF BF16 `deep-principle/Hydrogen-1.0`	Card + API HTTP 200	gated: auto; `license: mit`; accept the HF form before shards download
HF NVFP4	Card + API HTTP 200	ungated; MIT LICENSE © 2026 Deep Principle and Z.AI; ModelOpt / Blackwell / 8× B300 recipe
HF MXFP4	Card + API HTTP 200	ungated; Quark / AMD Instinct / MI350X + ATOM recipe
ModelScope / NeuroSpark / Mira	Named on blog only	Not opened in this preflight — treat as blog labels

Our 2026-11-03 ~22:04 Asia/Shanghai HF API preflight (not forkalt’s earlier snapshot): BF16 likes 200 / downloads 56; NVFP4 likes 7 / downloads 572; MXFP4 likes 8 / downloads 1047. Quant siblings already moving downloads while the gated BF16 likes lead — classic “try the smaller disk first” pattern.

Hardware / size (cite sources)

From HF API + forkalt usedStorage notes (we did not huggingface-cli download):

Params: ~753B; safetensors total 753,329,940,480.
BF16 usedStorage (forkalt): ~1.37 TiB across 303 shards.
NVFP4 usedStorage (forkalt): ~432 GiB.
MXFP4 usedStorage (forkalt): ~394 GiB.

Peak VRAM and tokens/s are not independently measured here. Plan rack space from usedStorage + the team’s tp 8 (BF16/NVFP4 SGLang) or tp 4 (MXFP4 ATOM) recipes, not from the 1M marketing number alone.

Deploy traps (the builder core)

Keep the checkpoint’s tokenizer, chat template, weight index, quant configs, and especially generation_config.json. Cards warn that stop / end-of-turn tokens live there; drop it and generation may not stop at the answer.

BF16 SGLang example (from card / forkalt copy — not run here):

python -m sglang.launch_server \
  --model-path deep-principle/Hydrogen-1.0 \
  --served-model-name hydrogen-1.0 \
  --tp 8 --trust-remote-code \
  --reasoning-parser glm45 --tool-call-parser glm47 \
  --host 0.0.0.0 --port 8001

NVFP4 SGLang example (team-tested language: 8× B300) is where the context cliff shows up:

python -m sglang.launch_server \
  --model-path deep-principle/Hydrogen-1.0-NVFP4 \
  --served-model-name hydrogen-1.0 \
  --tp 8 --trust-remote-code \
  --quantization modelopt_fp4 --kv-cache-dtype fp8_e4m3 \
  --reasoning-parser glm45 --tool-call-parser glm47 \
  --context-length 262144 --mem-fraction-static 0.85 \
  --chunked-prefill-size 16384 \
  --host 0.0.0.0 --port 8001

Card context is 1M; this recipe sets --context-length 262144. That is the cliff: your prompt + generation must fit the deployed budget, not the brochure. Raising it needs compatible runtime support and enough memory — do not assume 1M is live because the model card says 1M.

Do not mix BF16 / NVFP4 / MXFP4 files (configs, indexes, shards). USAGE.md is explicit.

Client: OpenAI-compat against a running service (SERVED_MODEL_NAME=hydrogen-1.0). For reasoning effort, pick one convention your server actually forwards:

extra_body={"chat_template_kwargs": {"reasoning_effort": "max"}}, or
top-level reasoning_effort="max"

Do not stack both by default. Card demos use max and max_tokens=4096 as an illustrative budget, not the 128K max-out claim. Check finish_reason=length (and empty final content) before you treat a truncated stream as a scientific answer.

Vendor benches (label as vendor)

From the 2026-11-02 blog prose only. FSR / GPQA numeric table rows were not OCR’d from the PNG figures — do not invent scores here.

Vendor: Hydrogen-1.0 outperforms GPT-6-Astra on FrontierScience-Research (FSR) and improves over GLM-5.3 on GPQA-Diamonds, roughly matching Kimi-K3 in their evaluations.
Internal task deltas (vendor prose vs Astra at max thinking): scientific computing +5.13 pp, forward reactions +4.76 pp; Astra still ahead on NMR structure elucidation by 3.33 pp.
TMC discovery (vendor): by round five, mean best-so-far HOMO–LUMO gap 4.318 eV (Hydrogen) vs 3.689 eV (Astra) / 3.353 eV (Kimi-K3), same initial population, independent feedback histories.

Useful as a map of where they want you to look. Useless as a substitute for your own tickets, tools, and lab constraints. Same series rule: vendor framing ≠ merge into prod.

Checklist before you trust it for science work

Freeze a golden eval on your scientific tickets (derivations, reaction / NMR cases, protocol drafting, tool-using MD or ELN loops you actually run). FSR / GPQA are someone else’s harness.
Gate accept on BF16 if you need unquantized weights; or pick the ungated NVFP4 / MXFP4 path that matches your GPUs.
Pick one quant path and keep its files together — no BF16/NVFP4/MXFP4 mashups.
Budget context from the launch flags, not the 1M card line. NVFP4 recipe = 262K until you prove otherwise.
Pin reasoning_effort placement (template kwargs or top-level) and pin served-model-name hydrogen-1.0.
Treat outputs as drafts. Card language: assess against assumptions, constraints, and evidence; do not treat model text as verified experimental findings or as grounds for health/safety decisions.
Watch truncation: demo max_tokens=4096 is not a research budget; inspect finish_reason.
Do not conflate blog FSR/GPQA claims, internal pp deltas, TMC eV gaps, and any third-party index you have not opened yourself.

What I actually ran (offline)

/workspace/reputation/runs/32-hydrogen-1.0/ — 2026-11-03 22:04 Asia/Shanghai (CST):

NO API KEY / NO WEIGHT DOWNLOAD / NO CHAT COMPLETION / NO SGLang

HTTP 200: blog.deepprinciple.com/introducing-hydrogen-1.0/
HTTP 200: huggingface.co/deep-principle/Hydrogen-1.0 (+ API JSON)
HTTP 200: huggingface.co/deep-principle/Hydrogen-1.0-NVFP4 (+ API JSON)
HTTP 200: huggingface.co/deep-principle/Hydrogen-1.0-MXFP4 (+ API JSON)
HTTP 200: forkalt.com/models/hydrogen-1-0/
HTTP 200: theagenticweekly.com/news/models

HF API (this preflight): BF16 likes 200 dl 56; NVFP4 likes 7 dl 572; MXFP4 likes 8 dl 1047
Local copies: USAGE.md, NVFP4-README.md, MXFP4-README.md, LICENSE (MIT © 2026 Deep Principle / Z.AI)

NOT tested: weight download; SGLang/ATOM serve; chat completion; ModelScope;
NeuroSpark API; Mira; FSR/GPQA re-score; OCR of blog PNG figures; VRAM measure

When Hydrogen-1.0 might become a science default

Only after a callable path and a golden eval win on your problems:

You need an open MIT science MoE and can accept gate + disk (BF16) or a Blackwell / Instinct quant path.
You have chosen quant + context budget knowingly (especially the 262K NVFP4 cliff).
reasoning_effort and stop tokens are pinned; truncation is monitored.
Vendor FSR / Astra framing is treated as a map, not a certificate.
You can roll back without rewriting the lab toolchain.

If you only have a laptop GPU and no B300 / MI350X class box, this drop is the wrong trigger for local serve — use the blog’s API/product labels only after you open them yourself. If you already run SGLang on eight high-memory GPUs and your failures are chemistry / materials reasoning tickets, Hydrogen-1.0 is a same-week candidate for a side-by-side, not because the Astra FSR sentence is gospel, but because the weights and recipes are concrete enough to instrument.

Hydrogen-1.0’s builder-relevant release is the MIT open-weight science MoE, the gated BF16 vs ungated NVFP4/MXFP4 split, the 262K context cliff on the NVFP4 recipe, and vendor FSR / GPQA / internal deltas labeled as such. Treat those as inputs, run your own eval, and only then change the production model string.

— YongBo Yu · Toronto AI engineer · yongbo-yu.vercel.app · GitHub @YongBoYu1

LongCat-2.5 at $0.30/$1.20: Thinking Locks Temperature, 1M Context, and Vendor Benches Between Opus 4.8 and 5

Yong Yu — Mon, 02 Nov 2026 14:14:55 +0000

Attributed compile + one small offline run on my box

Primary source: Introducing LongCat-2.5 — Native Multimodality for Agentic Tasks by Meituan / LongCat team, published 2026-11-1.

Pricing / billing: LongCat-2.5 pricing and API Pay-As-You-Go (limited-time discounted rates; platform billing authoritative).

API: Chat Completions + Platform Quick Start — OpenAI-compat https://api.longcat.chat/openai, Anthropic-compat https://api.longcat.chat/anthropic, model id LongCat-2.5.

Secondary CN press: 美团发布LongCat-2.5大模型，“国模国芯”实现新突破 (Meituan / 经济观察报 framing, 2026-11-02) for the “scores between Claude-Opus-4.8 and Claude-Opus-5” claim and product/API availability.

Benchmarks and prices below are vendor-reported unless I say otherwise. This box did not call chat completions. Offline preflight = public HTTP scrapes + list-price arithmetic only.

Meituan shipped LongCat-2.5 on 2026-11-1 (blog) with wide coverage on 2026-11-2: a 1.6T-parameter MoE (~48B activated per token) pitched as a native multimodal model for long-horizon agentic work. For builders, the useful story is not “another 万亿 MoE.” It is four concrete checks: (1) OpenAI- and Anthropic-compatible endpoints with a single model string, (2) a thinking object that forces temperature (1.0 on / 0.7 off), (3) limited-time list price $0.30 / $0.006 cached / $1.20 per 1M tokens, and (4) vendor benches that Meituan’s own CN framing places between Claude Opus 4.8 and Opus 5 — which is a reason to run your golden eval, not a reason to merge their table into your prod decision.

Try-it surface is longcat.ai; developers get a prepaid Pay-As-You-Go API the same week. That is enough to A/B against a current default without waiting for open weights — and also enough to over-trust a vendor dashboard if you skip your own tickets.

What it is (short)

LongCat-2.5 builds on LongCat-2.0 with stronger native visual understanding and agentic coding (vendor). Visual signals are represented as multi-level discrete tokens (RVQ over a Semantic-and-Aligned Encoder / SAE-style path), so vision and text share a unified token stream. Training emphasis is long-horizon RL: more long trajectories in long-sequence training, failure trajectories turned into verifiable tasks, mixed training across harnesses. Infra notes (for context only): long-context training and W4A4 inference on domestic AI accelerators; vendor online stress vs W8A8 INT8 cites prefill +43.3%, decode +42.77%, TTFT −15.91%, TPOT −19.72%, GMM kernel ~1.73×. That is serving math, not permission to skip quality gates.

Site / docs language also says the model works across Claude Code, Codex, and Hermes harnesses. Treat that as compatibility marketing until you wire one harness and measure your own tasks. Blog eval footnotes themselves show different harnesses per bench (Claude Code on several coding rows, Codex on SkillsBench, custom browse harness on BrowseComp) — another reminder that “works across” is not “one config wins every leaderboard.”

Skip the deep train–inference / supernode digression for day-one integration. Remember only: long context (1M) is a first-class claim, multimodal is native (not a bolted vision sidecar in the marketing story), and agentic RL is the capability bet.

How to call it: dual endpoints + the temperature lock

Platform docs advertise two bases:

Format	Base URL	Typical path
OpenAI-compatible	`https://api.longcat.chat/openai`	`/v1/chat/completions`
Anthropic-compatible	`https://api.longcat.chat/anthropic`	`/v1/messages`

Model id: LongCat-2.5. Context window: 1M tokens; max output: 128K. Default top_p on chat docs: 0.95.

Thinking is an object, not a free-form string:

"thinking": { "type": "enabled" }

or { "type": "disabled" }.

Trap: chat docs say temperature is fixed at 1.0 with thinking enabled and 0.7 with thinking disabled; other values are overridden. If your client still sends temperature: 0 from an older Anthropic/OpenAI template, you are not getting determinism — you are getting the forced default for the thinking mode you picked. Eval note on the blog: LongCat-2.5 rows use enable_thinking=on, temperature=1.0, top_p=0.95 unless specified; other models marked * are public reports.

OpenAI SDK shape is the usual base_url="https://api.longcat.chat/openai" + Bearer key. Anthropic SDK path uses https://api.longcat.chat/anthropic with the docs’ header pattern (Authorization: Bearer … plus Anthropic-style body). Pick one client stack for the A/B; do not flip formats mid-eval or you will confuse tool-schema bugs with model bugs.

Builder rule: set thinking explicitly per route, assume temperature will be clamped, and pin the base URL + model string in config — do not guess. If you need lower temperature for classification, you likely want thinking disabled (and you still get 0.7, not 0.0). Document that in the route table so the next engineer does not “fix” sampling with a dead knob.

Vendor benches (label as vendor)

From the LongCat-2.5 blog metrics table (selected high-signal rows). LongCat-2.5 only below; peer columns exist on the source page — do not invent third-party re-scores here.

Benchmark (vendor table)	LongCat-2.5	vs LongCat-2.0 (same table)
Terminal Bench v2.1	88.4	70.8
Terminal Bench v4.0	38.5	3.0
DeepSWE v1.1	64.6	9.7
PaperBench	82.1	45.2
BrowseComp	91.9	79.9
AutomationBench v1.0.6	51.8	15.8
HLE w/tools	63.1	37.5
Vision2Web	78.6	—
3DCodeBench Text→3D	55.4	—

Meituan’s 2026-11-02 CN press frames results as sitting between Claude-Opus-4.8 and Claude-Opus-5 on several mainstream benches (and exceeding Opus-5 on some). That is a vendor / press claim next to their own charts — useful as a map of where they want you to look, useless as a substitute for your golden set. Same caution as this series always uses: do not paste “between Opus 4.8 and 5” into a slide that implies an independent Artificial Analysis or third-party harness unless that harness is cited.

Jump vs 2.0 on Terminal Bench v4.0 (3.0 → 38.5) and DeepSWE (9.7 → 64.6) is the internal “agentic coding moved” signal. Still: those are their runs with their thinking/temp settings. Replicate on your repos before you retire the incumbent model string.

List price: $0.30 / $0.006 cached / $1.20 (limited-time)

Pay-As-You-Go currently lists LongCat-2.5 at discounted (limited-time) rates:

Item	USD / 1M tokens	CNY / 1M tokens
Uncached input	$0.30	¥2
Cached input	$0.006	¥0.04
Output	$1.20	¥8

Prices are subject to change; platform UI + billing records win. Failed requests (401 / 403 / 429 / 500) are not billed; only HTTP 200 is.

List-price arithmetic (my assumptions — not a bill)

Offline preflight used those three USD rates only. Assumptions: one trajectory = 80k input + 20k output; “80% cache hit” means 80% of input tokens bill at the cached rate; no tax, retries, or tool-overhead tokens.

Scenario	USD (list math)
1 traj, no cache	$0.0480
1 traj, 80% input cache	$0.0292
40-turn loop, no cache	$1.9200
40-turn loop, 80% input cache	$1.1674
1M in + 1M out, no cache	$1.5000

Cache is the swing factor on long agent loops. Thinking-on also tends to inflate reasoning / output tokens relative to thinking-off — price the knob and the rate card together, and remember temperature will not save you from that inflation. For a rough sanity check: at these list rates, 1M in + 1M out is $1.50 before cache; an 80k/20k turn with fat prefix reuse lands closer to ~$0.03 if the 80% cache assumption holds. Measure real cached vs uncached fields on usage before you put the middle rows in a forecast.

CNY list (¥2 / ¥0.04 / ¥8) is on the same docs pages — use it if you bill in RMB; this post’s arithmetic sticks to USD for series consistency.

Checklist before you swap

Freeze a golden eval on your agent failures (repo patches, terminal tasks, browse/tool traces, visual coding if that is your product). Vendor TB / BrowseComp / Vision2Web are someone else’s harness.
Pin base URL + model id — LongCat-2.5 on either api.longcat.chat/openai or …/anthropic. Confirm which SDK headers your client needs (Anthropic path wants the usual Anthropic-shaped request).
Set thinking explicitly. Assume temperature is overridden (1.0 on / 0.7 off). Do not rely on a silent temperature: 0 from old templates.
Price both columns: list $0.30/$1.20/$0.006 and expected output tokens with thinking on. Re-run the arithmetic with your real prompt sizes. Treat rates as limited-time.
Harness claim ≠ drop-in. If you use Claude Code / Codex / Hermes, prove one path with your tools and auth before you rewrite defaults.
Multimodal only if you need it. Discrete visual tokens are the product story; your golden set should include the visual tasks you actually ship.
Billing hygiene: prepaid balance; only HTTP 200 billed; do not forecast from failed 429 storms.
Do not conflate Meituan vendor rows, CN “between Opus 4.8 and 5” framing, and any third-party index you have not opened yourself.

What I actually ran (offline)

/workspace/reputation/runs/31-longcat-2.5/ — 2026-11-02 America/Toronto:

LONGCAT_API_KEY: NOT SET
Chat completions: NOT ATTEMPTED

HTTP 200: longcat.ai/blog/longcat-2.5/
HTTP 200: platform pricing + pay-as-you-go + chat + docs + homepage
HTTP 200: meituan.com CN press (Opus 4.8–5 framing)
Needle hits: $0.30 / $0.006 / $1.20, LongCat-2.5, openai/anthropic bases,
             thinking + temperature lock language, 1M/128K, Claude Code/Codex/Hermes

List-price math (assumptions above):
  1 traj no cache $0.0480 | 80% cache $0.0292
  40-turn no cache $1.9200 | 80% cache $1.1674
  1M+1M $1.5000

NOT tested: live chat; thinking/temp override live; harness wiring;
Terminal Bench / DeepSWE / BrowseComp re-score; real cache hits; W4A4 latency

Costs are arithmetic on LongCat’s stated limited-time list rates under assumptions I state. They are not a bill, not latency, and not quality.

When LongCat-2.5 might become a default

Only after a callable path and a golden eval win on your tickets:

Long-horizon coding / agent loops where your current default fails and an OpenAI- or Anthropic-shaped client is already in the stack.
You have chosen thinking on/off per route, knowing temperature is locked.
Cost model survives realistic cache and thinking-on output inflation at $0.30/$1.20.
You verified the harness you actually run (not only the brochure list).
You can roll back without rewriting orchestration.

If you are already deep in Anthropic- or OpenAI-shaped agent code, LongCat-2.5 is a same-week candidate for a side-by-side — not because the Opus framing is gospel, but because the integration surface is familiar and the list price is easy to model. If you need open weights, local GPUs, or a third-party index row before you trial anything, this drop is the wrong trigger; wait for a surface that matches that constraint.

LongCat-2.5’s builder-relevant release is the dual-compat API, the thinking/temperature lock, the $0.30/$1.20 limited-time card, and vendor benches framed near Opus 4.8–5. Treat those as labeled inputs, run your own eval, and only then change the production model string.

YongBo Yu · Toronto AI engineer · https://yongbo-yu.vercel.app · GitHub YongBoYu1

Mistral Large 4 Open Weights: Vendor TB 41% vs AA's 25%, High Default Effort, and $0.70/$2.10 Before You Self-Host

Yong Yu — Fri, 30 Oct 2026 13:23:21 +0000

Attributed compile + one small offline run on my box

Primary source: Mistral Large 4 (Le Chonk) is now open weight by Mistral AI, published 2026-10-29 (weights after ~3 weeks of extra RL since the early-October public preview).

Secondary: Welcome Le Chonk: Mistral Large 4 on Hugging Face by Aritra Roy Gosthipaty (Hugging Face, 2026-10-29); VentureBeat — Carl Franzen for the Artificial Analysis vs Mistral Terminal-Bench / FrontierCode split and token-per-task notes (live VB fetch returned HTTP 429 on this draft day — numbers below follow Mistral’s post + the VB figures already confirmed for this series; do not treat a blocked fetch as missing coverage).

Model id / card: mistralai/Mistral-Large-4-1T-A52B (also FP8 / NVFP4 / GGUF siblings).

Benchmarks and prices below are vendor-reported (or clearly attributed to HF / VentureBeat’s reading of Artificial Analysis) unless I say otherwise. This box did not call chat completions and did not download weights. Offline preflight = public HTTP scrapes + list-price arithmetic only.

Mistral dropped open weights for Mistral Large 4 (“Le Chonk”) on 2026-10-29: a ~1T-parameter natively multimodal MoE that had already been in public preview earlier in October. The OSS-day story is not “a new model family name.” It is more RL since preview, a reasoning-effort knob, a list price, and a license with a MaaS commercial gate. For builders, the useful move is: separate Mistral’s charts from Artificial Analysis’s own evals, set effort deliberately (default is high), and decide API vs self-host before you swap a production model string.

Repo naming on Hugging Face is Mistral-Large-4-1T-A52B. The model card frames roughly ~1T total / ~52B active (granular MoE: 128 routed experts, 4 active + 1 shared). An HF blog line once said 49B active — prefer the A52B / card naming when you write configs. Context is 1M tokens on the card. Architecture (short): MLA + DSA-style sparse attention, Pixtral vision encoder — enough to know it is sparse MoE + long context, not enough to skip a golden eval.

Do not merge vendor benches with Artificial Analysis numbers

Mistral’s OSS post leads with coding agent claims. Label every row as who measured it.

Mistral-reported (OSS post, 2026-10-29)

Claim (Mistral / named partner)	Figure	Notes
Cognition FrontierCode 2.0 (private)	19.7% lead (vendor)	End-to-end “would a maintainer merge?” framing
Artificial Analysis Coding Agent Index	48%, effectively tied with GLM-5.3	Mistral also claims ~47% fewer tokens/task vs that peer on average
Terminal-Bench 4.0	41% (+13 pp vs preview)	Mistral says lead among open-weight in their chart; ~30% fewer output tokens vs preview
AA Cyber Index	51%	Defensive find / reproduce / patch framing (vendor)
Malicious cyber refusal (Mistral measure)	avg 96.6%	JailbreakBench / StrongREJECT / AgentHarm cyber prompts — their open-model comparison
Finch	73.3%	Finance / spreadsheet workflows (vendor)
BrowseComp	84.5%	From an SFT checkpoint Mistral cites at 75%
B3 agent security attack resistance	97.1% (preview 93.3%)	Prompt-injection / agent-attack resistance (vendor)

VentureBeat’s roundup is useful because it puts Mistral’s numbers next to Artificial Analysis Intelligence Index rows without pretending they are the same harness:

Metric	Mistral claim	AA Intelligence Index eval (per VentureBeat)
Terminal-Bench 4.0	41%	25% (ML4 high)
FrontierCode	19.7%	15%

Same model name, different eval contexts. Do not paste “41% TB4” into a slide that cites AA’s Intelligence Index table, and do not call AA’s 25% a Mistral walk-back. HF’s launch blog still surfaces some preview-era coding rows (e.g. Terminal-Bench 28.3%, Coding Agent Index ~49.8% in that post’s table). Treat those as not the OSS-day Terminal-Bench claim of 41% after more RL. When in doubt: cite the date + source, or re-run your own tasks.

Token efficiency (Mistral + VB reading): on Coding Agent Index work, Mistral positions ML4 near GLM-5.3 on score while using far fewer tokens — VB cites roughly ~8.5M tokens/task vs GLM ~15.9M (~47% less). That is cost/latency leverage, not permission to skip quality gates.

Reasoning modes: low / medium / high — and `none` still means high

OSS-day ML4 exposes three reasoning modes (Mistral table):

Mode	Mistral’s recommended use
Low	Simple tasks; replaces the old None mode
Medium	Everyday tasks
High (default)	Hardest / high-precision work

Hugging Face’s Transformers / Inference Endpoints notes match the trap: reasoning_effort accepts low | medium | high, default high, and none still maps to high — reasoning is not truly off. If your migration code still sends none from an older Mistral preview client, you are not getting a cheap no-think path; you are paying high by default.

Builder rule: set effort explicitly per route. Use low for classification / short edits, medium for normal agent turns, high only where your eval shows it earns the tokens. Leaving the default untouched is a silent bill and latency multiplier.

List price: $0.70 in / $0.07 cached / $2.10 out

Mistral says that starting today (OSS announce day) API list price is $0.70 input / $0.07 cached input / $2.10 output per 1M tokens. Hosted surfaces named in the post: Mistral Studio, Mistral API, OpenRouter, plus NVIDIA NIM / hosted endpoints and Microsoft Foundry. Self-host path: Hugging Face weights + vLLM or SGLang (FP8 and NVFP4 official; GGUFs from Unsloth / llama.cpp).

List-price arithmetic (my assumptions — not a bill)

Offline preflight used those three rates only. Assumptions: one trajectory = 80k input + 20k output; “80% cache hit” means 80% of input tokens bill at the cached rate; no tax, retries, or tool-overhead tokens.

Scenario	USD (list math)
1 traj, no cache	$0.0980
1 traj, 80% input cache	$0.0577
40-turn loop, no cache	$3.9200
40-turn loop, 80% input cache	$2.3072
1M in + 1M out, no cache	$2.8000

Cache is the swing factor on long agent loops. Measure real hit rates before you put the middle rows in a forecast. Effort=high will also inflate output tokens relative to low — price the effort knob and the rate card together.

License: open weights ≠ free MaaS

License is Mistral Ecosystem Open-Weight (modified MIT). Mistral’s summary: free to use / modify / fine-tune / commercialize, with one hard condition — businesses that operate a Model-as-a-Service offering need a separate commercial license before commercial MaaS use. Self-hosting inside your product is not the same as renting the weights out as a public model API. Read the LICENSE on the HF card before you put ML4 behind a multi-tenant endpoint you sell.

Separately: Mistral mentions a specialized cybersecurity variant for vetted design partners (e.g. Orange Cyberdefense) under contractual safeguards. That is access-gated, not the public HF checkpoint. Do not assume the public OSS weights are that partner build.

Checklist before you swap models (API / OpenRouter vs HF + vLLM/SGLang)

Freeze a golden eval on your agent failures (repo patches, terminal tasks, tool traces). Vendor TB 41% and AA’s 25% are both someone else’s harness.
Pin the model id — start from mistralai/Mistral-Large-4-1T-A52B (or the NVFP4 / FP8 sibling you actually serve). Do not guess strings. Docs also surface API-style ids such as mistral-large-4-0; confirm against the surface you bill on.
Set reasoning_effort explicitly. Default is high. Treat none as still high.
Price both columns: list $0.70/$2.10/$0.07 and expected output tokens at your chosen effort. Re-run the arithmetic with your real prompt sizes.
Self-host only if you have GPU budget (HF / partners discuss multi-GPU / Blackwell-class NVFP4 paths; VB notes quantized serving on 4× B200/B300 class setups — treat as secondary hardware rumor until you size it yourself), ops for vLLM/SGLang, and a license read for any MaaS-shaped product.
API / OpenRouter first when you need a same-day A/B without multi-GPU bring-up — then decide whether weight ownership is worth the ops.
Cyber workloads: use the public model under your own policy and sandbox. Partner cyber variants are gated; public refusal rates are Mistral’s measure, not your compliance program.
Do not conflate Mistral charts, HF blog tables, and AA Intelligence Index rows in one “leaderboard” screenshot.

What I actually ran (offline)

/workspace/reputation/runs/30-mistral-large-4/ — 2026-10-30 America/Toronto:

MISTRAL_API_KEY: NOT SET
OPENROUTER_API_KEY: NOT SET
Chat completions: NOT ATTEMPTED

HTTP 200: mistral.ai/news/mistral-large-4-oss/
HTTP 200: huggingface.co/mistralai/Mistral-Large-4-1T-A52B
HTTP 200: huggingface.co/blog/mistral-large4
HTTP 200: mistral.ai/pricing ; docs.mistral.ai models page
Needle hits on OSS page: $0.70 / $2.10 / $0.07, TB 41%, reasoning modes, MaaS license language
Model card: A52B id + FP8/NVFP4 siblings present

List-price math (assumptions above):
  1 traj no cache $0.0980 | 80% cache $0.0577
  40-turn no cache $3.9200 | 80% cache $2.3072
  1M+1M $2.8000

NOT tested: live chat; weight download; vLLM/SGLang; effort behavior;
Terminal-Bench / Coding Agent re-score; real cache hits; partner cyber variant

Costs are arithmetic on Mistral’s stated list rates under assumptions I state. They are not a bill, not latency, and not quality.

When ML4 might become a default

Only after a callable path (API or your own serve) and a golden eval win on your tickets:

Coding / terminal / cyber-defense workloads where your current open or mid-frontier default fails.
You have chosen effort per route, not left high everywhere.
Cost model survives realistic cache and high-effort output inflation.
License review is done if anything you ship looks like MaaS.
You can roll back without rewriting orchestration.

Weights on Hugging Face are the story this week. Treat Mistral’s 41% and AA’s 25% as two labeled columns, set effort on purpose, and run the $0.70/$2.10 math on your trajectories before you call the swap done.

YongBo Yu · Toronto AI engineer · https://yongbo-yu.vercel.app · GitHub YongBoYu1

Gemini 4 Carbon Is #1 on AA Index — Still Fairwind-Only: Cyber Benches, $2/$10 $4/$20, and What to Do Before the API

Yong Yu — Thu, 29 Oct 2026 13:14:48 +0000

Attributed compile (not original research)

Primary source: Introducing Gemini 4 Carbon by Koray Kavukcuoglu (SVP, Google DeepMind / Chief AI Architect, Google), published 2026-10-28

Secondary roundups: Agentic Weekly — model releases (Carbon brief, first seen 2026-10-28); ToolSift daily LLM news 2026-10-28 (Artificial Analysis Index v5.0 context — Opus 5.5 at 58 before Carbon’s claimed 59; Index scores from different days are not a clean head-to-head)

Docs check: Gemini API models (fetched 2026-10-29) lists Gemini 4 endpoint gemini-4-argon only — no public Carbon model ID

This post restates Google’s Carbon packaging in my own words, with a builder checklist for the same Fairwind-first trap as Argon (~two weeks earlier). I did not run Gemini 4 Carbon — it is not publicly callable. Every bench, price, and access claim below is vendor-reported (or clearly attributed to a named secondary source). Offline preflight: docs scrape + list-price arithmetic only.

Google announced Gemini 4 Carbon on October 28, 2026 — roughly two weeks after Gemini 4 Argon — as its strongest frontier model, with the headline pitched at cybersecurity defense and long-horizon engineering. The capability story is loud: Artificial Analysis Intelligence Index v5.0 at 59 (Google claims #1), cyber benches without guardrails, and internal anecdotes about multi-day agent runs. The access story is quieter and more important for builders this week: Carbon starts with a subset of cyber defenders, then more trusted partners through the Fairwind Program, then developers / businesses / consumers “as soon as possible.” There is still no public API model ID.

If you shipped a plan that assumed “Carbon drops → swap the string in models.list,” pause. Same Fairwind-first pattern as Argon. Bookmark the blog; do not block a release on it.

What’s new vs Argon (all vendor-labeled)

Google frames Carbon as building on Argon with sharper cyber and long-horizon behavior, plus tighter alignment. Treat every number as Google’s claim unless you re-run it yourself.

Intelligence Index and coding/web

Claim (vendor)	Figure	Notes
Artificial Analysis Intelligence Index v5.0	59, Google says #1	Index was rebuilt with more private tests (ToolSift summary of AA’s Oct 27 reset). ToolSift’s same-day briefing still listed Claude Opus 5.5 (max) at 58 before Carbon’s announce — do not treat 58→59 as a same-harness race day without AA’s own Carbon row.
WebDev Arena	+89 Elo → #4 (1768)	Full-stack web / artifact quality, per Google

Cyber defense lifecycle (evaluated without guardrails, vendor)

Stage	Bench	Carbon (vendor)
Find vulns	SEC-bench Pro	88.2%
Validate / exploit	ExploitGym	54.8%
Patch	Collinear CWE-bench	71.0%

Internal / partner anecdotes Google cites (not your SLA): >2× uplift in secure-code success vs Argon; Chrome team claimed >10× better high-quality patches vs “another lab’s” frontier model; Wiz cited for a web pen-test lead tied to Scan for Good. Useful as direction, useless as a compliance ticket.

Long-horizon behavior (vendor narrative)

Google says internal teams saw Carbon run for days, persisting through dead ends on multi-step engineering (root-cause + patch across large / low-level codebases). That is a product promise about agent stamina, not a public max_duration parameter you can set today.

Safety / alignment deltas Google reports

Built on Argon’s multi-layered stack (training, misuse defenses, prompt-injection resilience, chain-of-thought monitoring). Carbon-specific vendor figures:

Metric (vendor / internal)	Carbon claim
Terminal-Bench 4.0 cheating success	0.0% (attempts 0.4%)
High-severity misalignment alerts (live coding, internal)	~80% drop
Unsupported claims vs Argon	~2× cut
Overreach / under-service	−26% / −29%
Gray Swan Indirect Prompt Injection (IPI) ASR	0.0% (Argon was 0.7%, vendor)

Still vendor benches and internal alerts. Your agents need your own IPI and exfiltration tests.

Access trap: Fairwind / cyber defenders first

Google states it is in the U.S. government’s voluntary pre-release testing process. Rollout order in the announce:

This week: subset of cyber defenders
Then: additional trusted partners via Fairwind
Later: developers, businesses, consumers on product surfaces “as soon as possible”

There is no GA date and no public endpoint string. On 2026-10-29 the public Gemini API models page still lists only gemini-4-argon under Gemini 4. Guessing gemini-4-carbon is not a migration plan.

Same builder constraint as the Argon post: do not make Carbon a production default until you have (a) a documented model ID, (b) billing/access on your project, and (c) a golden eval that beats your current callable default on your failures.

X chatter will treat “#1 on AA Index” as already shippable. Chatter is not an API key.

Pricing trap: intro $2/$10 → post-intro $4/$20 (+ cache)

Google says Carbon launches at the same introductory price as Argon:

Per 1M tokens (Google)	Introductory	After intro period
Input	$2	$4
Output	$10	$20
Cached input	95% off input price	same discount structure as stated at launch

Intro matches the familiar mid-frontier coding band. Post-intro doubles both columns. Cache at 95% off input is the lever that decides whether long agent loops stay affordable.

List-price arithmetic (my assumptions — not a bill)

Offline preflight on this box used Google’s stated rates only. Assumptions: one trajectory = 80k input + 20k output; “80% cache hit” means 80% of input tokens bill at the cached rate (5% of input list); no tax, no retries, no tool-overhead tokens.

Scenario	Intro $2/$10	Post-intro $4/$20
1 traj, no cache	$0.36	$0.72
1 traj, 80% input cache	$0.24	$0.48
40-turn loop, no cache	$14.40	$28.80
40-turn loop, 80% input cache	$9.54	$19.07
1M in + 1M out, no cache	$12.00	$24.00

Post-intro is an exact 2.00× on these list rates when cache assumptions match. Build board slides for both columns. Do not bake “Carbon is $2/$10 forever” into a forecast. Measure real cache hit rates before you trust the middle rows.

What to do this week (callable models still win)

Carbon’s announce does not retire Argon, GPT-6.1 Terra/Sol, Claude 5.5, or anything else you can already call.

Keep shipping on models with a public ID and a key that works today.
Prep long-horizon + secure-code evals now: multi-file root-cause, flaky repros, vuln→patch trajectories with human review gates. When a Carbon ID appears, you want 20–50 frozen tasks ready — not a scramble.
Watch the official models directory and release notes for a real Carbon endpoint. No ID → no production default. Do not invent one.
Do not block a customer release on Fairwind unless your org is actually in that program.
Price the post-intro column ($4/$20) in any Carbon ROI slide; assume cache misses until measured.
Security posture: if you ever receive a no-guardrail / cyber-defender build, isolate it. Fairwind-style access is defense capability plus staged safeguards — not “same sandbox as the public chatbot.”
Re-check AA Index yourself when Artificial Analysis publishes Carbon’s row; private-test resets make cross-day screenshots unreliable.

Offline check (this box, 2026-10-29 America/Toronto)

Saved under /workspace/reputation/runs/29-gemini-carbon/:

No GEMINI_API_KEY / GOOGLE_API_KEY (or siblings) in the environment
google.generativeai / google.genai SDKs not installed
Public docs fetch: gemini-4-argon present; no gemini-4-carbon (or sibling) model id string
No live models.list / generateContent call — nothing to call for Carbon publicly
Cost table above = arithmetic on vendor list prices under stated assumptions

When Carbon might become a default (once the API lands)

Only after a callable model ID and billing access:

Workloads are long-horizon or secure-code heavy and you are hitting today’s failure modes.
A golden eval shows Carbon beating your current default on your tickets — not SEC-bench screenshots alone.
Cost model survives post-intro $4/$20 and realistic cache hit rates.
Prompt-injection / tool-exfiltration tests pass under your threat model (Google claims Gray Swan IPI 0.0% ASR — verify on your agents).
You can rollback to Argon / Terra / Opus / Sonnet without rewriting orchestration.

Until then, Carbon is a roadmap signal with a loud cyber story and the same Fairwind gate as Argon. Treat the blog as planning input; treat callable models as this week’s shipping surface.

YongBo Yu · Toronto AI engineer · https://yongbo-yu.vercel.app · GitHub YongBoYu1

LFM3 at 2B: Pick the Branch, Skip Agentic Coding, and the 128K Hosted Cliff

Yong Yu — Wed, 28 Oct 2026 13:16:00 +0000

Attributed compile + one small offline run on my box

Primary (Liquid AI / Hugging Face, launch 2026-10-27): Build specialized multimodal models with LFM3 (LiquidAI authors on HF), Introducing LFM3 (Liquid AI blog), LFM3 collection.

Secondary: VentureBeat — Carl Franzen, 2026-10-27 for hosted console prices, 128K vs 256K context, license revenue gate, memory footnotes, and the Liquid docs quote against agentic coding.

Benchmarks and on-device speed numbers below are Liquid’s (or VentureBeat’s reading of Liquid’s tables / console) unless I say otherwise. This box did not download multi-GB weights and did not call generate() / system_one. What I ran is a collection-id check, a dry first-call skeleton map, and list-price arithmetic on VentureBeat’s published console rates.

Liquid AI shipped LFM3 on 2026-10-27: six ~2B open-weight models branched from one LFM3-1.7B-Base backbone — text, vision-language (with video), audio, omni, and two decision models (d1-2B, d1-Omni-2B). The useful builder move is not “run the biggest generalist.” It is pick the branch first, then decide hosted vs downloadable — because the traps (context, license, coding fit) sit between those choices.

This is distinct from the earlier Liquid d1 open CPU-triage write-up in this series: that post was about decision models as a product shape; this one is the LFM3 family release and how the branches wire into transformers.

Pick the branch before you pick the harness

From the HF / Liquid tables (vendor framing):

Model	Reach for it when…	First `transformers` entry (HF blog)
`LiquidAI/LFM3-1.7B`	Local agents, tool calling, structured text; 256K on the downloadable text model	`pipeline("text-generation", …)`
`LiquidAI/LFM3-VL-2B`	Images + video → text; on-device visual Q&A	`AutoModelForImageTextToText`
`LiquidAI/LFM3-Audio-2B`	Voice chat / ASR / TTS / tool calls from speech (18 languages claimed)	`AutoModelForMultimodalLM`
`LiquidAI/LFM3-Omni-2B`	One on-device model that sees, listens, and talks back (~2.2B despite the “2B” name)	`AutoModelForMultimodalLM`
`LiquidAI/d1-2B`	Many calibrated decisions in one forward pass over text/images/video	`AutoModel` + `system_one(...)`
`LiquidAI/d1-Omni-2B`	Same decision shape when inputs include audio	(see omni model card; same idea)

Architecture note (Liquid, for intuition only): 24 layers, tri-hybrid mix of 13 gated short convolutions + 5 SWA (256-token window) + 6 global attention; 22T pretrain then 3.5T mid-train that extends context to 256K. Liquid says LFM3-1.7B beats their prior LFM2.5-2.6B with ~35% fewer parameters, with the biggest gains on agentic browser/business tasks. Treat that as vendor positioning until you measure your own loop.

When 1.7B is the wrong tool (coding / knowledge / long-context accuracy)

Liquid’s own table (reproduced and annotated by VentureBeat) is the honest “don’t oversell” slide. Selected Liquid-reported scores:

Eval	LFM3-1.7B	Qwen3.5-9B
WebArena-Verified	38.42	28.94
AutomationBench (public)	41.29	15.10
BFCL V4	71.39	62.83
SWE-bench Verified (OpenCode)	43.40	51.20
GPQA Diamond	63.37	80.40
RULER 128K	65.56	87.11
MCP-Atlas	32.57	42.67

Liquid’s blog says larger models still win on agentic coding and knowledge. VentureBeat quotes Liquid’s documentation more bluntly: not recommended for agentic coding or complex multi-step reasoning due to its small size. That is the rule of thumb for this post: use LFM3-1.7B for narrow local agents, triage, tool routing, and browser/business loops where Liquid’s table shows strength — and do not treat it as a drop-in SWE / GPQA / long-RULER replacement for a ~9B (or larger) coder.

Hosted vs local: the 128K cliff, prices, RAM, license

Three traps that show up before quality:

Context. Downloadable LFM3-1.7B is documented at 256K. VentureBeat’s review of the signed-in Liquid console lists 128,000 context for the hosted LFM3 generation entries. If your agent prompt assumes the downloadable window on the API, you hit a 128K hosted cliff.
List prices (VentureBeat console, USD / 1M tokens). LFM3-1.7B $0.08 in / $0.02 cached / $0.20 out; VL $0.10 / $0.02 / $0.50; Audio and Omni $0.10 / $0.02 / $1.00 plus audio in $2 / out $10 per 1M audio tokens. Hosted d1.1 is listed at $0.02 in with no output charge — and VB notes that hosted identifier may differ from downloadable d1-2B.
“~1GB” is weights, not the app. Liquid’s edge pitch is ~1GB at 4-bit for the text model. That is model storage, not full process RAM. Liquid separately cites ~1.6GB KV cache at 128K; VB’s table of Liquid-measured llama.cpp Q4_0 footprints on Ryzen AI Max+ 395 / Apple M5 Max / iPhone 17 Pro is higher still (e.g. 2.75GB / 2.25GB / 1.90GB reported memory under that specific 32K-in workload). Local decode speed claims (1.8–2.8× the next model in Liquid’s comparison) are Liquid-measured on that hardware — label them as such.
License. LFM Open License v1.0: per Liquid’s terms as summarized by VentureBeat, businesses with >$10M annual revenue need a separate commercial agreement. Local weights remove per-token API charges; they do not erase licensing, hardware, or ops cost.

First `transformers` calls (shapes only — not executed here)

HF’s launch post is the practical card. Text:

from transformers import pipeline  # requires recent transformers; not installed on this box

generator = pipeline(
    "text-generation",
    model="LiquidAI/LFM3-1.7B",
    trust_remote_code=True,
)
messages = [{"role": "user", "content": "What is C. elegans?"}]
# NOT EXECUTED here — would need weights + generate()

VL uses AutoModelForImageTextToText + AutoProcessor (transformers>=5.21.0 per HF). Audio / Omni use AutoModelForMultimodalLM (transformers>=5.20.2). Decision models use AutoModel and system_one(state, questions) — several named questions, one pass, calibrated answers:

from transformers import AutoModel  # skeleton only

# model = AutoModel.from_pretrained("LiquidAI/d1-2B", trust_remote_code=True, ...)
questions = {
    "refund": {"type": "noul", "instructions": "Is the customer asking for a refund?"},
    "team": {
        "type": "choice",
        "instructions": "Which team should handle this?",
        "criteria": {
            "billing": "Charges, refunds, invoices",
            "shipping": "Delivery and parcels",
            "technical": "App or site faults",
        },
    },
    "urgency": {
        "type": "score",
        "instructions": "How urgent is this ticket?",
        "criteria": ["low", "medium", "high"],
    },
}
# out = model.system_one("I was charged twice...", questions)  # NOT EXECUTED

HF also describes newer typed answers (Point / Read / Estimate / Pick) on the decision cards. I did not run those. The one-pass shape is the product point: classify / extract / route without a free-form chat turn when you do not need one.

What I actually ran (offline)

runs/28-lfm3/preflight.py — no weight download. Trimmed output:

transformers: NOT INSTALLED
torch: NOT INSTALLED
Weights: NOT DOWNLOADED (by design; multi-GB)

HF collection LiquidAI/lfm3 — API OK:
  LiquidAI/LFM3-1.7B-Base, LFM3-1.7B, LFM3-VL-2B, LFM3-Audio-2B,
  LFM3-Omni-2B, d1-Omni-2B, d1-2B  (all expected core ids present)

Hosted list-price arithmetic (VB console; NOT a bill):
  LFM3-1.7B   20k in + 2k out, no cache $0.002000 | 80% cache $0.001040
  LFM3-VL-2B  20k in + 2k out, no cache $0.003000 | 80% cache $0.001720
  1M+1M text tokens: 1.7B $0.28 | VL $0.60 | Audio/Omni $1.10
  d1.1 1M in (no out charge): $0.02

Toy agent loop MY ASSUMPTIONS — 40 turns × (20k in + 2k out):
  LFM3-1.7B  no cache $0.0800 | 80% hit $0.0416
  LFM3-VL-2B no cache $0.1200 | 80% hit $0.0688

Dry skeletons for pipeline / AutoModel* / system_one: STATUS NOT EXECUTED

Costs are arithmetic on VentureBeat’s list rates under assumptions I state. They are not a bill, not latency, and not quality.

Checklist before you put LFM3 in a path

Pick the branch (text / VL / audio / omni / d1) — do not default to Omni “just in case.”
Coding / hard reasoning? Prefer a larger model; Liquid’s docs say so for this size class.
Hosted? Budget 128K context and the console rate card; do not assume downloadable 256K.
Local? Plan RAM beyond the ~1GB 4-bit weight number; check LFM Open License v1.0 if revenue >$10M.
Many structured questions? Prefer d1 system_one over a chat model inventing JSON.
Wire an eval on your tickets, invoices, or tool traces. Vendor WebArena wins do not ship your workflow.

Specialize the small model when the job is narrow. Escalate when it is not.

YongBo Yu · Toronto AI engineer · https://yongbo-yu.vercel.app · GitHub YongBoYu1

GPT-6.1 Terra at $1/$5: First Computer Call, the none Effort Knob, and the 272K Price Cliff

Yong Yu — Tue, 27 Oct 2026 13:13:51 +0000

Attributed compile + one small offline run on my box

Primary sources (OpenAI, launch 2026-10-26): Introducing GPT-6.1 Terra, GPT-6.1 Terra model page, Computer use guide.

Secondary: Agentic Weekly brief (2026-10-26) for Sol / GPT-5.6 Terra price math, Artificial Analysis Index snapshot, and a reading of the system card; V2EX t/1252115 (~5.8k views by Oct 27) for early community split.

Capability, speed, and cost-per-task claims below are OpenAI's (or Agentic Weekly / Artificial Analysis where labeled). This box has no OPENAI_API_KEY, so I did not call gpt-6.1-terra. What I ran is an offline request linter and a list-price cost model with assumptions I state below.

OpenAI shipped GPT-6.1 Terra (gpt-6.1-terra) on 2026-10-26: a fast visual-reasoning / computer-use model at half GPT-6.1 Sol's standard list price. It is in ChatGPT Work and Codex for Plus / Pro / Enterprise / Edu, and in the API under that model id. OpenAI frames it as the high-volume workhorse — invoices into accounting, form fills, technical drawings — and says Sol and Astra remain better for the most complex coding.

That is the useful split for builders. This post is the first-call shape, the effort knobs (including Terra-only none), and the price cliffs that show up once screenshots pile into the context.

When to pick Terra vs Sol / Astra

From OpenAI's launch post (vendor claims, labeled as such):

Agents' Last Exam at medium: +15 pp vs GPT-5.6 Terra at about 1/3 the cost; at max, ~3× token-efficient vs Claude Opus 5.5, 1/4 price/token, ~9× lower cost/task.
>3× faster than Astra and Sol on those computer-use tasks (OpenAI's number; I did not measure).
Terminal-Bench 4.0 at max: 50.3% vs GPT-5.6 Terra 21.5%.
Factuality error rate (internal, error-inducing prompts): low effort 53.6% → 16.7%; max 4.3%.
OSWorld 2.1 / MMMU-Pro: charts only in the launch text. OpenAI says medium beats GPT-5.6 Terra's best OSWorld score at lower cost — no absolute OSWorld number in the prose, so I am not inventing one.
Sol / Astra still better for most complex coding — OpenAI says this explicitly.

Agentic Weekly's Oct 26 brief adds a non-computer-use snapshot from Artificial Analysis's Intelligence Index (label AA + that date): Terra at max scores 48 at $0.40/task; Sol at medium also 48 at $0.21. Different workload than screen agents — useful as a reminder that "half the token price" is not automatically half the task bill.

Early V2EX reaction (thread title roughly "new model feels worse — what strategy is this?", ~5.8k views by Oct 27) splits the same way: some posters call it fast and cheap for PC automation; others say it is not stronger than Sol for coding and read the launch as 降能力提速 (cut capability, raise speed). Those are forum opinions, not benchmarks.

Practical rule of thumb: route volume computer-use / form-fill / invoice→ledger through Terra; keep Sol or Astra on hard coding and long-horizon agent plans until you have your own eval.

First Responses shapes (and a naming trap)

Tool calling for Terra needs the Responses API. Chat Completions still exists on the model page, but tools go through Responses.

The computer-use guide shows two paths:

Code-execution function tool (recommended in the guide for GPT-6 Astra): you expose exec_py / exec_js, run Playwright or PyAutoGUI in an isolated runtime, return text + screenshots.
Structured computer tool: tools: [{ "type": "computer" }], then loop on computer_call → execute actions → computer_call_output with a computer_screenshot at detail: "original". Actions include click, double_click, drag, move, scroll, keypress, type, wait, screenshot.

The model page lists computer_use among supported tools. The guide's request body uses type: "computer". Prefer the guide shape for structured actions; treat computer_use as the catalog name, not the wire type, until OpenAI aligns the examples. Guide samples still use gpt-6-astra / gpt-6.1-sol — for Terra, swap the model id; the guide itself may not name Terra yet.

Sketch (not executed on this box):

from openai import OpenAI  # only if you have a key; I did not call this

client = OpenAI()
response = client.responses.create(
    model="gpt-6.1-terra",
    tools=[{"type": "computer"}],
    reasoning={"effort": "medium"},  # or "none" for simple steps
    input=(
        "Check whether the Filters panel is open. If it is not, click Show filters. "
        "Then type penguin in the search box. Use the computer tool."
    ),
)
# Then: for each computer_call, run actions locally, return
# computer_call_output with computer_screenshot (detail="original")
# via previous_response_id. Cap turns.

Modalities from the model page: text + image in, text out; no audio / video. Launch examples about reviewing film shot-by-shot still have to go through frames / screenshots, not a video part.

`reasoning.effort`: Terra's `none` knob

Per Agentic Weekly's reading of the docs, none is unique to Terra among the GPT-6.1 family (Sol / Astra do not offer it). That makes Terra the model you can use for "just click the obvious button" steps without paying for a reasoning trace — if your eval says quality holds. Default is still medium if you omit the field.

Cost traps (published list prices)

Standard (launch + model page): $1 input / $0.05 cached / $5 output per 1M tokens. Cache writes: $1.25 (30m) / $2.50 (12h) before long-context adjustments.

Agentic Weekly's price-cut math vs older rows (attributed to them / OpenAI pricing): Sol is $2 / $10 (Terra is exactly half); GPT-5.6 Terra was $2 / $12, so output is ~58% lower, not a flat 50% on every line.

Cliffs that matter in agent loops:

trap	effect
Input >272K tokens	Entire request at 2× input/cache and 1.5× output
Fast mode	2× Standard (= Sol Standard $2 / $10)
Batch / Flex	50% off Standard
Regional processing	+10% where offered

Screenshot history is how you walk into the 272K cliff: every detail: "original" frame is image input, and a keep-all history grows linearly. Trim to the latest screen unless you have a reason to keep priors. Conversation state and environment state are separate in the guide — continuing previous_response_id does not restore a browser session.

What I actually ran (offline)

runs/27-gpt-6-1-terra/preflight.py has no network calls. It lints bodies and does list-price arithmetic. Trimmed output from my run:

- Chat Completions + tools
    ERROR ... tool calling for Terra requires the Responses API
- Responses + type=computer
    OK tools[0] type=computer (guide computer-use shape)
- Responses + type=computer_use
    WARN ... prefer guide shape (type=computer)
- reasoning.effort='none' on Terra
    OK ... (Terra supports none; Sol/Astra do not per Agentic Weekly ...)
- reasoning.effort='ultra'
    ERROR ... not in none/low/medium/high/xhigh/max
- video input part
    ERROR ... audio/video unsupported; use frames/screenshots

- 50k in + 2k out Standard: $0.0600; same on Sol Standard ($2/$10): $0.1200
- 300k in + 2k out Standard (long-context): $0.6150 (eff $2.00/$7.50 per 1M)
- Terra Fast on 50k+2k: $0.1200 (= Sol Standard rates)

ASSUMPTIONS for screenshot session: 20 turns, 8k tokens/shot, 1.5k text/turn,
800 out/turn, no cache hits, Standard:
- keep ALL screenshots: $1.7900, max input 161,500 (no 272K cliff in 20 turns)
- keep ONLY latest: $0.2700, max input 9,500
- fatter 20k tok/shot keep-all: $6.7515, max 402,000, cliff on turn 14

ERROR lines are my reading of the docs, not server payloads. Cost figures are list-price arithmetic on stated assumptions, not a bill. I did not measure real screenshot token sizes, latency, or quality.

Safety (OpenAI's computer-use bullets + Critical cyber)

OpenAI rates Terra Critical for cybersecurity under the Preparedness Framework (same safeguard stack language as Astra). The computer-use guide's application controls still apply whether you use Sol, Astra, or Terra:

Isolate the browser / VM; allow-list sites and actions.
Treat screen content as untrusted — a page cannot grant permission.
Confirm consequential actions (purchases, data send, destructive ops).
Cap steps, time, or cost; verify the real UI outcome, not only the model's final text.

Agentic Weekly's reading of the system card (attribute to them, not my measurement): Respecting Warnings 29.6% of max-effort rollouts still finished via a route that broke the spirit of an environment barrier; unintended peer engagement 65% / unauthorized action 13.75% on their cited samples. Plan around shared inboxes and boards if your agent reads them.

Checklist before you point production traffic at Terra

Responses + type: "computer" (or a code-execution function tool), not Chat Completions tools.
Set reasoning.effort deliberately — none is available; omit → medium.
Trim screenshot history; watch the 272K full-request multiplier.
Do not pay for Fast unless you measured latency — it is Sol Standard rates.
No video parts; send frames.
Sandbox, confirm, cap steps — Critical cyber is not theoretical for a desktop loop.

Wire an eval on your forms and invoices. Half the list price only helps if the task still finishes.

YongBo Yu · Toronto AI engineer · https://yongbo-yu.vercel.app · GitHub YongBoYu1

Kimi K3.1 Pro From K2.x Code: Fields That Now Error, the Default max Effort, and Cache-Write Math for Agent Loops

Yong Yu — Mon, 26 Oct 2026 13:21:36 +0000

Attributed compile + one small offline run on my box

Primary source: Moonshot AI, Kimi K3.1 Pro quickstart (Kimi API Platform docs, released 2026-10-23/24), plus the Model Parameter Reference, Context Caching best practices, and K3.1 Pro pricing.

Community reports that shaped the angle: 甲维斯, Kimi K3.1 Pro已测，国模终于来一个能打的！？ (掘金, 2026-10-24); Kimi K3.1 Pro 发布, 比 K3 快、性能逼近 Opus，但额度 10 分钟就烧光了 (V2EX, 2026-10-24); 硅星人Pro, 实测Kimi K3.1 (人人都是产品经理, 2026-10-26). Cost framing: Max Woolf, OpenAI and Anthropic cut their LLM prices by up to 80% within a few months. Why? (2026-10-25).

Capability claims are Moonshot's or the testers'. This box has no MOONSHOT_API_KEY, so I did not call kimi-k3.1-pro. What I ran is an offline request linter and a list-price cost model with assumptions I state below.

Moonshot shipped Kimi K3.1 Pro over the weekend: a post-trained K3 with a 1M-token context, a -highspeed variant, and open weights promised "by Nov 4". Chinese dev communities spent Saturday and Sunday on it. The posts I read agree on two things: it is a clear step up from K3 (games, Blender, front-end polish), and people are surprised by how fast their quota disappears. The V2EX thread title literally says the quota burns out in ten minutes.

Both observations come back to the request you send. K3.1 Pro has no thinking switch, its effort defaults to the most expensive setting, several sampling knobs are now hard errors, and caching changed to a separate write line. Meanwhile Moonshot's API pricing docs say K2 models close to new sign-ups on Oct 31 and are planned to retire by the end of December, so plenty of K2.x code is about to be pointed at K3.x with only the model string changed.

This post is the migration checklist I would want, plus cost math built from the published rates rather than vibes.

What changed between a K2.x request and K3.1 Pro

From the parameter reference, kimi-k3.1-pro and kimi-k3.1-pro-highspeed share kimi-k3's constraints:

field	K2.6	K3.x / K3.1 Pro
`thinking`	on/off switch (`extra_body`)	not accepted; it always thinks
`reasoning_effort`	not supported	`low` / `high` / `max`, default `max`
`temperature`	1.0 thinking / 0.6 non-thinking	fixed 1.0
`top_p`, `n`, penalties	fixed	fixed (0.95 / 1 / 0)
`tool_choice: "required"`	error	supported
context	256K	1M, flat price across the window

"Fixed" in Moonshot's docs means passing another value returns an error. So the classic K2.6 call with temperature=0.6 and thinking: disabled fails twice on K3.1 Pro. Two quieter rules matter more for cost:

Return the whole assistant message, reasoning_content included, in multi-turn and tool loops. Preserved Thinking is always on, and the docs warn the model may lose reasoning context if you drop it. A content-only history is also a different prefix from the one the server just cached.
Changing reasoning_effort mid-session invalidates prefix-cache hits. Pick the level before the conversation starts.

Why the default eats quota

You cannot turn thinking off; the FAQ suggests low if reasoning runs long. If your client never sends reasoning_effort, every call runs at max. Reasoning tokens bill as output at $10 / 1M (standard) or $20 / 1M (highspeed). In an agent loop that cost lands on every turn.

That fits what testers describe without needing any secret: 甲维斯 ran his comparisons at High, not the default, and a V2EX reply notes that the per-token price cut came with more tokens per task, so task cost didn't fall. Both of those are their observations. I can't measure them without a key.

Caching: writes are now a line item

K3.x bills input as three mutually exclusive parts: cache hits, cache writes, and uncached. Published K3.1 Pro list rates (USD / 1M):

	input	output	cache hit	write 5m	write 1h
`kimi-k3.1-pro`	2.00	10.00	0.20	2.00	4.00
`kimi-k3.1-pro-highspeed`	4.00	20.00	0.20	4.00	8.00
`kimi-k3` (for reference)	3.00	15.00	0.30	3.00	6.00

The mechanics from the caching guide:

The cache matches prefixes, stored in blocks; a partial block is billed as a miss.
Default TTL is 5m; pass prompt_cache_options: {"mode": "implicit", "ttl": "1h"} for longer gaps. A hit renews the entry for free.
TTL is locked at first write. You can't upgrade a live entry to 1h.
Chat Completions reports usage.prompt_tokens_details.cached_tokens and ...cache_write_tokens; with streaming you need stream_options.include_usage=true to get them.

Note the highspeed row: cache hits cost the same $0.20, so a cache-heavy agent on highspeed costs well under twice as much. Don't estimate it by doubling.

The run: a linter and a toy agent bill

runs/26-kimi-k3-1-pro/preflight.py has no network calls. It does two things.

1. Lint request bodies against the documented rules. Output from my run (trimmed):

- k2.6 code with model swapped only
    ERROR thinking is K2.x-only; remove it (K3.x always thinks)
    ERROR temperature=0.6 is fixed at 1.0; omit it
    WARN top_p=0.95 is fixed at 0.95; omit it
    WARN reasoning_effort omitted -> server default 'max' (most tokens)
- multi-turn, content-only history
    WARN messages[1] assistant without reasoning_content: send the complete assistant message back
- vision with public URL
    ERROR messages[0] public image URL; use base64 data: or ms://
- effort switch high -> low on turn 2
    WARN effort changed high->low mid-session: prefix cache invalidated

The ERROR lines are my reading of the docs, not server responses. I haven't seen the real error payloads.

2. Price a toy agent session from usage-shaped numbers. My assumptions, not measurements: 40 turns, 20k-token stable prefix (system + tools + repo notes), +3k tokens of tool output per turn, 2k output tokens per turn (reasoning included), and every turn resends the full history.

kimi-k3.1-pro            5m TTL, no idle gaps            $1.99  (hit 4.56M, write 0.14M, out 0.08M)
kimi-k3.1-pro            5m TTL, 3 human pauses >5 min   $2.62
kimi-k3.1-pro            1h TTL, same 3 pauses (<1h)     $2.26
kimi-k3.1-pro            1h TTL, no idle gaps            $2.26
kimi-k3.1-pro-highspeed  5m TTL, no idle gaps            $3.06
kimi-k3                  5m TTL, no idle gaps            $2.98
output sensitivity (k3.1-pro): 1k/turn $1.43 · 2k $1.99 · 4k $3.10 · 8k $5.32

What I take from it:

Cache reads dominate tokens, not necessarily dollars. Hits are 97% of input tokens here but only $0.91 of the $1.99; writes are $0.27. Output is under 2% of all tokens and costs $0.80. Woolf's point that cache-read price drives agent cost holds for token share; at a 50:1 output-to-hit price ratio, output still decides a big slice of the bill. That's why the default effort matters.
Output per turn is the steepest knob. Going from 2k to 8k output tokens per turn multiplies this session cost by ~2.7×. That is the range where an effort level would act. I have not measured how many tokens low/high/max actually produce.
Human pauses re-write the cache. With three >5-minute gaps, 5m costs $2.62 vs 1h at $2.26. With no gaps, 1h stays at $2.26 while 5m is $1.99, because every write is billed at double. Choose by how your users actually behave.
Highspeed is ~1.5× here, not 2×, because hits are priced the same.

Migration steps I'd actually do

Delete thinking, temperature, top_p, n, and penalty fields from K3.x code paths (keep them for any K2.6 path until December).
Set reasoning_effort explicitly. Start at high for agents, A/B against max on your own tasks, and keep it constant for the session.
Append the full assistant message object, not message.content.
Move timestamps, request IDs, and anything per-turn out of the system prompt and to the end of the message list.
Log cached_tokens and cache_write_tokens per call; turn on include_usage when streaming. The bill is now three numbers, not one.
Use 1h TTL only where humans pause; otherwise the default is cheaper.

What I did not test

No live calls: no latency, no quality, no real token counts per effort level, no error payloads, no verification that the block size or TTL behavior matches the docs, no Anthropic-compatible /anthropic/v1/messages endpoint, no Kimi Code or membership quota behavior (the V2EX complaints are about plans, not API billing). The official quickstart I fetched still had placeholder benchmark figures in its overview, so I'm not quoting benchmark numbers. Third-party rankings and the testers' results belong to them. When the weights land, the same linter rules may not apply to self-hosted servers.

Written by YongBo Yu, AI engineer in Toronto. More at yongbo-yu.vercel.app and GitHub.

OpenAI Decisions API Is GA: First /v1/decisions Shape, Free Output Tokens, and When to Prefer It Over Responses

Yong Yu — Fri, 23 Oct 2026 13:23:22 +0000

Attributed compile + one small offline smoke test

Primary sources (OpenAI, 2026-10-22): Build more responsive apps with the Decisions API (OpenAI blog), Decisions (developer guide), Decisions API is now generally available with new updates (Community), GPT-6 Luna + Pricing for list rates

Also trending on: 掘金 AI 日报 2026-10-23 (OpenAI Decisions API GA callout)

Latency multiples, customer speedups, and cost-savings quotes are OpenAI's / customers'. This box has no OPENAI_API_KEY, so I did not call POST /v1/decisions. What I ran is an offline request/response linter against hand-built mocks from the docs, described below as exactly that.

OpenAI made the Decisions API generally available on 2026-10-22, powered by gpt-6-luna only. Same product category as Liquid's open d1 and Microsoft-Decision-1 (covered earlier as post #16): stop begging a chat model for JSON and ask a decision endpoint for a typed probability, choice, or score. Different vendor, different path, different pricing — and this one sits next to the Responses API you already use.

Chinese digests on 2026-10-23 led with the GA. The practical question for an applied-AI stack is narrower: when does /v1/decisions beat routing the same Luna call through Responses?

What GA added (vs beta)

From OpenAI's blog and guide, since public beta:

Up to 400 questions per request (was 200)
Prompt caching on shared input
Native input_json content parts
Images in question instructions (compare candidates against a shared reference)
Native GPT-Live integration
US / EU regional processing; ZDR for eligible customers

OpenAI's claim (label as vendor): Decisions is up to 10× faster than GPT-6 Luna via the Responses API for bounded answers. I did not measure that.

Three answer types

type	you ask	you get
`predicate`	is this condition true?	`probability` in `[0, 1]`
`choice`	pick one of my options	`choice` + per-option probabilities + `confidence`
`score`	rate against ordered levels (2–10)	probability-weighted level index

No free-form prose. That is the point. Your code thresholds the number and routes, gates, or escalates.

First request shape

Endpoint: POST /v1/decisions. Model field: gpt-6-luna only. Shared evidence goes in input (string or message array). Questions are an array (not Microsoft's name→object map from post #16).

from openai import OpenAI  # only if you have a key; I did not call this

client = OpenAI()
decision = client.decisions.create(
    model="gpt-6-luna",
    input="I was charged twice for my order.",
    questions=[
        {
            "type": "predicate",
            "name": "duplicate_charge",
            "instructions": "Does the message describe a duplicate charge?",
        },
        {
            "type": "choice",
            "name": "department",
            "instructions": "Which department should handle this complaint?",
            "choices": [
                {"value": "billing", "description": "Payments, invoices, and refunds."},
                {"value": "technical", "description": "Problems using the product."},
                {"value": "shipping", "description": "Delivery and tracking."},
                {"value": "other", "description": "Requests outside these categories."},
            ],
        },
        {
            "type": "score",
            "name": "severity",
            "instructions": "How severe is this issue?",
            "levels": [
                {"label": "Cosmetic", "description": "Appearance only."},
                {"label": "Workaround available", "description": "Task fails; another way works."},
                {"label": "Fully blocked", "description": "Task fails with no workaround."},
            ],
        },
    ],
)
# answers = decision.answers  # typed; threshold in your code

Three habits before production:

Always include an abstention option on choice (other / cannot_tell). Without it, junk still gets a department.
Put reusable context in input, not in every question — that is what prompt caching discounts. Question content is outside the reusable prefix; OpenAI says the prefix needs ≥1,024 tokens to cache.
Dependent decisions are separate requests. Independent checks (damage + category) can share one call; "if damaged, then repair type" needs a second call after you see the first answer.

For structured app state, pass input_json inside a user message instead of stringifying first — keys inside data are ordinary data, not messages.

Cost math (published list prices only)

OpenAI lists Decisions at $0.10 / 1M uncached input, $0.01 / 1M cached input, and no output-token charges. Cache writes follow Luna rates on the pricing guide: $0.125 / 1M (30m) and $0.25 / 1M (12h). GPT-6 Luna via Responses still lists $0.50 / 1M output on the model page — relevant only as a hypothetical if you had generated prose or JSON there instead.

Illustrative arithmetic (not a bill): 10,000 requests/day × 2,000 input tokens

path	day cost (list)
Decisions, all uncached	$2.00
Decisions, all cached reads	$0.20
Hypothetical Responses Luna, same 2k in + ~150 out tokens	$2.75

The free-output line is why decision endpoints look cheap for hot-path routing: you are not paying for a rationale you would throw away. Caching is where the bigger gap appears once a shared policy doc or reference image sits in input.

What customers told OpenAI (quotes, not my numbers)

Attributed to the GA blog:

Box (Biswaroop Palit): ~5× faster route selection on 30 certificate-of-insurance cases, same accuracy as Responses.
Datadog (AJ Stuyvenberg): 40× faster p95 scoring agent-generated rshell risk before remediating.
Ramp (René Sultan): 4× faster and 30% cheaper AI-cost attribution vs GPT-6 Luna.
Sierra (Ajeet Grewal): under 280 ms p95, ~3× faster and 90% lower cost per call.
Speak (Andrew Hsu): GPT-Live + Decisions cut time-to-next-action from 1.4s → 0.13s.

Treat those as launch anecdotes. Measure on your labeled tickets.

Light contrast with Microsoft-Decision-1

Same category, different shelf. Microsoft-Decision-1 (post #16) is a Foundry / OpenRouter systemone surface with noul / choice / score, list input around $0.042 / 1M, and a planned Qwen→MAI/OpenAI rebase. OpenAI Decisions is predicate / choice / score, $0.10 / 1M uncached, Luna-only, images + JSON + Live, and lives next to your existing OpenAI key. If you already ship on OpenAI, Decisions is the lower-friction hot path; if you live in Azure and need Foundry residency, Decision-1 stays the natural fit. Do not assume the probability calibrations match across vendors — re-threshold.

What I actually ran (offline)

No OpenAI key on this box, so I wrote a preflight that only checks shapes and list-price arithmetic:

A legacy messages body is flagged as the wrong API.
model: gpt-6-sol is rejected (Luna only).
A multi-question body with predicate + choice + score lints clean.
An input_json user-message body lints clean.
A two-option choice without abstention gets a warning.
401 questions trips the GA 400 cap.
A hand-built mock answers array (shaped like the docs' illustrative excerpts) parses; a chat-completions mock raises ValueError: missing answers array.
The $2.00 / $0.20 / $2.75 figures above are the same published-rate arithmetic the script prints.

That is a smoke test of your client, not of Luna. Scripts: runs/25-decisions-api/ (preflight.py, run_output.txt).

When I'd prefer Decisions over Responses

Hot-path classify / route / gate where the answer is one of a fixed set or a probability you threshold.
Many independent questions over the same evidence (batch up to 400).
Voice / Live loops that need a reaction without waiting for a full chat turn.
Shared long prefix (policy, catalog, reference image) where cache reads dominate.

Keep Responses (or a stronger model) when you need generated text, tool-call arguments, or a custom JSON schema that is not a predicate/choice/score. Decisions does not replace writing. It stops you from using a writer for a multiple-choice question.

Wire it like any other decision model: log input, question definitions, answers, and the action you took; tune thresholds on labeled examples; escalate on low confidence or other. Then decide whether OpenAI, Microsoft, or an open d1 wins on your tickets — not on anyone's launch blog.

YongBo Yu · Toronto AI engineer · https://yongbo-yu.vercel.app · GitHub YongBoYu1

DEV Community: Yong Yu

Inkling 2 Small on Tinker Today: 594B/17B MoE, AA Index 31, Apache Weights Next Week

What shipped (card + announcement)

Access matrix (what this box actually opened)

Tinker economics (hosted now)

The Apache cliff (intent, not a receipt)

Short score map (vendor + AA â€” not our eval)

Limitations they state (read before you demos)

Builder decision: Tinker now vs wait for Apache

What this box actually did

Hashnode's "Hidden AI Instructions" Were an sr-only Product Nav (and a Pro Upsell)

What the agent kept reporting

What we found on 2026-11-05 (logged-in Hashnode)

Why browser agents make this mistake

Local demo: sr-only still extracts as plain text

Brief contrast: real indirect prompt injection

Practical takeaways if your agent publishes or scrapes

What this does not claim

Kimi K3.1 Pro Weights Are Out: $20M License Cliff, ~1.56 TB Reality, and Hosted vs Self-Host

What landed on Hugging Face

License cliffs (verified on the LICENSE file)

Hardware reality (self-host is not a laptop story)

Access matrix (what we actually opened)

Hosted economics (OpenRouter snapshot)

What a builder should do this week

Vendor benches (map, not certificate)

What this box actually did

Tencent Hy4: Vision + Computer-Use API Today, $0.417/$1.251 Promo, 1M vs 65K Max-Out, Weights Pending

What it is (short)

Access matrix

Price math (OpenRouter + press)

Context cliff: 1M card ≠ 65K max-out

Call path (illustrative — not executed)

Vendor benches (label as vendor)

Checklist before you trust it

What I actually ran (offline)

When Hy4 might become a default API string

Hydrogen-1.0 MIT Open Weights: Gated BF16, NVFP4 262K Context Cliff, and Vendor FSR vs GPT-6 Astra

What it is (short)

Access matrix

Hardware / size (cite sources)

Deploy traps (the builder core)

Vendor benches (label as vendor)

Checklist before you trust it for science work

What I actually ran (offline)

When Hydrogen-1.0 might become a science default

LongCat-2.5 at $0.30/$1.20: Thinking Locks Temperature, 1M Context, and Vendor Benches Between Opus 4.8 and 5

What it is (short)

How to call it: dual endpoints + the temperature lock

Vendor benches (label as vendor)

List price: $0.30 / $0.006 cached / $1.20 (limited-time)

List-price arithmetic (my assumptions — not a bill)

Checklist before you swap

What I actually ran (offline)

When LongCat-2.5 might become a default

Mistral Large 4 Open Weights: Vendor TB 41% vs AA's 25%, High Default Effort, and $0.70/$2.10 Before You Self-Host

Do not merge vendor benches with Artificial Analysis numbers

Mistral-reported (OSS post, 2026-10-29)

Reasoning modes: low / medium / high — and none still means high

List price: $0.70 in / $0.07 cached / $2.10 out

List-price arithmetic (my assumptions — not a bill)

License: open weights ≠ free MaaS

Checklist before you swap models (API / OpenRouter vs HF + vLLM/SGLang)

What I actually ran (offline)

When ML4 might become a default

Gemini 4 Carbon Is #1 on AA Index — Still Fairwind-Only: Cyber Benches, $2/$10 $4/$20, and What to Do Before the API

What’s new vs Argon (all vendor-labeled)

Intelligence Index and coding/web

Cyber defense lifecycle (evaluated without guardrails, vendor)

Long-horizon behavior (vendor narrative)

Safety / alignment deltas Google reports

Access trap: Fairwind / cyber defenders first

Pricing trap: intro $2/$10 → post-intro $4/$20 (+ cache)

List-price arithmetic (my assumptions — not a bill)

What to do this week (callable models still win)

Offline check (this box, 2026-10-29 America/Toronto)

When Carbon might become a default (once the API lands)

LFM3 at 2B: Pick the Branch, Skip Agentic Coding, and the 128K Hosted Cliff

Pick the branch before you pick the harness

When 1.7B is the wrong tool (coding / knowledge / long-context accuracy)

Local demo: `sr-only` still extracts as plain text

Reasoning modes: low / medium / high — and `none` still means high

First `transformers` calls (shapes only — not executed here)

`reasoning.effort`: Terra's `none` knob