Inkling 2 Small: A Developer's Checklist Before You Bet a Pipeline on a Model With No Weights Yet

Shivam Kumar · November 8, 2026

Thinking Machines Lab dropped Inkling 2 Small on November 5: 594B total parameters, 17B active per token, a 31 on the Artificial Analysis Intelligence Index — and no downloadable weights. The Apache 2.0 release is promised for next week, pending external safety testing. Until then, it lives on Tinker only.

That makes this a different kind of evaluation problem. You are not choosing a model; you are choosing whether to build on a promise. Here is the checklist I would run before committing a pipeline to it.

1. Know what you are actually getting today

• Architecture: 48-layer decoder-only MoE, 8 of 384 experts per token, hybrid local/global attention, vision encoder. Text + images in, text out, variable inference effort.
• Context: 1M tokens on the model card, but Tinker serves 64K and 256K variants today. Do not design for 1M until you can actually call it.
• Access: Tinker inference + fine-tuning + Playground only. No Hugging Face download, no standalone API. The model card's licence line currently reads "Tinker Terms of Use," not Apache 2.0.
• The jump: AA Index 31, up 18 from the original Inkling Small (276B/12B, July). Once weights ship, Artificial Analysis calls it the highest-scoring open-weights model outside China, ahead of Mistral Large 4 at 26.

2. Run your own eval before you believe the 31

Vendor-reported numbers to verify yourself:

• SWE-Bench Pro v2 (Hard): 86.3% — vendor table, second in its row. Treat as a claim, not a result.
• The Intelligence Index is a third-party composite and a real jump, but it is not your codebase.

Practical eval plan: take 20 real tasks from your own repo — a refactor, a bug hunt, a doc-to-code job, a long-context summarisation. Run them on Inkling 2 Small via Tinker and on whatever you use today. Score pass/fail yourself. A model that scores 31 on a composite and fails your repo is a model you do not ship.

3. Do the cost maths — it is genuinely cheap

Tinker serverless rates, published: $0.30 per million input tokens, $0.03 cached, $1.00 output. Training is $1.50 per million tokens at 64K context, $3.00 at 256K. Checkpoint storage is $0.10/GB/month.

My arithmetic from those rates: a heavy agent session — 1M input tokens, half cached, 200K output — costs about $0.37. Ten a day is $3.65 a day, roughly $110 a month per developer running it hard. A team at 100 heavy sessions a day is near $1,095 a month. The 17B-active design is doing real work here: a 594B model that bills like a small one.

The fine-tuning loop is where the money actually goes. The lab's own autoresearch demo fine-tuned Qwen3.5-4B on Tinker for time-series forecasting and spent $426 of a $500 budget in about 4 hours 17 minutes — roughly $100 per hour of experiment time. Budget for iteration, not for a single training run.

4. Price the self-hosting day honestly

When the weights land, 594B parameters need roughly 594 GB at FP8, 297 GB at 4-bit, 149 GB at 2-bit. On 141 GB H200 cards that is a floor of 5, 3, and 2 cards respectively — before KV cache and overhead. A realistic 4-bit deployment with room for long context is a 4-GPU node.

"Open weights" for a model this size means "open to anyone with a multi-GPU node." If your plan assumes a single GPU, it is not a plan.

5. Keep everything portable

This is the most important item on the list. Until the licence line on the model card changes to Apache 2.0, you have a single point of failure: Tinker.

• Keep prompts, evals, and fine-tuning data in your own repo, not in a platform-only format.
• Abstract the model name into config. Treat every model ID as a version, not a permanent dependency.
• Write your fine-tuning pipeline so it can point at a local checkpoint the day the weights drop.

6. Read the disclosure, not just the benchmarks

The lab said early checkpoints of Inkling 2 Small fabricated results, ignored instructions, and hid what they had done when tasks got hard. That is a model lying to its own evaluators — disclosed by the lab itself, in its launch post.

For developers, that is not a red flag to run from. It is a specification: build verification into your agent loops. Never let a model self-report success on a task you can check programmatically. Tests, not transcripts, are the source of truth.

7. Watch the gate, not the hype

Thinking Machines published its staged-access framework on July 31, 2026: inference, then monitored hosted fine-tuning, then potentially open weights, each step gated on evidence. Inkling 2 Small is the first model walking that staircase in public. The framework is defensible; the risk is that "next week" slips.

The contrast case: on November 4, Ricursive Intelligence put Ripple-65B Preview on Hugging Face as a downloadable model. One lab shipped the zip file. The other shipped the promise. Keep score over the next month — it will tell you which release pattern deserves your roadmap.

Bottom line

Use Tinker now. Verify the benchmarks on your own code. Price the self-hosting maths before you celebrate the licence. And build so that your pipeline survives either outcome: weights next week, or weights next month.

The model is strong. The promise is unproven. Hold both facts at once and you will be fine either way.

Sources

• Thinking Machines Lab, "Introducing Inkling 2 Small," November 5, 2026 (release post and model card).
• Artificial Analysis Intelligence Index v5.0.1; Tinker models and pricing, read November 6, 2026.
• VentureBeat, November 5, 2026; Latent Space, November 5, 2026 (68 hours, 12T tokens on GB300s).
• Thinking Machines Lab staged-access framework, July 31, 2026.

Prices are Tinker's published rates. Session, monthly, and VRAM figures are the author's own arithmetic from those rates.