TL;DR
Thinking Machines Lab announced Inkling 2 Small on November 5: a 594B-parameter mixture-of-experts model with 17B active parameters, image input, and a 1M-token context window, available on its Tinker platform with closed weights for now. The list price is $0.30 per million input tokens and $1.00 per million output tokens. Artificial Analysis rates it 31 on its Intelligence Index (median of comparable models: 23), but also reports that it burned 154M output tokens to run the index against a median of 89.8M, and that a task takes 15.7 minutes against a median of 7.4. The reported average cost is $1.18 per task. By my arithmetic only about 13% of that is output tokens, so the cheap-looking output price is not the number that drives the bill. Independent Vals results are uneven: 4th of 37 on Finance Agent, 41st of 61 on Terminal-Bench 4.0. And the weights are not on Hugging Face yet.
Everything marked "my arithmetic" or "illustrative" below is a calculation from the published figures and stated assumptions. Benchmark numbers belong to the lab, Artificial Analysis or Vals, as labeled, and I have not reproduced any of them.
What did Thinking Machines actually announce?
The lab describes Inkling 2 Small as its most capable model and the first of a second generation, with "a big jump in agentic coding and vision." The facts I could confirm across the lab's page and independent listings:
| Item | Value | Where it comes from |
|---|---|---|
| Parameters | 594B total, 17B active per token | Lab announcement |
| Inputs | Text and images, variable effort setting | Lab announcement |
| Context window | Up to 1M tokens | Vals listing, several write-ups |
| Price | $0.30 / $1.00 per million input / output tokens | Vals and Artificial Analysis listings |
| Cached input | $0.03 per million (one write-up of Tinker pricing) | Secondary source, not checked against Tinker |
| Availability | Tinker, closed weights at release | Lab announcement |
Active parameters are about 2.9% of the total (17 / 594), which is the usual sparse-MoE story: you pay memory for the whole model and compute for a small slice of it. Since the weights are not downloadable, the useful questions this week are about the hosted service, not about GPUs.
When do the weights arrive, and under what license?
This is where reports differ, so it is worth being precise. The lab's own wording, as I could read it, is: "Inkling 2 Small is closed weight at release. We intend to release the full weights in the coming weeks, pending the results of additional safety testing." Several outlets report "next week" and an Apache 2.0 license. Those may come from a social post or a longer announcement that I could not retrieve, so I treat "next week" and the license as reported, not confirmed.
I checked what is verifiable. Querying the Hugging Face API for the thinkingmachines organization on November 8 returns no repository for Inkling 2 Small. It does show a track record: the first-generation Inkling (952.4B parameters in BF16, created July 14) and Inkling-Small (266.0B parameters, created July 27) are public under Apache 2.0, each with an NVFP4 variant. That makes the promise credible, though a track record is not a date. Note also that the Vals page already labels the model "open-weight" while the download does not exist yet. If your procurement or compliance process keys off the word "open," wait for the repository and its license file.
You can rerun the check yourself:
import json, urllib.request
url = "https://huggingface.co/api/models?author=thinkingmachines&limit=50&sort=createdAt"
for m in json.load(urllib.request.urlopen(url)):
lic = [t for t in m["tags"] if t.startswith("license:")]
print(m["id"], m["createdAt"][:10], lic)
Why does a $1.00 output price still cost $1.18 per task?
Artificial Analysis reports an average of $1.18 per Intelligence Index task, 154M output tokens for the whole index, 159 tokens per second, and 15.7 minutes per task. One write-up quoting the same data puts the average at about 150,000 output tokens per task, which the lab's earlier model produced at roughly a quarter of that rate according to the same write-up.
Those numbers fit together, which is reassuring. At 159 tokens per second, 150,000 tokens takes 943 seconds, or 15.7 minutes. So the reported time per task is almost entirely generation time.
Now the cost split, in my arithmetic:
- Output: 150,000 tokens x $1.00 per million = $0.15 per task.
- Reported total: $1.18 per task.
- Remainder: $1.03, which must be input-side cost (prompt, tool results, accumulated context re-read on each step) unless the benchmark includes charges I cannot see.
So output is about 12.7% of the bill. The remaining $1.03 corresponds to 3.4M input tokens per task if all of it were billed at the uncached $0.30 rate, or about 34M tokens if all of it were served at the $0.03 cached rate. Agentic tasks re-send a growing context on every step, so numbers in this range are plausible, but the actual split is not published. That uncertainty is the point: the headline output price describes the smaller part of the invoice.
Dividing 154M by the ~150,000 per-task average also suggests the index run covers roughly 1,000 tasks, which would put the total output charge near $154 and the total bill near $1,200. That last step is my own inference from two rounded figures, so treat it as a sanity check, not a measurement.
How much does caching change the picture?
If the input side dominates, the cache hit rate matters more than the output price. Holding my inferred 3.4M input tokens and 150,000 output tokens fixed, and applying the cached rate to a share of the input:
| Cache hit share of input | Cost per task (illustrative) |
|---|---|
| 0% | $1.18 |
| 50% | $0.72 |
| 90% | $0.35 |
| 99% | $0.26 |
These are not measurements of Tinker or of any customer. They assume the $0.03 cached rate applies as quoted, that Artificial Analysis ran with little or no caching, and that the whole $1.03 is input. If any of those is wrong the curve shifts, but the shape does not: going from no caching to mostly cached cuts the bill by roughly two thirds. For an agent you operate, prompt layout (stable prefix first, volatile content last) is likely worth more than haggling over the output rate.
The reverse also holds. Halving the output length would save only $0.075 per task, or about 6%, in the same model of the bill. Verbosity costs you mostly in wall-clock time, not dollars.
Is it verbose compared with its peers?
Yes, and measurably. Artificial Analysis calls it very verbose against a median of 89.8M tokens for the index. In ratios:
| Metric | Inkling 2 Small | Median of comparable models | Ratio |
|---|---|---|---|
| Output tokens for the index | 154M | 89.8M | 1.7x |
| Minutes per task | 15.7 | 7.4 | 2.1x |
| Output price per million tokens | $1.00 | $0.87 | 1.15x |
| Input price per million tokens | $0.30 | $0.24 | 1.25x |
Artificial Analysis itself labels the pricing "somewhat expensive" relative to peers. One way to read the first and third rows together, as an illustration: because it emits 1.7x the tokens, its $1.00 output price is equivalent to about $1.72 per million tokens of median-length answer, roughly twice the $0.87 median. That comparison is crude, since longer outputs may buy more accuracy and the median is taken over a different model set than any one rival, but it shows why a per-token price table can mislead.
On quality the same listing is favorable: a score of 31 and a rank of 4 out of 29 comparable models. So the trade is real. You get a high index score, you pay a bit above the median per token, and you wait about twice as long per task.
What do the independent Vals results say?
The lab reports its own numbers: 86.3% on SWE-Bench Pro v2 (Hard), 72.1% on DeepSWE v1.1, and 81.6% on Vibe Code Bench v1.1. Treat these as vendor-reported. Vals runs benchmarks itself, and its listing for the model shows a Vals Index of 56.08% (plus or minus 1.18), ranked 19th of 34, at $3.509 per test and a 50 minute 35 second latency.
One check lines up: the lab's 81.6% on Vibe Code Bench matches Vals' 81.55% (plus or minus 3.45). That is mild corroboration. It also shows how little a high score says by itself, because 81.55% ranks only 28th of 125 on that benchmark.
The more useful view is rank as a share of the models listed on each benchmark:
The pattern is clear. It does well on finance, legal and tax work (4th of 37 on Finance Agent v2.1, 7th of 37 on the Finance Index, 7th of 35 on the Legal Index, 5th of 35 on HLAB-Vals-1.1, 12th of 82 on Tax Agent Bench). It is middling on security and biology. And it is in the lower half on terminal and ops work: 41st of 61 on Terminal-Bench 4.0 (12.63%), 27th of 37 on SRE Bench (1.91%), 33rd of 44 on Terminal-Bench-Science (2.86%). The absolute scores on those last three are low for every model, so the rank is what carries information. A write-up of the Artificial Analysis results likewise says it lags on terminal tasks and physics.
Two caveats. The number of models differs per benchmark (21 to 125), so percentages across rows are not strictly comparable. And Vals' cost and latency figures describe its own suite, not yours.
So who should use it, and how would you test it?
My read, labeled as opinion:
- Good fit: document-heavy professional workflows (finance, legal, tax), where it ranks near the top and where an extra few minutes per task rarely matters.
- Poor fit: latency-sensitive loops and terminal or SRE style automation, where it ranks lower and where 15 minutes per task hurts.
- Cost control: design for cache hits first, cap output length second.
- Self-hosting: wait for the weights, the license text, and a quantized checkpoint before you plan hardware. Do not size a cluster from a press cycle.
A small harness gives you your own answer in an afternoon. Run 50 of your real tasks and record output tokens, input tokens, cache hits and wall time per task, then compute cost from your invoice rather than from list prices:
import statistics as st
PRICE = {"in": 0.30, "cached": 0.03, "out": 1.00} # USD per million tokens, from the listings
def task_cost(t):
fresh = t["input_tokens"] - t["cached_tokens"]
return (fresh * PRICE["in"] + t["cached_tokens"] * PRICE["cached"]
+ t["output_tokens"] * PRICE["out"]) / 1e6
def summarize(tasks):
costs = [task_cost(t) for t in tasks]
print("tasks", len(tasks))
print("median cost $%.3f" % st.median(costs))
print("p90 cost $%.3f" % st.quantiles(costs, n=10)[-1])
print("median out %d tokens" % st.median(t["output_tokens"] for t in tasks))
print("median secs %.0f" % st.median(t["seconds"] for t in tasks))
Compare the median and p90, not just the mean, because agent runs have a long tail.
FAQ
How much does Inkling 2 Small cost?
List price is $0.30 per million input tokens and $1.00 per million output tokens, with cached input at $0.03 per million according to one write-up of Tinker pricing. Artificial Analysis reports an average of $1.18 per Intelligence Index task.
Is Inkling 2 Small open source?
Not yet. The lab says it is closed weight at release and intends to publish full weights in the coming weeks after additional safety testing. Outlets report an Apache 2.0 license, but I could not confirm that from the lab's page, and no Inkling 2 repository existed on Hugging Face on November 8.
Why is it slower than other models?
It generates more tokens per task (154M for the index against a median of 89.8M) at 159 tokens per second. At about 150,000 output tokens per task, generation alone is about 15.7 minutes, matching the reported time.
What is it good at, according to independent tests?
On Vals it ranks near the top on finance, legal and tax benchmarks and in the lower half on Terminal-Bench 4.0 and SRE Bench. Its overall Vals Index is 56.08%, ranked 19th of 34.
Are the lab's benchmark numbers independent?
No. SWE-Bench Pro v2 (Hard), DeepSWE and the lab's Vibe Code Bench figure are lab-reported. Artificial Analysis and Vals results are third-party. The one overlap, Vibe Code Bench, agrees within the margin.
How can I lower my bill?
Structure prompts so a long stable prefix is cached, and measure your own cache hit rate. In my illustrative model a 90% hit rate cuts the per-task cost from $1.18 to about $0.35.
Further reading
- Baidu's ERNIE-5.5-Flash-Base: can you self-host a 280B open model, and who is allowed to?
- Is open-weight really 90% as good at 10% of the cost? Checking IBM's claim against list prices
Sources: Thinking Machines Lab, Inkling, Vals listing for Inkling 2 Small, Artificial Analysis model page, af.net coverage of the index score, ai-tldr release summary, Hugging Face model API. Figures retrieved November 8, 2026; listings can change.
Top comments (0)