Thinking Machines (Inkling)

💰 价格与方案

🔧 API & Developer Experience

• •Machine-Readable Pricing: Thinking Machines explicitly asks you not to scrape the pricing tables, calling them presentational and changeable, and points instead at two published JSON files. models.json covers the training table with name, tinker_id, context, size, params, active_params, arch, type, url, and four per-million-token price strings; serverless.json covers the inference table with input, cached_input, and output. Discounted models carry original_prefill, original_cached_prefill, original_sample, original_train, and a note field.
• •Two Products, One Vendor: Tinker is a training API, not a chat API. Its surface is four functions: forward_backward accumulates gradients, optim_step applies them, sample generates tokens for evaluation or RL actions, and save_state checkpoints. Inference is a separate serverless surface billed per token. A team can adopt either half without the other.
• •Base-Model Roster Beyond Its Own Weights: Tinker fine-tunes eight vendors' checkpoints, not just Inkling: NVIDIA Nemotron 3.5-Lightning / 3-Nano / 3-Super / 3-Ultra, Z.AI GLM-5.3, Moonshot Kimi-K2.6, five Qwen checkpoints (Qwen3.8-27B, Qwen3.6-35B-A3B, Qwen3.6-27B, Qwen3.5 family, Qwen3-8B), OpenAI GPT-OSS-120B and 20B, and DeepSeek-V3.1. Checkpoints come in 32K, 64K, 128K, and 256K context tiers at different prices.
• •Checkpoint Portability: Tinker exposes an API endpoint to download any saved checkpoint, and the model page links the open weights on Hugging Face directly. Fine-tuned weights move off the platform, which matters if you want to run inference on your own GPUs after training.
• •Data Handling: The FAQ states customer data is used solely to fine-tune the customer's own models and is not used to train Thinking Machines' models. LoRA is the fine-tuning method: Tinker trains a streamlined adapter rather than updating all base weights, which the vendor says matches full fine-tuning on learning performance while requiring less compute.
• •Multimodal Input: Both Inkling models accept text, image, and audio input natively. The model table types both as Hybrid + Audio + Vision. Hybrid means the model reasons by default but chain-of-thought can be disabled via a renderer or argument for faster, cheaper direct answers.
• •Context Discrepancy to Watch: Three surfaces publish three context figures. The model page and release posts advertise 1M tokens; serverless inference is documented at 256K; Tinker training offers 64K and 256K tiers at different prices. Confirm the billed tier before sizing a context budget on the 1M headline.

📊 Benchmarks (Inkling-Small vs Inkling)

🎯 Use Cases & Verdict

• •Pick Inkling-Small for the API, not Inkling: It is 3.3x cheaper on input and 3.4x cheaper on output than Inkling, and Thinking Machines reports it beats Inkling on reasoning and agentic coding. The only reason to pay for the 975B model is knowledge coverage and factuality, which is a narrow set of workloads.
• •Watch the cached-input ratio: Inkling-Small's cached input is one fifth of its input rate and Inkling's is better than one sixth. For an agent carrying a persistent system prompt or skill file, the cached rate is the dominant cost lever — and it is the number most comparison tables omit.
• •Adopt Tinker on its own merits: The base-model roster spans eight vendors, so Tinker is a standalone answer to 'fine-tune without owning GPUs' regardless of your interest in Inkling. Benchmark it against your current stack on the four training line items plus $0.10/GB-month storage.
• •Budget on original, not promotional, rates: The 50% training discount is limited-time. Inkling's 64K train rate doubles from $5.61 to $11.22 when it lapses. The machine-readable JSON exposes the original_* fields precisely so you can model the post-promotion case.
• •Verify which surface you are on: 1M claimed on the model page, 256K on serverless, 64K/256K tiers in training. A cost estimate that silently mixes these is the most likely way to be off by 2x.
• •Verdict: A structurally unusual release: a small open-weight family with parseable pricing attached to a training API whose roster extends well beyond its own weights. The rates are competitive for the parameter counts, Inkling-Small especially, and the cached-input ratios are aggressive enough to matter for long-context agents.