UpShaqo
Intelligence desk
Agent Trust & Security Source-backed analysis

Inkling 2 Small Puts Autonomous AI Research Within a Business Budget

Thinking Machines' new 594B-parameter model can train other models, write code, and spend its own budget unsupervised—raising a real question for leaders: how much unverified autonomy should a business authorize before independent safety testing finishes?

UpShaqo Editorial IntelligenceNovember 7, 20266 min read
Intelligence standard

Independent UpShaqo analysis built from fresh, attributed sources. We explain the impact instead of repeating the announcement.

Read for leverage: focus on the workflow change, the customer problem, and the next action—not only the product announcement.

A technology leader evaluating Inkling 2 Small this week faces a narrower question than most model launches pose: not "is it capable," but "how much unsupervised runtime am I willing to authorize before anyone outside the lab has stress-tested it?" Thinking Machines has released Inkling 2 Small as a Mixture-of-Experts model with 594 billion total parameters and 17 billion active, available now through its Tinker platform with closed weights. The company says it intends to publish the full weights under an Apache 2.0 license next week, but only "after the completion of external safety testing and red-teaming," according to the launch post. That sequencing—ship capability first, finish the safety review second—is the crux of the decision in front of anyone considering a pilot.

What the Model Actually Demonstrated

Strip away the marketing language and the evidence is substantial. Inkling 2 Small scored 31 on the Artificial Analysis Intelligence Index, which Thinking Machines attributes to gains in agentic coding, vision, knowledge work, and reasoning, per the company's release. It was trained with reinforcement learning across hundreds of thousands of long-horizon coding tasks spanning multiple agent harnesses, and its graders evaluated how the model approached a problem rather than only whether its code passed unit tests. On SWEBench Pro v2 (Hard) it posted 86.3%, the second-highest reported score among the models compared in the release, and on DesignArena's website-generation leaderboard it ranked as the top open-weights model pending its weight release, with a score of 1,340 against Muse Wonder's 1,366.

The most consequential demonstration, though, wasn't a leaderboard number. Thinking Machines ran Inkling 2 Small on an internal autoresearch benchmark: training Qwen3.5-4B to forecast time series across five data sources, with a 12-hour window and a $500 budget. The model wrote its own evaluation script, discovered and fixed a bug in that script, ran supervised fine-tuning, attempted reinforcement learning, recognized the RL run was making forecasts overconfident, killed it, and submitted a final checkpoint. It finished in 4.5 hours, spent $426, and more than doubled the forecasting skill score versus the untrained baseline, according to the detailed walkthrough Thinking Machines published. That is a real, documented instance of a model managing its own research loop, including self-correction, inside a fixed budget.

Where the Evidence Ends and Speculation Begins

It's worth being precise about what this single case study proves and what it doesn't. One benchmark run, however well-documented, is not evidence of reliable behavior across the messy, high-stakes workloads a business would actually assign—proprietary codebases, customer data, production infrastructure. The company has not published failure rates, variance across repeated runs, or what happens when the budget or time constraint is tighter than the one used in this demo. Nor has it disclosed results from the external red-teaming it says is underway; those findings, by definition, don't exist publicly yet. Any claim that Inkling 2 Small is "safe for autonomous production use" is, at this point, inference rather than fact—the model card and benchmarks describe capability, not a validated trust boundary.

There's a second layer of uncertainty worth naming explicitly: separate research from Anthropic on agent memory offers a useful lens here, even though it describes a different model family. Anthropic's work on what it calls "dreaming"—letting an agent reflect on its own transcripts offline to catch and correct mistakes—found that models without that correction step could loop on an error for hours, in one case failing a simple navigation task three times before giving up, per Anthropic's published research. The broader point transfers directly to Inkling 2 Small's autoresearch demo: a model that self-corrects well in a controlled 4.5-hour run is not automatically a model that self-corrects well over a multi-day, multi-session production workflow where memory, context, and oversight get thinner. Thinking Machines hasn't published anything describing how Inkling 2 Small behaves over that longer horizon, so treat claims about sustained reliability as an open question, not a settled one.

A Concrete Scenario Worth Running Before You Commit

Imagine a 40-person startup hands Inkling 2 Small a weekend task: refactor a legacy service, with an agentic coding harness and a capped Tinker budget, unsupervised until Monday. The published kernel-optimization results give a sense of what "capped and unsupervised" looks like in practice—on the PMPP-Hard benchmark, Inkling 2 Small solved a mean of 54.25 of 69 tasks across a 10-hour budget, trailing GPT-6 Astra's 63 and Claude Opus 5.5's 60, per the benchmark table in the release. That's competent, not dominant—a gap a team should price into expectations rather than discover after the fact. The time-series demo also shows spend isn't linear with time: most of the $426 went to evaluation cycles, not training, meaning a poorly scoped eval script could quietly burn budget before producing anything useful. The practical lesson: treat any unsupervised run like a vendor contract with a hard spending cap, a defined rollback point, and a human checkpoint before the output touches anything customer-facing.

Practical Controls for Now

  • Pilot Inkling 2 Small inside Tinker's sandboxed environment on non-production, non-sensitive codebases until the open-weight release and its accompanying safety testing are public.
  • Set hard budget and time ceilings for any autonomous run, and require a human review gate before merging agent-generated code or deploying agent-trained models.
  • Log every self-correction the model makes during a run (as it did when it killed its own overconfident RL phase) to build an internal track record of how often it catches its own mistakes versus how often a human has to.
  • Treat benchmark rankings as directional, not predictive—second-place finishes on SWEBench Pro and PMPP-Hard mean strong but not best-in-class performance relative to frontier closed models.

What Remains Unresolved

The biggest open question is simple: what do the external red-teaming results actually show, and will Thinking Machines publish them in full when the Apache 2.0 weights land next week? A second question follows directly from Anthropic's memory research—does Inkling 2 Small have any analogous self-correction mechanism for errors that compound over sessions longer than the demonstrated 4.5-hour run, or does its reliability degrade the way early-generation agents did before techniques like dreaming were introduced? Until those answers arrive, the responsible posture for most organizations is enthusiasm paired with a leash: real capability, not yet a verified trust boundary.

Sources

#Thinking Machines#Inkling 2 Small#agentic coding#AI autonomy#open weights#Tinker#AI risk management

Two doors. Pick one.

Hire the team.
Or become it.