Thinking Machines Releases Inkling 2 Small, a 594B-Parameter Sparse MoE with 17B Active

Today we are introducing our second model generation with Inkling 2 Small. It is a Mixture-of-Experts model with 594B total parameters, 17B active, and supports image inputs and variable effort.

Inkling 2 Small far surpasses our previous models’ scores on the Artificial Analysis Intelligence Index with a score of 31, reflecting gains in performance on agentic coding, vision, knowledge work, and reasoning. The increase in capabilities comes from improvements made at every step of our training process, including more efficient pre-training and a large, unified RL run.

Inkling 2 Small will initially be available through Tinker, with closed weights, following the approach we outlined in a safe path to open weights. We intend to make the full weights available under an Apache 2.0 license next week after the completion of external safety testing and red-teaming.

You can try Inkling 2 Small on Tinker Playground today. The model is also available for fine-tuning and sampling on Tinker; checkpoints will be downloadable with the release of Inkling 2 Small’s weights.

Capabilities

Inkling 2 Small is more capable across the board than our first generation, particularly in long-horizon autonomous work.

Inkling 2 Small’s vision and agentic capabilities enable it to incorporate visual feedback to iteratively build and refine websites, games, and 3D designs with interactive elements.

Inkling 2 Small uses Three.js to build a full city simulator with no pre-made assets, generating every building, texture and car procedurally, allowing users to grow a living city from a single road while managing power, budgets and emergencies.Open video: City simulator gameA from-scratch PC emulator written in Python. It boots a real Linux kernel and provides a web interface that boots a live instance in the browser.Open video: Linux PC simulator with VimA hand-drawn valley on plain paper, with origami cranes landing on Inkling. Generated with Inkling 2 Small in Blender; revised with improvements to the water and chimney.Open video: Paper, ink & origami cranesA floor-plan walkthrough generated from a map.Open video: Floor-plan walkthrough

Agentic coding and autoresearch

Inkling 2 Small was trained with RL on hundreds of thousands of long-horizon coding tasks across multiple agent harnesses and context-compaction strategies. We increased the quality of our synthetic coding data pipeline and moved beyond unit-test rewards alone; many tasks included an agentic RL grader that evaluated how the model approached the problem, not just whether its code passed. We also tested early checkpoints of Inkling 2 Small on OpenCode under the name Fledge-Alpha to assess our model’s performance on coding tasks in the real world.

The result is a model that is both stronger at coding and easier to use inside real agent loops. Inkling 2 Small improves on usability compared to Inkling: it follows instructions better, considers changes carefully, and verifies its work without being asked.

Kernel optimization (PMPP-Hard)

69 tasks · Four independent attempts · 10-hour budget

GPT-6 Astra63Kimi K3.1 Pro60.5Claude Opus 5.560Kimi K355.75DeepSeek V4.1 Flash55.25Inkling 2 Small54.25GLM 5.352.5Mistral Large 450.25GLM 5.242

Mean tasks solved / 69

Hover a curve or select a model to inspect; select it again to reset. With a model focused, use ← and → to step through results, or Escape to clear.

View full results

Rows are ordered by AUC: the area under the mean curve over 0–10 hours, with a maximum of 690 task-hours.

Each model uses its maximum available reasoning setting, the PI harness and a shared compaction policy. We include fixes for task and grading issues identified during evaluation. Each submitted solution receives two independent LLM audits, with a third review resolving disagreements.

PMPP-Hard is an external GPU kernel-optimization benchmark, adapted here for consistent cross-model evaluation. Curves show the mean across four independent attempts; legend values are mean tasks solved at 10 hours.

Beyond conventional software tasks, Inkling 2 Small was also trained on long-horizon autoresearch tasks. This included agentic GPU kernel optimization and ML tasks such as post-training a model autonomously, all run across a range of GPU architectures.

Preliminary kernel autoresearch results

DeepSeek-V3.2 sparse attention, forward + backward

Claude Opus 5.5 · 18.80×GPT-6 Astra · 10.26×Inkling 2 Small · 6.02×DeepSeek V4.1 Flash · 5.66×GLM 5.3 · 5.03×Mistral Large 4 · 3.43×

Speedup over the original (×)

DeepSeek Sparse Attention lets each query attend only to the top-k earlier tokens chosen by a lightweight indexer, so long-context cost no longer grows with the square of the context. Starting from the public TileLang kernels, make the training kernels faster while keeping their error close to the original's (tight tolerances), with no time limit. The benchmark covers several model sizes in different regimes, from packed pretraining sequences to long-context training. The public TileLang baseline is not tuned for B300, which leaves ample headroom on these workloads to measure each model's optimization capability and perseverance. Speedups are for these kernels alone, not end-to-end training.

To demonstrate its end-to-end autoresearch performance, we tested Inkling 2 Small on a task Proximal built for one of our internal benchmarks. Inkling 2 Small autonomously trained Qwen3.5-4B on Tinker to predict various time series such as weather and Wikipedia page views. It started by analyzing the tasks and writing its own evaluator, experimented with training datasets and recipes, and tried various approaches to SFT and RL, while debugging the process as it goes. After 4.5 hours of work and $426 in Tinker spend, the trained model has more than doubled its forecasting score.

inkling-2-small@tinker: time-series-forecastingWe want Qwen/Qwen3.5-4B to forecast time series. The model gets a window, the recent history of one series as text, and writes the values of the next steps. It is sampled several times for each window. The median of its forecasts should be close to what happens, and their spread should match how uncertain it is. [...] Train a LoRA of Qwen/Qwen3.5-4B with Tinker. [...] You have 12 hours and a Tinker budget of 500 USD.Bashls /app /data && cat /data/README.md/app: examples.jsonl forecast … (25 more lines)Bashtinker-usage 2>&1 | head -20; echo ---; tinker-usage --prices 2>&1 | head -40time 0 h 0 min of 12 h (11 h 59 min left)Now let me look at how sampling works with Tinker:Bashmkdir -p /app/work && cat > /app/work/eval_windows.py <<'EOF'Bashtimeout 900 python3 work/eval_windows.py --limit 4 --workers 4 --out work/base_test.jsonl 2>&1 | tail -20skill=0.1090 windows=4 errors=0 time=103s mean crps ratio=1.0111 mean mae ratio=1.1256Base model produces parseable output, skill ~0.1 on 4 windows. Let me run a fuller baseline in the background while I explore the data for training.Now the dataset builder:Bashtimeout 2400 python3 work/build_windows.py --out work/windows_train.jsonl --n 12500 --seed 0 --cutoff 2026-05-wrote 12500 windows to work/windows_train.jsonlBase model: skill 0.038, worst on electricity. Now an SFT smoke test 8 samples came out identical because I passed one seed with num_samples=8. The grader makes 8 requests with 8 seeds. Let me fix the eval to mirror that:Bashnohup python3 work/sft.py --data work/sft_train.jsonl --out work/logs/sft1 --epochs 1 --batch-size 64 --lr 1e-sft-startedWhile SFT trains, let me study the RL infrastructure for a possible GRPO phase model with proper distinct seeds: skill=0.191 (not 0.038). SFT at step 109. Let me write the RL launcher done. Evaluating on the 100 examples:Bashpython3 -c "airq crps=0.634 mae=0.761 eia_demand crps=0.760 mae=0.932 eia_renew crps=0.776 mae=1.014 weather crps=0.695 mae=0.863 wiki crps=0.753 mae=0.894 windows with identical samples: 0 /100$101 spent — evals are expensive. Let me test whether num_samples=8 with a random seed gives distinct samples (it should, and shares the prefill) eval costs $0.02/window. Now train the all-data SFT:Bashpython3 work/windows_to_conversations.py --windows work/windows_all.jsonl --out work/sft_all.jsonl && nohup pyBashtail -5 /app/work/sft2_eval.log; ps aux | grep eval_windows | grep -v grep | wc -lskill=0.2692 windows=100 errors=0 time=281s mean crps ratio=0.7114 mean mae ratio=0.8679Bashcat > /app/model.json << 'EOF'{"checkpoint": "tinker://…/sampler_weights/final"}Bashrm -rf /app/work/logs/rl_smoke /app/work/rl_smoke.log; nohup python3 work/rl.py --windows work/windows_all.jsoBashtimeout 900 python3 work/eval_windows.py --checkpoint tinker://…/saskill=0.2558 windows=100 errors=0 time=139sBashtimeout 600 python3 work/eval_windows.py --checkpoint tinker://…/saskill=0.2296 windows=100 errors=0 time=160sBashkill 3978 2>/dev/null; sleep 2; ps aux | grep rl.py | grep -v grep | awk '{print $2}'Bashpython3 - << 'EOF'lam=0.50 skill=+0.2515 crps=0.6933 mae=0.8036 lam=1.00 skill=+0.2692 crps=0.6581 mae=0.8036 lam=2.00 skill=+0.2463 crps=0.7037 mae=0.8036Bashnohup python3 work/sft.py --data work/sft_all.jsonl --out work/logs/sft3 --epochs 1 --lr 5e-5 --batch-size 64 Bashnohup python3 work/sft.py --data work/sft_recent.jsonl --out work/logs/sft4 --epochs 1 --lr 2e-5 --batch-size Bashtimeout 900 python3 work/eval_windows.py --checkpoint tinker://…/saskill=0.2888 windows=100 errors=0 time=298sBashcat > /app/model.json << 'EOF'{"checkpoint": "tinker://…/sampler_weights/final"}Bashtimeout 600 python3 work/windows_to_conversations.py --windows work/windows_recent2.jsonl --out work/sft_recenBashtimeout 600 python3 work/windows_to_conversations.py --windows work/windows_recent3.jsonl --out work/sft_recenBashpython3 - << 'EOF'sft2_eval_seeded crps=0.6674 mae=0.8213 skill=0.2556 sft2_eval_seeded2k crps=0.6691 mae=0.8201 skill=0.2554 sft2_eval crps=0.6581 mae=0.8036 skill=0.2692 sft4_eval_seeded crps=0.6635 mae=0.8254 skill=0.2556 sft4_eval_seeded2k crps=0.6708 mae=0.8283 skill=0.2505 sft4_eval crps=0.6417 mae=0.7808 skill=0.2888| base Qwen3.5-4B | — | 0.191 | — | | sft4 = sft2 + recency top-up (≥ 2025-08-01) | 0.289 | 0.256 | 0.251 |✓ 4 h 17 min · $426 of $500 · submitted: SFT 4/tinkerbench/time-series-forecasting/0h 00m into the runForecasts on its evaluation examplesQwen3.5-4B (base)electricityUS Southwest grid · demandwind & solarNew York grid · wind powerair qualityWinnipeg · PM2.5page viewsWikipedia · “Valhalla”observedmodel's forecastEvaluation scores (% less error than copying)100 examples$0.00Tinker spend, of$500Data: U.S. Energy Information Administration (EIA-930); weather and air quality data by Open-Meteo.com (CC BY 4.0), containing modified Copernicus Climate Change Service and Copernicus Atmosphere Monitoring Service information 2026; Wikimedia pageviews (CC0).Start. Inkling 2 Small reads the task and the given raw data, covering years of hourly and daily history from five sources: electricity demand, wind and solar power, weather, air quality and Wikipedia page views.Building evaluation. Before any training, Inkling 2 Small builds an evaluation script to measure progress. The baseline is copying the latest values forward.Data curation. It turns the history through May into 12,500 training problems.Supervised fine-tuning. It starts its first supervised fine-tuning run (SFT 1). Meanwhile it finds a bug in its evaluation: it gave all 8 forecasts the same random seed, so they came out identical, while the final grader uses 8 different seeds.First results. After SFT 1, the model makes less error than copying on every data source: 25% overall, up from 19%. It also notices that evaluations are expensive ($101 so far) and cuts their cost by asking for all 8 forecasts in one request, so the prompt is prefilled once.SFT on all history. It retrains on all the history up to July 31, and saves this model as its submission so far.Reinforcement learning. It tries reinforcement learning by using the task's score as reward. The forecasts become overconfident and the score drops (26%, then 23%), so it stops the run. A quick check shows the spread of its SFT 2 forecasts (i.e., how uncertain they are) is already about right, so reinforcement learning had little to improve.More SFT. A second epoch over the same data does not help (SFT 3: 25%). A short extra run on only the last 12 months, the period closest to the test, gives its best model (SFT 4: 29%). The last two years (SFT 5) or seven months (SFT 6) resulted in worse performance.Submission. It submits its best SFT checkpoint (SFT 4) and stops after 4 h 17 min, having spent $426 of its $500 budget. On the unseen August–September data, this final model makes about 15% less error than the base model.

Vision interpretation and creation

Inkling 2 Small processes image inputs using a 292M-parameter vision encoder based on Perception EncoderBolya et al., 2025.. We use 20×20-pixel patches with 2×2 spatial pooling, and interleave image patches with text tokens. The model demonstrates strong visual capabilities across multiple categories, including OCR, grounding, infographic interpretation, and visual reasoning.

The model uses vision in the loop to interpret and validate the visual coding output it generates. Pending the release of its weights, it is set to be the top open-weights model on DesignArena.

DesignArena Website score

Muse Wonder (max)1,366Muse Spark 1.3 (xhigh)1,351Inkling 2 Small1,340GPT-6 Astra (max)1,333Kimi K31,328Claude Opus 5.51,321Kimi K3.1 Pro1,320GPT-5.6 Sol (xhigh)1,314Gemini 4 Argon1,312Claude Sonnet 5.51,309DeepSeek-V4.1-Flash-10171,303MiMo-V2.6-Pro1,303Muse Spark Open (xhigh)1,296DesignArena Website leaderboard. Scores from the November 5 leaderboard snapshot; the blue bar identifies Inkling 2 Small. The comparison includes the top ten models and three additional open-weights models. Bars start at 1,100, not zero. View on DesignArena.

We even tested Inkling 2 Small against some of our researchers in a wine tasting event. It outperformed them using vision alone, correctly identifying three wines from a single picture in 19 out of 20 trials.

Prompt: you’re in a blind wine tasting competition. glasses are labeled 1 to 3 from left to right. varietals: 99 cab sauv, 19 cab sauv, 23 nebbiolo

Inkling 2 Small: Here’s my read — with the big caveat up front that color from a phone photo under warm restaurant lighting is shaky evidence, so treat this as an educated guess, not a verdict.

My guess: Glass 1 = 2019 Cabernet Sauvignon Glass 2 = 1999 Cabernet Sauvignon Glass 3 = 2023 Nebbiolo

Continue readingShow less

Why:

• Glass 3 (right) is by far the lightest and most translucent — bright, cherry-red, you can see light through the bowl. Nebbiolo is famously pale for a red, even when young, so 2023 nebbiolo is the best fit. A 1999 cab would likely show more brick/orange/tawny at the rim, and this one reads more vivid ruby-garnet.
• Glass 1 (left) is the darkest and most opaque, nearly purple-black at its core. That’s the 2019 cab — seven years in, Cabernet still holds dense color with primary fruit.
• Glass 2 (middle) sits between the two: still dark, but a shade less impenetrable than glass 1 and a bit more muted/garnet. A 25+-year-old cab, assuming decent storage, should have dropped some of its purple and opacity but not turned fully brick, so it lands here.

The honest weak points in that guess: lighting is uneven (the left glass sits in the dimmer zone near the hearth, which exaggerates its darkness), and a well-stored 1999 can drink much darker than it looks on camera. Hue differences, not depth, would be the real tell — if glass 2 shows orange/brown at the rim versus glass 1’s purple-red edge, that confirms it.

Fast sensory tie-breakers when you actually taste:

• 1999 cab: tertiary — leather, tobacco, dried cassis, forest floor, cedar; tannins resolved and silky; fruit fully softened, maybe a touch of faded fruit.
• 2019 cab: blackcurrant/graphite/cedar, still firm structured tannins, fresher fruit, more oak presence.
• 2023 nebbiolo: pale garnet but fierce acid and grippy, drying tannins; red cherry, rose/violet, dried herbs, a tarry note — the classic “white-wine color, marathon-runner mouthfeel” giveaway.

If the pour in glass 3 is pale but your mouth feels sanded down by tannins, that’s the slam-dunk nebbiolo confirmation; if it is soft and plush, flip glass 3 and glass 2. Good luck in the competition — report back with the reveal if you get it.

Wine-tasting photo, shown as the model saw it, and the model’s response.

Agentic knowledge work

Inkling 2 Small accelerates knowledge work in realistic professional environments. It proficiently looks up information, calls tools over MCP, and produces high-quality deliverables. On AA-Briefcase, an end-to-end knowledge work benchmark, these capabilities come together for an ELO score of 1527.

Inkling 2 Small is especially strong in finance and quantitative reasoning over spreadsheets, filings and documents. Among open weight models, Inkling 2 Small ranks first on AA-AnalystAgent and Dayjob, and second on Vals Finance Index and DiligenceBench.

Customizability

Some models respond better to fine-tuning, independent of their out-of-the-box performance. We wanted Inkling 2 Small to be a strong base model for customization.

Inkling 2 Small learns faster and improves more than our previous models when trained on the same data and algorithm across a variety of post-training scenarios, which we curated based on customer use cases. For example, starting from similarly low scores on a public financial-document summarization task, Inkling 2 Small adapts quickly, reaching the final performance of Inkling Small with just 75 training steps and finishing substantially ahead.

Evaluating Model Finetunability

Inkling 2 Small learns faster and finishes at higher performance than our previous models, and is competitive with other OSS models of similar size in an RL fine-tuning setting. We used public earnings call data to create a task of investment analysis with expert judgement, similar to the type of financial analysis workloads our customers use tinker for training custom models. To ensure a fair comparison, we ran a learning rate sweep for each model; all models were trained on Tinker with Tinker Cookbook abstractions using our Async RL implementation with the Stable Reinforce loss, over 200 steps. Results for the Inkling models are averaged over 3 seeds; the other models use single runs. Costs are estimated by multiplying the number of sampling and training tokens with current tinker per-token pricing; for sampling, we assume prefix cache hits within rollouts among the same group.

Reasoning, knowledge, and epistemics

Inkling 2 Small is trained on challenging STEM problems, instruction following, information seeking with and without web search, and forecasting tasks. During RL, we use proper scoring rules for forecasting tasks and uncertainty-sensitive rewards on some question-answering tasks. This trained the model to assess uncertainty, express appropriate confidence, and make well-calibrated predictions.

Safety and alignment

Our safety work for Inkling 2 Small centers on two questions: how the model performs for the general user, and how well it resists the removal of safeguards by a malicious actor. The release of Inkling’s weights is pending further safety evaluations by us and our partners.

To assess misuse risks, we trained an internal helpful-only variant. We ran both this model and the release checkpoint through a wider suite of evaluations, with more external testers, than any previous release.

On chemical, biological, radiological, and nuclear (CBRN) risk, Inkling 2 Small’s knowledge and capability scores sit below the open-weight frontier. On FORTRESS, Scale AI’s private benchmark that scores how much harmful assistance a model gives in response to expert-written adversarial prompts across CBRN, terrorism, and nonviolent crime, Inkling 2 Small has a lower Average Risk Score compared with Inkling and Inkling-Small, and also demonstrates a higher Overrefusal Score (see Limitations). The helpful-only variant of Inkling 2 Small exhibits marginal uplift on CBRN knowledge relative to the release checkpoint, but it does not significantly advance the frontier on any dimension we measured.

On offensive and dual-use agentic cyber benchmarks, Inkling 2 Small is a large step up from Inkling Small but remains behind the open-weight frontier. It matches the open-weight frontier on Vals CyberBench v1.1 and PatchEval, both of which measure the ability to find and patch security vulnerabilities.

DeepSeek combines the supplied Flash results: 1017 for FORTRESS and PatchEval; unversioned Flash for DistressBench, StrongREJECT and Vals CyberBench.

• While we handle mental distress situations well, our model sometimes overreacts with disclaimers in normal emotional support queries as mentioned in the Limitations section.

As models take on unsupervised, longer-horizon autonomous work, the potential harm from their misbehavior increases. Without proper attention to alignment, capabilities-focused RL can push models to succeed at any cost. When tasks were difficult, early checkpoints of Inkling 2 Small were persistent in trying to succeed—in some cases fabricating results, ignoring instructions, and concealing what they had done.

We worked across the stack to improve model alignment. In midtraining, we filtered out traces containing misbehavior and included traces with honest, aligned behavior. In RL, we added a general alignment reward that penalizes misbehavior on every task. We also built environments targeting specific failure modes we observed in training, such as rewarding models for giving up on impossible tasks. Finally, we used on-policy self-distillationZhao et al., 2026. from a teacher model prompted with a conduct spec, so the model internalizes principles for good behavior without explicit prompting.

We measured progress with both internal and external evaluations, and found that Inkling 2 Small substantially improves over previous Inkling models on both internal and external evaluations, and outperforms a set of comparable open-weights models on our internal evals.

| | Inkling + open weightsInkling + open weights | Closed weightsClosed weights | | --- | --- | --- | | Alignment | Inkling 2 Small | Inkling | | Misbehavior (Internal) ↓ | 14.9 (Second-best reported result in this row) | 66.8 | | Covert misbehavior (Internal) ↓ | 11.8 (Second-best reported result in this row) | 59.4 | | Destructive actions (Internal) ↓ | 4.7 (Best reported result in this row) | 71.9 | | HoneyBench v0.2-alpha: Reward Hacking (Goodhart Labs) ↓ | 44 (Best reported result in this row) | 70 | | Covert Action with No Goal (Apollo Research) ↓ | 8 (Best reported result in this row) | 37 | | Covert Action with Goal (Apollo Research) ↓ | 0 (Best reported result in this row) | 7 |

Inkling 2 Small still trails closed-weights models, such as GPT-6.1 Sol on our alignment evaluations. Reducing this gap is a priority for future models.

We also worked to secure training and evaluations with two layers of monitoring. The first is synchronous: a monitor inspects tool calls before they run. Each task declares what actions it authorizes. Deterministic rules check calls against the task’s policy and circumvention patterns, escalating uncertain cases to an LLM judge. The second layer is asynchronous: an LLM judge reviews completed rollouts from training and evaluation for misbehavior and actions against our security boundary, raising alerts that we triage and escalate into our incident process. Together, these form a defense-in-depth approach to safety and alignment that we consider critical to developing a safe model factory.

Training Inkling 2 Small

Inkling 2 Small’s initial pretraining phase (H1) covered 8.4 trillion tokens of a broad mix of natural language, code, and image data. It ran for 68 hours on NVIDIA GB300 NVL72 racks, which enabled high expert parallelism. Training ran natively in NVFP4, the 4-bit floating-point format introduced with the NVIDIA Blackwell GPU architecture. We’ll share more details on our NVFP4 recipe in a follow-up post soon.

Internal Code

Cutoff 2026-06 · Bits per byte (lower is better)

0.190.25GLM-5.3base-recovered0.2358DeepSeek V4 Pro Base0.2335GLM-5.3 Flashbase-recovered0.2327DeepSeek V4.1 Flash 1017base-recovered0.2209Inkling 2 Smallpost-trained0.2080Kimi K3.1 Probase-recovered0.2068Inkling 2 Smallpre-trained0.2030Inkling 2 Small significantly outperforms other open-weight models on our primary held-out evaluation. Note that some models are labeled as “base-recovered”. For models where only the post-trained checkpoint was available, we fine-tuned on a dataset of pretrain-formatted code and documents before computing log loss. We validated that this procedure mostly recovers base model loss on other models where ground truth (the actual base model) is available.

We followed this initial phase with a second phase (H2) of 3.8 trillion tokens of higher-quality, newer data the model hadn’t seen, at 512K context. The third and fourth phases mixed in data in the deployment format. The third phase was about 320 billion tokens of reasoning and agent trajectories at 1M context, alongside replayed pretraining data. The fourth phase (H4) kept only the highest-quality data: about 34 billion tokens of agent trajectories. The H3 and H4 mixtures consisted mostly of trajectories sampled from earlier models including Kimi K3 and our own models, filtered for correctness and alignment.

We then carried out a joint RL run, consisting of 1,075 steps and over 17 million rollouts over 9 days. See table below for more details. This single joint run contrasts with the previous Inkling release, where we ran separate reasoning and agentic RL runs and combined them with multi-teacher distillation.

The task mix included software engineering in real repositories, terminal tasks, document creation, STEM question answering, vision, web app building, tool use with simulated users, and safety. Each task family had its own grader:

• hidden unit tests and programmatic checks for most coding work;
• rubric-based LLM judges for documents and tool use;
• reference answers for STEM and vision question answering;
• pairwise reward models comparing screenshots of rendered web apps.

We randomly sampled and conditioned on an effort level, and applied a length penalty in the reward function, which trained the model to trade off speed and thoroughness.

Our asynchronous RL uses a score centering variant—the StableReinforce objective in Tinker—which tolerates significant staleness. Our run combines short and long horizon tasks with p50/p99 total rollout tokens being 43k and 1.5M respectively and p50/p99 duration of 8 minutes and 4 hours respectively. We use 256k context length and enable compaction training for long-horizon tasks. As a result, both training reward and evaluation performance grow log-linearly with compute.

STEM evaluation performance

STEM evaluation score

STEM evaluation performance versus cumulative learner and sampler FLOPs, on a logarithmic axis.

Vision evaluation performance

Vision evaluation score

Vision evaluation performance versus cumulative learner and sampler FLOPs, on a logarithmic axis.

Making this scale practical required improvements throughout the systems stack. Our RL infrastructure deploys NVFP4 MoE training and sampling. During sampling, prefill, draft, and verify run fully on CUDA graphs. Trainers mirror the pretrain stack with high expert parallelism, EPLB, and CUDA graphs to improve GPU efficiency. To support long horizon agentic workloads, we use sticky routing and DRAM KV-cache offloading for maintaining 93%+ prefix cache hit rate, allowing us to maintain a 5 sampler ratio despite training at long contexts. Weight transfer is done via GPUDirectRDMA at 93%+ line rate with a parallelism-invariant checksum verifier. We also further lower deployment inference cost by offering a variant of NVFP4 KV cache, which we find to minimally lower evals.

Long-horizon tasks give the model hours of autonomy, increasing potential risks from misaligned behavior. Midway through the main RL run, our asynchronous monitor flagged an instance where the model, failing at a task, worked around a network block through a third-party service it could reach using its search tools. We paused the run, hardened our infrastructure, removed environments that required web access, and added synchronous tool-call monitoring. We then resumed the run, incorporating additional training phases specifically for alignment, as described above.

Improvements to our process allow us to train models at different sizes using similar recipes with predictable scaling and performance. Inkling 2 Small is part of a ladder of models; we look forward to sharing more rungs with you soon.

Benchmarking Inkling 2 Small

Like previous Inkling releases, we benchmarked Inkling-Small on a broad range of capabilities. All evals run at effort 0.99 (xhigh) and temperature 1.0. All evals run with a 1M-token maximum trajectory limit, increased from the 256K-token limit used for Inkling Small.

| | Open Weights FlashOpen Weights Flash | Open Weights ProOpen Weights Pro | Closed Weights FlashClosed Weights Flash | | --- | --- | --- | --- | |

Highest reported score in each row; ties includedSecond-highest reported score in each row; ties included

Evaluation snapshot: Missing results are shown as dashes.

Limitations

While Inkling 2 Small improves on usability vs Inkling, it is not the most succinct communicator, and doesn’t always choose the best tools for the job—especially in codebases with a large number of skills.

Like previous Inkling models, Inkling 2 Small natively supports image input; however, this model does not support audio.

Inkling 2 Small is also less optimized for the chat experience. We notice issues such as worse organization and presentation of content, overuses of slashes, and overreaction to mental health and other safety related queries.

Try Inkling 2 Small today

We are proud to make Inkling 2 Small available on Tinker for inference and fine tuning. Following the completion of safety testing, the model will be available on additional platforms in the coming weeks.

Inkling 2 Small was made in service of our mission to build AI that extends human will and judgment. We hope that it encourages your ambitions, and we look forward to seeing what you build with it.