How Much To Run AI
Open weights

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:

Inkling 2 Small Tinker rates from $0.03 per million cached input to $3 per million 256K training tokens, a one-million-token batch at $0.40 or $0.184 with cache hits, and Apache 2.0 weights needing at least 500 GB of aggregate VRAM for NVFP4 or 800 GB for MXFP8.
Original diagram of the listed Tinker rates and the model card’s cluster configurations; the active 17B count is not the stored weight size.

Use this model

Online access and trials

API docs and console

Official model repository

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.

RouteExact Tinker model IDContext
Sampling / trainingthinkingmachines/Inkling-2-Small64K
Extended sampling / trainingthinkingmachines/Inkling-2-Small:peft:262144256K
Serverless inference betathinkingmachines/Inkling-2-Small:peft:262144256K

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.

Install the Cookbook, then select this model in its documented workflows
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)

Calculators