Ling 3.0 Tiny vs Inkling Small: "Small" Is Doing a Lot of Work in These Two Names

"Tiny" and "Small" sound like the same size, and the two newest models wearing those names could not be further apart. Ling 3.0 Tiny is a 7.9-billion-parameter proprietary MoE from Ant Group's InclusionAI — about 1.3B active per token, free to call today through its own API endpoints, text-only, scored 23 on the Artificial Analysis Intelligence Index. Inkling Small is Thinking Machines Lab's 276-billion-parameter open-weight sparse MoE — 12B active, Apache 2.0 weights on Hugging Face, native text, image, and audio input, scored 40 on the same index. One is smaller in every real sense and rents for pennies; the other is a third of a trillion parameters you can download and run on your own hardware. The names are the trap: this is not a comparison of two small models, it is a comparison of two completely different ways to buy AI, whose only shared marketing decision is a diminutive adjective.

Both released within days of each other in the most crowded summer the model market has ever had — Inkling Small on July 30, 2026, Ling 3.0 Tiny on August 6 — and both target the same buyer: a team that wants capable AI without a frontier-model budget. This piece separates what each one actually is, what the independent numbers say, and why the "which is better" question is really a "which do you want to own" question.

Ling 3.0 Tiny: the free API

Ling 3.0 Tiny is a mixture-of-experts reasoning model with 7.9B total parameters and roughly 1.3B active per token — small, cheap to serve, and currently priced to acquire. It carries a 256K-token context window (262K on the commercial listings and Artificial Analysis), up to 32K output tokens, native function calling, and prompt caching, with a per-request switch between default-on "Thinking" and direct "Instant" modes. It is text-in, text-out; there is no vision or audio path.

The business model is the striking part. It is listed as inclusionai/ling-3.0-tiny:free at $0 per million tokens on both sides; a second gateway runs it free until 8:00am PT on August 14, 2026, after which its listed rate of $0.06 per million input and $0.18 per million output tokens applies. For an API model that is an extraordinary number — below essentially every comparable text tier on the market — and Artificial Analysis has already run it: Intelligence Index 23, ranked #6 of 56 models in its class against a median of 8. The same run flagged it as very verbose, generating 210M output tokens versus a 63M median, which is the hidden cost to keep in mind when you model the bill.

Inkling Small: the open weights

Inkling Small is a different species. It is a sparse mixture-of-experts transformer with 276B total parameters and 12B active per token — 42 layers, each token routed to 6 of 256 experts plus 2 shared experts — distilled on-policy from the 975B flagship Inkling, then given extra reinforcement learning on agentic coding. (Artificial Analysis's technical spec reads 266B total; the 12B active figure agrees, and the difference does not change the comparison.) The weights are on Hugging Face under Apache 2.0 with no commercial restrictions. It is multimodal on input — text, image, and audio land in the same token stream, with text-only output — and it ships a five-level thinking-effort dial (minimal through xhigh) so the same weights run cheap or run hard.

Because it is open weights, the access story is completely different. Thinking Machines serves it on its Tinker API at $0.30 / $1.20 per million tokens with cached input at $0.06, and it is carried on two third-party endpoints at roughly $0.45–$0.50 in / $1.20 out per 1M, with context capped at 524,288 tokens on those endpoints rather than the advertised 1M. Or you download the weights yourself — which means 276GB at 8-bit, a multi-GPU node, not a workstation, and a quantization question (the hosted endpoints serve fp8; vendor benchmarks were not measured on fp8).

The independent scoreboard

Put the two on the same Artificial Analysis scale and the capability gap is unambiguous. Inkling Small scores 40 on the Intelligence Index, ranked #15 of 101 in its class; Ling 3.0 Tiny scores 23, ranked #6 of 56 in its (smaller) class. The 17-point gap is roughly the distance between "genuinely useful budget model" and "comfortably above average for a tiny model." Inkling Small's 12B active parameters — nearly ten times Ling 3.0 Tiny's 1.3B — show up in agentic work, long-context retrieval, and coding, the dimensions the index composites. Ling 3.0 Tiny is exceptional for its size; Inkling Small is simply more capable, because it is a fundamentally bigger model wearing a small name.

Both models are verbose, which is worth stating because it affects both bills. Artificial Analysis measured Ling 3.0 Tiny burning 210M output tokens across its index run (63M median) and Inkling Small burning 130M (100M median). Inkling Small thinks about 30% more than typical; Ling 3.0 Tiny thinks more than three times typical. Neither is a model you deploy and forget to watch.

The dimensions, one line each:

• Independent score — Ling 3.0 Tiny AA Index 23 (#6/56, class median 8) vs Inkling Small AA Index 40 (#15/101).

• Price — Ling 3.0 Tiny free then $0.06 / $0.18 per 1M vs Inkling Small $0.30–$0.50 in / $1.20 out per 1M on hosted endpoints, or $0 plus your own hardware.

• Size — 7.9B total / ~1.3B active MoE, proprietary vs 276B total / 12B active sparse MoE, Apache 2.0 open weights.

• Modality — Ling 3.0 Tiny text-only vs Inkling Small text, image, and audio input, text output.

• Context — 256K on Ling 3.0 Tiny vs up to 1M advertised / 524K served on Inkling Small's current hosted endpoints.

• Ownership — closed API you rent vs open weights you can own, fine-tune on Tinker, or run yourself on a multi-GPU node.

What each one actually costs you

The price difference is not the interesting number; the ownership difference is. Ling 3.0 Tiny is a metered service: free for a week, then $0.06 / $0.18 per million tokens forever, at whatever concurrency you run, with a verbosity tax that multiplies the effective output cost. Inkling Small has two price tags: a rented one — around $0.50 / $1.20 per million on third-party endpoints, or $0.30 / $1.20 first-party — and an owned one, which is a serious hardware purchase and the engineering time to serve 276B parameters. Artificial Analysis's measured economics give Inkling Small a blended price around $0.22 per 1M tokens and roughly $0.07 per intelligence-index task, which makes it genuinely cheap to run as an API for what it delivers. But the open-weights option has no meter at all after the training-and-hosting bill, which is the same logic that draws people to a 2.6B checkpoint and is far harder to justify at 276B.

There are also capability strings attached to the open model that a spec sheet misses. Inkling Small's card recommends audio inputs under two minutes, versus under twenty for the flagship — a tenfold cut if you were reasoning over meetings. Neither hosted endpoint currently advertises response_format (schema-enforced JSON), which matters if your pipeline depends on structured output. And adversarial robustness on the lab's own numbers (71.6% on FORTRESS adversarial) is a reason to think before putting it behind a public text box. Ling 3.0 Tiny, being an API with no weights, has none of these self-hosting questions — you take what the endpoint serves.

Which "small" is right for your problem

Choose Ling 3.0 Tiny when you want the cheapest capable text reasoning you can rent, you do not need to see images or hear audio, you value an independently scored model you can try free this week, and you are fine with a metered bill and a verbose model. Choose Inkling Small when you need the capability — real multimodal input, 12B active parameters of agentic strength, an index score 17 points higher — or when you specifically want open weights you can own, fine-tune, or move off a vendor entirely. Choose it for the modality and the index score, not for the name.

An honest note on renting them

Neither of these models is on OrcaRouter, and we are not going to imply otherwise. Ling 3.0 Tiny is served by its own free endpoints; Inkling Small lives on Thinking Machines' Tinker API, third-party endpoints, or your own GPU node. What OrcaRouter is useful for in this particular comparison is everything around them: the frontier and mid-tier models you will benchmark against, and the ones you route to when the cheap tier runs out of headroom. When the free Ling 3.0 Tiny window closes or a free endpoint gets rate-limited, the escape path is a hosted budget tier — Qwen 3.7 Flash at $0.03 / $0.13, Gemini 3.5 Flash-Lite at $0.30 / $2.50, and 200+ others behind one OpenAI-compatible key at 0% markup, so the provider's list price is the price, with automatic failover so a benchmarking run or a production path does not die on one provider's bad hour. Inkling Small, being open weights, is the one side of this comparison that a router will never host for you — and the one side where that is the point.

Verdict

The two names describe marketing intent, not size. Ling 3.0 Tiny is genuinely tiny and genuinely cheap — the best free trial in the budget tier this month, with an honest if modest independent score and a meter that starts on August 14. Inkling Small is a 276B model with a small name — ten times the active parameters, seventeen index points higher, natively multimodal, and open weights you can actually own. If you want to rent the cheapest capable text reasoning, take Ling 3.0 Tiny and enjoy the free week. If you want a model you can own, fine-tune, and run yourself — or one that can hear and see — "Small" is not the right word for what you need.