On November 20, 2026, Thinking Machines Lab released Inkling 2 Mini — a 26-billion-parameter AI model with open weights that runs offline on a laptop with 32GB of memory. It leads every open-weights model under 100 billion parameters on agentic coding benchmarks, including a 48.2% score on DeepSWE v1.1, and it does it by reusing its own layers instead of adding more of them. If you write code, run a small dev shop, or just want a capable AI that never sends your work to a cloud server, this is the most interesting model launch of the month — and the cheapest serious coding model you can own outright.
That last part is the real story. Inkling 2 Mini is free to download under the Apache 2.0 license. Run it locally and your marginal cost per task is zero. Run it through an API and it costs about $0.59 per agentic coding task, according to independent testing by Artificial Analysis — roughly six times cheaper than its closest open rival, and about four times faster. The catch, as always, is in the fine print: it needs 32GB of memory, it is weaker at ordinary chat than at coding, and its headline benchmarks are the lab’s own numbers. This article walks through what the model actually is, what it costs in real dollars, how to run it on hardware you already own, and where it falls short.
What Inkling 2 Mini actually is
Thinking Machines Lab is the San Francisco startup founded by Mira Murati, OpenAI’s former chief technology officer. Inkling 2 Mini is its second open-weights release, following the 594-billion-parameter Inkling 2 Small on November 12. The Small model was too big for anyone to run themselves. The Mini is the answer to that feedback — a model deliberately sized for local hardware.
The headline specs, from the official announcement and the Hugging Face model card:
- 26.4 billion total parameters, with 3.4 billion active per token — a mixture-of-experts (MoE) design that routes each token to 8 of 128 experts
- ~20GB memory footprint, small enough for a consumer laptop
- 1-million-token context window, with text and image input and text output
- Open weights under Apache 2.0, free to download, fine-tune, and build into products
- Trained on 1 trillion tokens distilled from a larger internal Inkling model
The number that matters most for a small business is the last-but-one: 20GB. A capable coding model that fits in 20GB changes who can run serious AI. Until now, the models that could genuinely help with multi-step coding work either lived behind a paid API or needed a workstation GPU. Inkling 2 Mini fits on a MacBook Pro you may already own.
The looped transformer, explained in plain English
Every AI model is a stack of layers. A token of text passes through each layer once, and each layer refines the model’s understanding a little. Bigger models get smarter mostly by adding more layers and more parameters — which is why frontier models need data centers.
Inkling 2 Mini takes a different route. It has 24 layers, grouped into four blocks of six. The first block and the last block run once, like normal. The two middle blocks run three times per token, reusing the same weights each pass, with gated messages passed between loops. The result is 48 layer applications per token from a model that only stores 24 layers of weights.
Think of it like re-reading a hard paragraph instead of buying a longer book. The model spends more compute thinking about each token before it produces the next one, without needing more memory to hold more parameters. Thinking Machines says this buys reasoning depth precisely where agentic coding needs it — tasks that depend on working through a problem step by step rather than recalling a fact.
There is a trade-off, and the lab is upfront about it: looping costs compute time. The model does more work per token, so raw generation speed per token is lower than a same-size conventional model. What you get in exchange is better answers per token — fewer tokens wasted on wrong turns, which is why the lab reports the model reaching the right answer with fewer tokens overall on coding tasks.
The lab also published a research companion, TML-d24-varloop-research, that lets researchers vary the loop count from one to five passes. In their tests, more loops shortened the model’s written reasoning traces — from about 3,703 tokens at one pass to 1,661 at five passes on GPQA Diamond — while extending how long the model could reason without writing anything down, from 16 seconds to 37 seconds. That is genuinely new science, and it is also a warning label: as models reason more internally and write less down, it gets harder for humans to audit how they reached an answer. Thinking Machines partnered with the National Deep Inference Fabric (NDIF) and Goodfire to study exactly that monitorability question.
The benchmarks — and the honest caveat
Here are the scores Thinking Machines reports for Inkling 2 Mini, against Alibaba’s Qwen3.8-27B, the strongest comparable open model:
| Benchmark | Inkling 2 Mini | Qwen3.8-27B |
|---|---|---|
| DeepSWE v1.1 (agentic coding) | 48.2% | 42.2% |
| SWE-bench Verified | 79.2% | 77.8% |
| SWE-bench Pro v2 Hard (51 tasks) | 77.9% | 73.8% |
| Vals Index v2.2 | 46.5% | — |
| Artificial Analysis Intelligence Index | 20.1 | ~20.1 (tied) |
Two things to note before you take these numbers at face value. First, the coding scores are company-reported — Thinking Machines ran these evaluations itself, and testing setups differ between models, so treat the leads as directional, not gospel. Second, the one fully independent number in the table, the Artificial Analysis Intelligence Index, has the two models tied at 20.1. Artificial Analysis also reports that Inkling 2 Mini uses about 152,000 output tokens per task on average — roughly 38% more than Qwen — yet still comes out far cheaper and faster per task, because its per-token price is so much lower.
So the fair summary is this: on agentic coding, Inkling 2 Mini is at least as good as the best open model of its size, and by the lab’s own tests it is better. On general intelligence, it ties. That is a strong result for a model designed to run on a laptop — but it is not a frontier model. GPT-6 Luna (max) scores 28 on the same Artificial Analysis index, for comparison. Inkling 2 Mini is a specialist that punches above its weight, not a replacement for the biggest cloud models.
The local AI community’s reaction has been enthusiastic but measured. On Hacker News, one commenter summed up the mood: “This is bonkers good if these benchmarks hold up in real-world scenarios. To be at the level of Qwen3.8-27B with a looped transformer model is quite the flex.” A Thinking Machines team member showed up in the r/LocalLLaMA discussion to say the sizing was “largely informed by what folks on this subreddit ask for the most” — this is the lab’s first model targeted at local users, and it shows in the design choices.
Will it run on your laptop? The honest hardware check
The official requirement is clear: 32GB of memory or more. The model card lists Apple silicon devices with 32GB or more (MacBooks, Mac minis, and Studios), a single NVIDIA DGX Spark, or other GPUs with 32GB or more of VRAM. The demo machine was a MacBook Pro with the M5 Pro chip and 48GB of memory, running in airplane mode — fully offline — while it built a playable flight simulator in a few minutes.
Here is how that maps to machines real people own:
| Your machine | Will it run? |
|---|---|
| MacBook Pro / Mac mini / Mac Studio, 32GB+ | Yes — this is the supported path, via Ollama |
| MacBook with 16GB | Probably not smoothly — the weights alone take ~20GB |
| MacBook with 8GB | No — use the hosted API instead |
| Windows/Linux desktop with a 24GB GPU | Community reports say yes with quantized GGUF builds via Unsloth or llama.cpp, but this is not the lab’s officially supported path |
| NVIDIA DGX Spark (128GB) | Yes — used in Stanford’s tests |
Two honest notes. First, 32GB is the floor, not the sweet spot — the weights take 20GB, and the operating system, your editor, and the model’s working memory need the rest. Second, if you have a 16GB machine, do not buy a new laptop for this model alone. The hosted API costs pennies per task (see the cost section below), and a quantized community build may reach your hardware later. Unsloth already promotes a GGUF route aimed at 16GB machines, and the lab notes its models respond unusually well to quantization — maintaining 90% top-1 accuracy even at 1-bit quantization in Unsloth’s testing, per the team’s own Reddit comment.
How to run it yourself
At launch, Thinking Machines supports Inkling 2 Mini on any Mac system with at least 32GB of RAM via Ollama, the popular local-model runner. Community reports say Ollama’s 0.40.17 release ships the model as ollama run inkling-2-mini. The day-one framework support is broad: Hugging Face Transformers, SGLang, vLLM, llama.cpp, Unsloth (including quantized GGUF versions), the Llama App, NVIDIA Dynamo, and TokenSpeed, plus MLX and Exo Labs on Apple silicon. Fine-tuning routes include the lab’s own Tinker platform, Miles, and SkyRL.
A practical setup path for a Mac owner:
- Check your memory first. On a Mac, open the Apple menu and choose About This Mac. You need 32GB or more.
- Install Ollama from ollama.com and make sure it is updated to a version that includes Inkling 2 Mini support.
- Pull the model — about a 20GB download, so do it on Wi-Fi you trust, not a metered connection.
- Point your coding tool at it. Ollama exposes an OpenAI-compatible local endpoint, so tools that accept a custom base URL can use your local model instead of a cloud API.
- Try it offline. Turn off Wi-Fi and run a real task — that is the whole point. Your code never leaves the machine.
If you are not on a Mac, the Hugging Face route is the most flexible: download the checkpoint from the model card page and run it under vLLM or SGLang on a rented GPU server, or under llama.cpp with a community GGUF build on a 24GB desktop GPU. Expect rough edges — looped-model support is brand new in these tools, and speed varies by app and hardware. This is week-one software, not a polished product.
For everyone else — and for teams that want to try the model before committing hardware — the Tinker Playground offers inference-only access in the browser, no download required.
What it costs: the worked math
This is where Inkling 2 Mini gets genuinely interesting for a small business, because there are three ways to pay for it and the numbers are far apart.
| Route | Input price | Output price | Best for |
|---|---|---|---|
| Local (your hardware) | $0 | $0 | Privacy, offline work, unlimited retries |
| Tinker (first-party API) | $0.15 / 1M tokens | $0.50 / 1M tokens | Trying it, fine-tuning |
| OpenRouter (hosted) | $0.075 / 1M tokens | $0.30 / 1M tokens | Cheapest hosted access, served by Prime Intellect and io.net |
Those hosted prices are verified from Thinking Machines’ own pricing via Artificial Analysis and OpenRouter’s live listing. Note that OpenRouter also charges $0.015 per million tokens for cache reads — a small detail that matters if your agent re-reads long contexts.
Now the worked example. Artificial Analysis measured the real per-task cost of running its Intelligence Index on Inkling 2 Mini at $0.59 and 9.0 minutes per task using first-party pricing, against $3.53 and 38.2 minutes for Qwen3.8-27B. Scale that to a small dev shop running 100 agentic coding tasks a month:
- Inkling 2 Mini via Tinker: 100 × $0.59 = $59/month, about 15 hours of compute time
- Qwen3.8-27B hosted: 100 × $3.53 = $353/month, about 64 hours of compute time
- Inkling 2 Mini local: $0/month in API fees — the only cost is electricity and the machine you already own
That is a $294 monthly saving against the closest open rival, and the local route wipes the bill out entirely. Compare that with the frontier hosted models, where a single heavy agent session can cost dollars, not cents — our GPT-6.2 Astra vs Claude Fable 5.2 comparison shows what the big labs charge for their best models, and the gap is an order of magnitude.
The honest framing: those per-task figures come from one benchmark harness, and your mileage will vary with task length. But the direction is unambiguous — this is the cheapest way to run capable agentic coding that exists right now, and the local option is free after hardware.
What it is actually good for
The model’s strengths mirror its design: long-horizon agentic work. That means tasks where the AI has to plan, use tools, read results, and keep going — not one-shot questions. Practical uses for a small business or freelancer:
- A local coding assistant that reads your codebase, makes multi-file changes, runs tests, and iterates — without your proprietary code ever leaving your laptop. For client work under NDA, that privacy property alone is worth more than the price.
- Offline development on planes, in dead zones, or in offices with locked-down networks. The flight-simulator demo was not a gimmick; it was the point.
- Bulk agent work — refactoring, test generation, documentation passes, dependency updates — where the per-task cost of a frontier API would add up fast.
- A private research and writing helper for sensitive material, since local inference means no logs on a vendor’s server.
The 1-million-token context window matters here too. You can load a whole small codebase, a long contract, or a year’s worth of meeting notes into a single session and have the model work across all of it.
Where it falls short — the honest limits
No model launch is all upside, and this one has real limits worth knowing before you commit a weekend to setup:
- It is weaker at ordinary chat. The lab’s own numbers show it trailing on multi-turn dialogue (50.0% on MultiChallenge) and rule tracking (33.4% on ComplexConstraints v1.1). If you want a general chatbot, a hosted frontier model is still better.
- The benchmarks are self-reported. The coding leads come from Thinking Machines’ own evaluation runs. Independent verification under a common harness is still open, and the one independent index available has it tied with Qwen, not ahead.
- Local tooling is week-one software. Looped-model support just landed in Ollama, vLLM, and llama.cpp. Expect quirks, slower-than-expected speeds on some setups, and community patches — one builder already reports needing a patched build to hit 190–220 tokens per second on a 24GB GPU.
- The reasoning is getting harder to audit. As the loop count rises, the model writes shorter reasoning traces and does more work internally. Thinking Machines is studying this openly with NDIF and Goodfire, but if your workflow depends on reading the model’s chain of thought to verify its work, that is a genuine trade-off.
- It is not a frontier model. An Artificial Analysis score of 20.1 is excellent for its size and price, but the best cloud models score meaningfully higher. For the hardest problems, you will still reach for the API — and our November AI pricing roundup is the place to compare those costs.
None of these limits is a reason to skip the model. They are reasons to use it for what it is good at — local, private, cheap agentic coding — rather than expecting it to replace everything.
Inkling 2 Mini vs the alternatives
| Option | Cost | Privacy | Coding strength | Best for |
|---|---|---|---|---|
| Inkling 2 Mini (local) | $0 after hardware | Full — nothing leaves your machine | Best open model under 100B on coding tests | Private client work, offline use |
| Inkling 2 Mini (hosted API) | ~$0.59 per agent task | Vendor sees your prompts | Same model | Trying it, or 16GB machines |
| Qwen3.8-27B (hosted) | ~$3.53 per agent task | Vendor sees your prompts | Slightly behind on coding, tied overall | If you already have it wired up |
| Frontier cloud models (GPT-6, Claude) | Dollars per heavy session | Vendor sees your prompts | Strongest available | The hardest problems |
The decision is simpler than the table makes it look. If your work involves proprietary code, client data, or offline environments, run Inkling 2 Mini locally — nothing else at this price gives you this capability with full privacy. If your machine cannot run it, the hosted API is still the cheapest capable coding model you can buy. And if the task is genuinely hard — novel architecture, ambiguous requirements, high stakes — pay for the frontier model and use Inkling for the bulk work around it.
The bottom line
Inkling 2 Mini is not the biggest model launch of November, and it is not trying to be. It is the most practical one for a small business: a capable coding model you can download for free, run on a laptop you may already own, and use without a per-task bill or a privacy compromise. The looped-transformer design is a real architectural idea, not a marketing label — it buys reasoning depth without buying more memory — and the independent testing so far backs up the lab’s claims on cost and speed, even if the benchmark leads deserve the usual skepticism.
Try it this week if you have a 32GB Mac. Try the hosted API if you do not. And if you run it, run it on a real job, not a demo prompt — that is the only test that matters.
Frequently Asked Questions
What is Inkling 2 Mini?
Inkling 2 Mini is a 26.4-billion-parameter open-weights AI model released by Thinking Machines Lab on November 20, 2026. It uses a looped-transformer design that runs its middle layers three times per token, and it is small enough — about 20GB — to run offline on a laptop with 32GB of memory.
Can Inkling 2 Mini really run on a laptop?
Yes, on the right laptop. You need a Mac with at least 32GB of unified memory (MacBook Pro, Mac mini, or Mac Studio) running it via Ollama, or a desktop GPU with 32GB or more of VRAM. The lab demonstrated it running fully offline in airplane mode on a 48GB MacBook Pro. A 16GB laptop will struggle with the full model; community quantized builds may help, or you can use the hosted API instead.
How much does Inkling 2 Mini cost?
The weights are free under the Apache 2.0 license — download them from Hugging Face and run them locally for no per-task cost. Hosted access costs $0.15 per million input tokens and $0.50 per million output tokens through Thinking Machines’ own Tinker platform, or $0.075/$0.30 per million tokens through OpenRouter. Independent testing put the real cost at about $0.59 per agentic coding task.
Is Inkling 2 Mini better than Qwen3.8-27B?
On agentic coding benchmarks run by Thinking Machines, yes — 48.2% vs 42.2% on DeepSWE v1.1 and 79.2% vs 77.8% on SWE-bench Verified. On the independent Artificial Analysis Intelligence Index, the two models tie at 20.1. Inkling 2 Mini is about six times cheaper and four times faster per task, which is the more important difference for most users.
What is a looped transformer?
A looped transformer reuses the same middle layers multiple times for each token instead of adding more layers. Inkling 2 Mini has 24 layers, but its middle 12 run three times per token, giving 48 layer applications from 24 stored layers. That lets the model reason more deeply about each token without needing more memory.
Is Inkling 2 Mini good for everyday chat?
Not especially. It trails on multi-turn dialogue and strict instruction-following benchmarks, and its strength is long-horizon agentic coding work. For general chat, a hosted frontier model is still the better choice.
