Inkling 2 Small: Open Weights, Tinker and API Costs
Inkling 2 Small is Thinking Machines Lab’s 594B-parameter multimodal model for text, image understanding and tool-driven work, with 17B parameters active per token. Its Apache 2.0 weights are now available on Hugging Face; Tinker remains a hosted route for sampling and fine-tuning. Local deployment requires a multi-GPU cluster, so the active-parameter count is not a desktop hardware estimate.
Content reviewed:

Use this model
Online access and trials
- Try Inkling 2 Small in Tinker Playground
Availability and signup terms are set by the provider.
API docs and console
- Tinker SDK quick start
Availability and signup terms are set by the provider.
Official model repository
- Inkling 2 Small open-weight model card and hardware requirements
Model card, downloads and license conditions.
Use cases
- Ask questions about a document or image and check the answer against the source.
- Evaluate a coding task with the tools and tests your application will supply.
- Fine-tune on a repeated task when examples and an evaluation set are available.
Choose Tinker access or downloadable weights
For self-hosting, use the official Hugging Face weights and the matching deployment instructions. The weight-download section below covers formats and multi-GPU requirements.
Playground is the shortest route to a first conversation. For an application, Tinker offers serverless inference in beta. Its current documentation asks production users to join a waitlist with their model, volume and latency requirements. Establish that access before depending on it for a production service.
Sampling and fine-tuning use the Tinker SDK. Keep the route and exact model ID with your usage records: a training client, a sampling client and the serverless endpoint have different billing operations.
Inkling 2 Small inference and fine-tuning prices
Checked November 11, 2026, Tinker lists USD rates per million tokens: $0.30 for fresh input or prefill, $0.03 for cache hits and $1 for sampled output. Training costs $1.50 at 64K context or $3 at 256K. Forward-only calls through a training client use the training rate. Checkpoint storage is separately listed at $0.10 per GB per month.
| Route | Exact Tinker model ID | Context |
|---|---|---|
| Sampling / training | thinkingmachines/Inkling-2-Small | 64K |
| Extended sampling / training | thinkingmachines/Inkling-2-Small:peft:262144 | 256K |
| Serverless inference beta | thinkingmachines/Inkling-2-Small:peft:262144 | 256K |
Calculate a complete task budget
For an illustrative batch totaling one million fresh input tokens and 100,000 output tokens, inference is $0.30 + $0.10 = $0.40. If 80% of that input qualifies as a cache hit, it becomes $0.06 + $0.024 + $0.10 = $0.184. Count all turns and retries in those totals; tool services and training add separate charges.
Ten million training tokens cost $15 at the listed 64K rate or $30 at 256K, before sampling, evaluations and storage. A shorter configuration can reduce training spend if your examples fit. Compare held-out task quality before choosing a longer context or another training run.
Try a checkable task before connecting an agent
Open Playground, sign in and select Inkling 2 Small. Supply a short document and ask for a bounded result, such as the payment dates and amounts together with their supporting quotations. Check the quotations against the document. For an image task, use a clear chart and compare the extracted numbers with its labels.
For programmatic access, install the current Tinker SDK and follow its account authentication instructions. The exact model IDs above distinguish the supported configurations. Use the Cookbook sampling workflow with its documented model selection and inspect returned usage before running a batch. Tinker’s compatible-API guide describes sampler checkpoint paths; keep those distinct from serverless model IDs.
For coding, the model needs an agent client that can expose files, execute tools and return results. Start with one repository task and an existing test. Record the complete session, including reasoning, failed edits and retries, when comparing it with another model.
uv pip install tinker-cookbook
# In the chosen Cookbook workflow:
# model_name = "thinkingmachines/Inkling-2-Small"Training and evaluation can dominate an agent budget
Thinking Machines’ own time-series demonstration has Inkling 2 Small train Qwen3.5-4B through Tinker. The replay ends after 4 hours 17 minutes with $426 spent from a $500 budget. It also describes reducing repeated evaluation-prefill work and stopping an RL run after its score declined. This is a publisher-run workflow, with training and evaluation spend, rather than a price for one Inkling response.
For an autonomous experiment, set separate limits on model calls, training, evaluation and elapsed time. Keep the best held-out result and the complete bill together; low output-token prices alone do not determine the cost of improving another model.
Match the model to the task and configured context
The model supports image and text input and produces text. Thinking Machines reports improvements in agentic coding, reasoning and fine-tuning compared with its first generation. It also identifies weaker chat presentation and tool selection in repositories containing many skills. Audio input is unsupported.
ARC Prize’s verified leaderboard records Inkling 2 Small at 96.5% on the ARC-AGI-1 semi-private set and 81.7% on the ARC-AGI-2 semi-private set at XHigh effort. In ARC Prize’s November 10, 2026 leaderboard snapshot, the results exceeded those of every model it had evaluated whose weights were then open; Inkling’s weights were still pending release at that time. The scores describe ARC-style visual reasoning, not general coding-agent performance.
The model card describes a context window up to one million tokens, while the current priced Tinker configurations above expose 64K or 256K. Size requests for the actual configuration you use. The model card’s maximum is not a one-million-token allowance on every endpoint.
Read early task reports with their test conditions
Adam Holter records eight early tasks using Tinker Playground or the native SDK at medium effort. His examples include an SVG request answered with ASCII, website revisions that improved layout, and a small browser game that ran through two waves. Some comparisons use different tools or token caps, so the report is more useful for choosing test cases than ranking models.
For your evaluation, keep the client, instructions, skill files, effort and output budget consistent. Check the generated artifact as well as the response: a claim that a page or game works is easier to assess when you can open it and repeat the intended actions.
Can you download Inkling 2 Small weights?
The full weights are now available from Thinking Machines on Hugging Face under Apache 2.0. The model card recommends the native NVFP4 checkpoint; MXFP8 is also available. Tinker remains a separate hosted inference and training service with its own model IDs and prices.
The official model card lists at least 500GB aggregate VRAM for NVFP4, with examples of two NVIDIA B300 or four H200 GPUs. Its MXFP8 checkpoint calls for at least 800GB aggregate VRAM, with examples of four B300 or eight H200 GPUs. These are multi-GPU cluster configurations, not desktop requirements; the 17B active count does not represent the stored weight size.
The model card documents vLLM, SGLang, TokenSpeed and Hugging Face deployment frameworks. Budget for the selected runtime, storage, utilization and context cache in addition to accelerator time.
For a smaller local configuration, compare Qwen 27B; for another server-scale checkpoint, see Kimi K3.1 Pro and its deployment conditions.
Before you use it
- Serverless production access is subject to Tinker’s beta arrangements; budget the context and operations of the exact configuration you select.
How to get started
Test a bounded task in Playground, then choose the documented inference or training route and track complete-task usage.
Sources
Sources (9)
- Adam Holter: early Playground and native-SDK task tests ↗
Source checked:
- Inkling Cookbook setup and model selection ↗
Source checked:
- Thinking Machines: November 5 release ↗
Source checked:
- ARC Prize verified semi-private ARC-AGI results at XHigh ↗
Source checked:
- Inkling 2 Small model card ↗
Source checked:
- Tinker model IDs and token pricing ↗
Source checked:
- Tinker beta access and storage pricing ↗
Source checked:
- Tinker SDK quick start ↗
Source checked:
- Inkling 2 Small open-weight model card and hardware requirements ↗
Source checked: