TwIL-8B Explained: The 8.8B Open-Weight Model That Claims 93% of Frontier Coding Power
On 4 November 2026, Austin-based webAI opened the weights of TwIL-8B, an 8.8-billion-parameter reasoning model that its maker says reaches 93% of frontier-model performance on coding — and fits in a 5GB file you can run on your own machine
No subscription, no API key, no cloud bill: download it from Hugging Face, point llama.cpp at it, and you have a model that webAI claims scores 98.2 on MATH-500 and 81.6 on LiveCodeBench. That is the pitch, and it landed at exactly the right momen.t
Just days earlier, AI researcher Andrej Karpathy had argued on two major podcasts that a 1-billion-parameter model would soon be enough for most everyday work — and within hours of the launch, commentators were holding up TwIL-8B as the proof. This guide explains what TwIL-8B actually is, what its benchmark numbers really mean, where the model falls short, why its licence matters more than its size, and how to run it locally — including what happened when independent testers put it to work on a real coding job.

Table of Contents
- TwIL-8B at a Glance
- What Is TwIL-8B?
- How the Model Was Built
- Balanced vs Verbose: Two Variants, One Model
- TwIL-8B Benchmarks: The 93% Claim, Explained
- Where It Falls Short
- The Licence: Open Weights Is Not Open Source
- The Independent Reality Check: Outside webAI’s Lab
- How to Run It Locally
- TwIL-8B vs Qwen3.5-9B vs Gemma 4
- Pricing: Free to Download, Not Free to Run
- Who Should Use It — and Who Should Skip It
- Frequently Asked Questions
- The Bottom Line
TwIL-8B at a Glance
| Detail | TwIL-8B |
|---|---|
| Developer | webAI (Austin, Texas), CEO David Stout |
| Released | 4 November 2026 |
| Size | 8.79 billion parameters, dense decoder-only transformer |
| Base model | IBM Granite 4.2 8B (Apache 2.0) |
| Context window | 131,072 tokens |
| Variants | Balanced (default, shorter reasoning) and Verbose (longer reasoning) |
| Headline claims* | MATH-500 98.2; LiveCodeBench 81.6; 93% of frontier on coding |
| Download size | 4.98 GiB (Q4_K_M GGUF) or 16.38 GiB (full bf16) |
| Licence | webAI Non-Commercial License 1.0 — research and study only |
| Managed API | None — no hosted inference provider as of publication |
| Price | Free to download; you pay for your own hardware and electricity |
*All benchmark figures are webAI’s own, self-reported numbers. They have not been independently reproduced. Treat them as the maker’s claim, not a verified result — this article explains why that distinction matters.
What Is TwIL-8B?
TwIL-8B is a reasoning model: instead of answering immediately, it writes out a long chain of thought — a “think block” — before giving its final answer. That extra thinking is what lets a relatively small model punch above its weight on maths and code, where working through a problem step by step matters more than memorised facts. The model is a dense decoder-only transformer in IBM’s Granite family, with 40 layers, a hidden size of 4,096, 32 attention heads with 8 key-value heads, and a vocabulary of 100,352 tokens. It takes English text in and produces English text out.
The name needs a little unpacking. TwIL is webAI’s model family, and the “8B” is the parameter count — 8.79 billion, to be precise. This is the family’s second act. In August 2026 webAI released much smaller formal-logic models, TwIL-LM3 and TwIL-LM3-Pro at 1.7B and 3B parameters, built to prove that a tiny model trained for one job — formal logic — could beat far larger general models at that job. TwIL-8B takes the same philosophy and widens it: instead of pure logic, it targets the three skills working developers actually reach for — maths, code, and following instructions precisely.
One confusion to clear up early: webAI is not Opera’s WebAI. Opera has proposed a “WebAI” standard for running local models in the browser, which is a separate project with a similar name. webAI is the Austin company behind TwIL-8B, and its model lives on Hugging Face under the webAI-Official organisation.
The launch pitch is worth quoting because it frames the whole story. In his announcement post on 4 November, webAI chief executive David Stout argued that the industry should stop chasing the most powerful model at any cost and start measuring itself by the cost of completing a task. That is the bet behind the model: not that a small model beats a frontier model outright, but that it gets close enough — webAI says 93% on coding — at a fraction of the size, cost, and hardware. If you can run it on a laptop, the argument goes, you do not need a data centre to get frontier-adjacent results on the tasks it is good at.
That framing landed because of timing. Days before the release, Andrej Karpathy told the No Priors and Dwarkesh Patel podcasts that 1 billion parameters would soon be enough for most everyday work, as models get distilled, compressed, and specialised. Commentators immediately held up the new model as the idea made real: a small, focused reasoning model doing serious work. Karpathy’s claim and webAI’s launch are not the same thing — a 1B general model and an 8.8B specialist are very different bets — but the coincidence gave TwIL-8B far more attention than a typical open-weight release gets in its first week.
How the Model Was Built
TwIL-8B starts from IBM’s Granite 4.2 8B, an open base model released under the permissive Apache 2.0 licence, and then goes through three training stages. Understanding the recipe matters, because it explains both the model’s strengths and its blind spots.
Stage one: supervised fine-tuning. webAI ran full-parameter supervised fine-tuning — every one of the 8.79 billion weights was updated — on reasoning traces for maths, STEM subjects, and instruction following. A reasoning trace is a worked example: not just the answer to a problem, but the step-by-step thinking that leads to it. Training on traces teaches the model to think out loud before answering, which is the core skill of a reasoning model.
Stage two: reinforcement learning. The fine-tuned model was then trained further with reinforcement learning, using two algorithms — GRPO and DAPO — on maths, code, STEM, and instruction-following prompts. In plain terms, the model generated many candidate answers, got rewarded for the ones that were right, and gradually shifted toward producing correct reasoning more often. This stage produces the verbose variant: a model that reasons at length and is aimed at hard, contest-style problems.
Stage three: length-aware reinforcement learning. A further RL stage added a reward that favours shorter reasoning, measured against per-domain length references for maths, code, STEM, and instruction following. The goal was to keep most of the accuracy while cutting the length of the think block. This stage produces the balanced variant, which ships as the default download.
Two details in the model card deserve attention. First, webAI says the training pools were decontaminated against the benchmarks by 13-gram matching — a standard technique that removes any training example sharing a 13-word sequence with a test question, so the model cannot simply have memorised the answers. One exception matters, though: the HMMT November 2025 contest set was not included in that decontamination check, which is worth remembering when you read the 90% frontier figure for that benchmark.
Second, the 131,072-token context window is inherited from the Granite 4.2 base model, not something webAI extended. That is a generous window for an 8B model — long enough to hold a large codebase file or a long document alongside the model’s own reasoning — but it is the base model’s capability, not a new achievement.
Balanced vs Verbose: Two Variants, One Model
TwIL-8B ships in two variants that share the same architecture and tokenizer but behave quite differently in practice. Choosing between them is the first real decision a user has to make, and the model card is unusually honest about the trade-off.
TwIL-8B Balanced: the default, shorter thinker
The balanced variant is the default download, and it is the model most people will actually run. After the length-aware RL stage, it reasons for fewer tokens — around 19,500 output tokens per AIME 2026 problem, compared with 31,200 for its closest open rival, Qwen3.5-9B. Fewer tokens means faster answers, less waiting, and less memory spent holding the reasoning trace. For everyday use — drafting a function, checking a proof, following a multi-step instruction — the balanced variant is the sensible pick, and it is the one the 4.98 GiB GGUF file contains by default.
The catch is that the model card does not publish a full benchmark table for the balanced variant on every test. Several headline rows carry a dagger noting they were measured on the verbose variant. What webAI does show is that on AIME 2026 the balanced model averages about 19,500 tokens and scores 88.3, while Qwen3.5-9B uses 31,200 tokens for 92.5. That is a genuine trade: fewer tokens, a few points lower. Whether it suits you depends on the job. For batch-grading maths problems on a single GPU, shorter traces mean more problems per hour. For a hard one-off proof, the verbose variant — or a larger model — may serve better.
Verbose: the long thinker for hard problems
The verbose variant is the model before the length-shortening stage: it reasons longer, and on the hardest tests it scores higher. The headline LiveCodeBench figure of 81.6 and the IFBench figure of 74.4 were both measured on the verbose variant, not the default balanced one. That is the single most important caveat in the whole launch. A reader who downloads the default file and expects 81.6 on coding benchmarks may get something different — and to webAI’s credit, the model card flags this openly with daggers in its tables rather than burying it.
Both variants emit a think block before the answer, and both need a large generation budget. The model card warns that a short budget truncates the reasoning and scores far worse, and that low-effort modes score substantially lower. In practice, that means you should give TwIL-8B plenty of room to think — the example llama.cpp command in the card allows up to 32,768 output tokens — or you are not really testing the model at all.
TwIL-8B Benchmarks: The 93% Claim, Explained
The number everyone quotes is 93%: webAI says it reaches 93% of frontier-model performance on coding, 92% on instruction following, and 90% on contest mathematics. Here is exactly where those numbers come from, what they do and do not prove, and where the model is weak — because the benchmark story is more interesting, and more honest, than the headline.

Against open rivals
Against other open-weight models of similar size, the card reports a mixed but strong picture. All scores are webAI’s own runs at high effort with thinking enabled, and competitor scores are published figures the company did not re-run.
| Benchmark | TwIL-8B | Qwen3.5-9B | Gemma 4 12B | Gemma 4 31B |
|---|---|---|---|---|
| MATH-500 | 98.2 | 96.6 | n/a | 87.9 |
| AIME 2026 | 88.3 | 92.5 | 77.5 | 89.2 |
| HMMT Feb 2026 | 68.2 | 71.2 | n/a | 77.2 |
| GPQA Diamond | 70.2 | 81.7 | 78.8 | 84.3 |
| IFBench (verbose) | 74.4 | 64.5 | 74.0 | 76.0 |
| LiveCodeBench (verbose) | 81.6 | 65.6 | 72.0 | 80.0 |
The pattern is clear. TwIL-8B leads its comparison on contest maths and code: 98.2 on MATH-500 is the top score in the card’s table, and the 81.6 on LiveCodeBench beats Qwen3.5-9B by a full 16 points and edges out even the much larger Gemma 4 31B. On instruction following it beats Qwen3.5-9B by nearly 10 points.
But on knowledge-heavy tests it trails badly: 70.2 on GPQA Diamond against 81.7 for Qwen3.5-9B, and just 12.6 on Humanity’s Last Exam, with 76.5 on MMLU-Pro. The card’s own head-to-head summary says it wins 7 and loses 6 of 13 shared benchmarks against Qwen3.5-9B, and wins only 3 and loses 11 of 14 against the far larger Gemma 4 31B. This is a specialist, not an all-rounder.
Against the frontier: where 93% comes from
The frontier comparison is where the famous percentages live. webAI compares the model against GPT-5.5, Claude Opus 4.8, and Grok 4.3 at their highest published reasoning effort, and reports the share of the best frontier score the small model reaches: 93% on LiveCodeBench (81.6 against a best of about 87.7), 92% on IFBench (74.4 against 81.3), 90% on HMMT November 2025 (86.7 against 96.5), and 88% on AIME 2026 and HMMT February 2025. It also beats Claude Opus 4.8 outright on IFBench, by 12.2 points.
But the same table shows the other side. On the hardest contest set, HMMT February 2026, it reaches only 69% of the frontier. On GPQA Diamond it reaches 75%. On Humanity’s Last Exam — the hardest general-knowledge test in the set — it reaches just 26%. The card states plainly: “It is not a knowledge model.” The 93% figure is real arithmetic from the model’s own numbers, but it describes coding, the model’s best subject, not its overall ability.
There is also a quiet problem with the comparison itself. The card notes that newer frontier releases — including GPT-6.1 Sol, Claude Opus 5.5, and Grok 4.7 — no longer report AIME, HMMT, or GPQA scores at all, so the frontier comparison uses older models. The “frontier” TwIL-8B is measured against is the frontier of a few months ago, not today’s. That does not make the numbers wrong, but it does mean the gap to the current best models is wider than 93% suggests.
Fewer tokens than its open rival
One of the more useful numbers in the card is not a score at all, but a token count. On AIME 2026, the model averages about 19,500 output tokens per problem, against 31,200 for Qwen3.5-9B — roughly 38% fewer. On HMMT February 2026 the numbers are 32,900 against 40,600. In plain words, it reasons more tersely than its closest open peer. But the frontier models are far more efficient still: Claude Opus 4.8 averages 21,000 tokens on AIME 2026, and GPT-5.5 just 5,000. webAI itself says the harnesses and tokenizers differ, so the comparison is directional — but the direction is clear: TwIL-8B is efficient for its size class, and still far behind the frontier on tokens per answer.
A final note on reading these tables: on a 30-problem contest set, one problem is worth 3.3 points. A gap of two or three points on AIME or HMMT is within the noise of a single question. The large gaps — plus 16.0 on LiveCodeBench over Qwen3.5-9B, minus 11.5 on GPQA Diamond — are the informative ones. Small gaps are not.
Where It Falls Short
To its credit, the model card is more candid about its limits than many launch documents. Here is what it admits, and why each admission matters for anyone thinking of using the model.
The knowledge gap is structural, not a bug
TwIL-8B trails larger open models and the frontier by wide margins on every knowledge benchmark: GPQA Diamond 70.2 against 84.3 for Gemma 4 31B, Humanity’s Last Exam 12.6, MMLU-Pro 76.5. The card explains why, and the explanation is honest: those tests reward stored knowledge, which tends to scale with parameter count more than with reasoning-focused training. A small model can learn to reason, but it cannot store as many facts as a big one. If your work is question-answering over general facts, trivia, or broad knowledge, it is the wrong tool — read the GPQA and HLE rows first, not the MATH-500 row.
What webAI did not test at all
The card states that SWE-bench, SuperGPQA, tool use, and agentic tasks were not evaluated. That is a significant gap for a model being sold partly as a coding model. LiveCodeBench measures whether a model can write a correct function from a description; SWE-bench measures whether it can fix a real bug in a real repository, and tool use measures whether it can call functions, search files, and operate software. None of that has been measured for the model. Anyone building coding agents on top of it is working without a benchmark safety net — and the independent test in the next section shows exactly how that can go wrong.
The card also says there is no safety or preference tuning beyond what the Granite 4.2 base model carries. That matters if you plan to expose the model to other users: it has not been specifically tuned to refuse harmful requests or to behave helpfully in open-ended conversation. For personal, local use that is a minor note. For anything user-facing, it is a real gap.
Finally, the cross-harness caveats: competitor numbers come from each vendor’s own model card or third-party tests, with their own prompts, sampling settings, and token budgets. webAI did not re-run them. And the GGUF performance question is open: all reported scores were measured on the full bf16 weights, and the card says the 4.98 GiB Q4_K_M build most local users will actually run may deviate slightly. The number you read on the card is not necessarily the number you get on your laptop.
The Licence: Open Weights Is Not Open Source
Here is the part of the TwIL-8B story that most launch coverage glossed over, and it matters more than any benchmark: TwIL-8B is not open source. The weights are open — anyone can download them from Hugging Face — but they are distributed under the webAI Non-Commercial License version 1.0, which limits use to non-commercial research and educational purposes only. You may study the model, run it for yourself, and test it. You may not build a paid product on it, sell access to it, or ship it inside a commercial service unless webAI grants you terms.
That is a very different deal from the Apache 2.0 licence on the IBM Granite 4.2 base model, which permits commercial use freely. The base is open; the post-trained model built on top of it is not. This is the same pattern the industry has settled into over the past two years: open weights, restricted licence. Meta’s Llama models, Google’s Gemma family, and now webAI’s TwIL line all draw a line between “you can download it” and “you can sell with it.”
For most readers, the practical effect is simple. If you want a small coding and maths model for your own machine — homework, personal projects, research, learning how reasoning models behave — the licence is no obstacle at all. If you want to put TwIL-8B inside a product you charge for, the licence blocks you unless you negotiate with webAI. Read the LICENSE file in the Hugging Face repository before building anything on it, and do not assume that “open weights” means “free to commercialise.” It does not.
The Independent Reality Check: Outside webAI’s Lab
Benchmarks are the maker’s claim; the real test is what happens when someone else runs the model. Within three days of launch, two independent checks appeared — and together they give a much more useful picture than the model card alone.

The Mac Studio spot check
The first check came from Novel Cognition, which ran TwIL-8B for evaluation only against Qwen3-8B and DeepSeek V4 Flash on a Mac Studio M3 Ultra with 256 GB of memory. The test was deliberately small and honest about it: eight machine-scored tasks — a code fix, a function written to a specification, a seven-rule writing brief, two counting puzzles, two trivia quizzes, and a data extraction — run three times each. The model passed 164 of 168 checks, ahead of Qwen3-8B at 153 and behind DeepSeek V4 Flash, which passed all 168.
The interesting finding was speed. The model generated text about 3.6 times faster than DeepSeek, but averaged 50 seconds per answer against 22 — because it wrote about seven times as much, most of it reasoning. That is the reasoning-model trade-off in one number: fast token generation, slow answers, because the thinking is the work. The researchers were careful to call it a spot check, not a benchmark. Eight tasks cannot settle a model’s quality. But the direction matched the model card: strong on code and structured tasks, weaker on trivia and knowledge — exactly where the GPQA and HLE rows said it would be.
The real coding job: 11 of 15 runs
The second check was harder, and more revealing. On 7 November, the Tokenwright project gave the model a real coding job: the Q4_K_M build running through llama.cpp on an M4 Pro with 24 GB of memory, working through 15 coding tasks in an agent harness, with Claude Haiku 5.5 running the same tasks for comparison. The model passed 11 of 15 runs — 73%. Claude Haiku 5.5 passed every run. And the time gap was stark: 15 tasks took 65 minutes locally against about 1.6 minutes for Claude.
The failures were more informative than the pass rate. Every failure had the same shape: the model knew what to do and did not do it. It read an empty file 18 times. It wrote its tool call inside its private thinking block instead of actually calling the tool. On one task it thought for 12,000 tokens — about ten minutes — in a single reply and got cut off before writing the fix.
On another it stopped with a test still failing. The model used about 10 GB of memory and wrote roughly 36 tokens a second, which is respectable for local hardware. The problem was not speed or memory. It was agency: the model was never evaluated on tool use or agentic tasks, and in an agent harness that showed.
That is the honest summary of where the model stands a few days after launch. On the tasks its maker measured — contest maths, code generation, instruction following — the model is genuinely strong for its size, and the independent spot check supports that. On the tasks its maker did not measure — using tools, working through a multi-step job, knowing when to stop thinking and act — it is unproven, and the first real test found it wanting. A reasoning model that thinks brilliantly and acts clumsily is still a useful model. It is just not a coding agent yet.
How to Run It Locally
There is no managed API for the model and no hosted inference provider serving it — at least not yet. If you want to use it, you download the weights and run them yourself. That is the whole point of the release, and the good news is that an 8.8B model is genuinely runnable on ordinary hardware. Here is how.

Option 1: llama.cpp (the easy route)
For most people, the simplest path is llama.cpp with the 4.98 GiB Q4_K_M GGUF file. The model card gives this command, which downloads the file from Hugging Face and starts a chat session:
llama-cli -hf webAI-Official/TwIL-8B --hf-file TwIL-8B-Q4_K_M-balanced.gguf -cnv -c 40960 -n 32768
The flags matter. -c 40960 sets a 40,960-token context, and -n 32768 allows up to 32,768 output tokens — a large generation budget, which the card explicitly recommends. A short budget truncates the reasoning and the model scores far worse. If you are new to local inference, our guide to running AI coding models locally on a Mac walks through the same llama.cpp setup step by step.
Option 2: Hugging Face Transformers
If you prefer Python, load the model with AutoModelForCausalLM and pass subfolder="verbose" for the verbose variant. You will need a Transformers release with Granite 4.2 support, and the full bf16 weights are 16.38 GiB per variant — so make sure you have the disk space and the GPU memory before you start. The default sampling settings are temperature 1.0 and top_p 0.95.
What hardware do you need?
The 4.98 GiB Q4_K_M build runs on a CPU or a modest-VRAM GPU, and the independent tests bear that out: the Tokenwright run used about 10 GB of memory on an M4 Pro with 24 GB, and Novel Cognition ran it on a Mac Studio.
A modern laptop with 16 GB of RAM can run it; 24 GB or more is more comfortable, especially with the 131,072-token context window in play. The full bf16 weights at 16.38 GiB need a GPU with at least 16 GB of VRAM, or a machine with enough system RAM to hold them. A Q8_0 build at 8.70 GiB exists for the verbose variant only, as does an F16 build at 16.38 GiB. Remember that all the published benchmark scores were measured on bf16, so the 4-bit build you most likely run may score slightly lower than the numbers in the card.
Settings that matter
Three settings decide whether you get the model the card describes. First, give it a large generation budget — the reasoning is the product, and cutting it short cuts the quality. Second, use the default sampling settings (temperature 1.0, top_p 0.95) unless you have a reason to change them; the scores were measured there. Third, pick the right variant for the job: balanced for everyday work and speed, verbose for hard contest-style problems where accuracy matters more than time.
TwIL-8B vs Qwen3.5-9B vs Gemma 4
The model’s most direct rival is Qwen3.5-9B: same size class, same open-weight audience, same local-hardware pitch. Gemma 4 is the other name in the card’s tables, in 12B and 31B sizes. Here is how they compare on the facts that matter to a buyer or a downloader, not just the scores.
| TwIL-8B | Qwen3.5-9B | Gemma 4 31B | |
|---|---|---|---|
| Parameters | 8.79B | ~9B | 31B |
| Smallest local file | 4.98 GiB (Q4_K_M) | ~5–6 GiB (Q4 GGUF) | ~19 GiB (Q4 GGUF) |
| Context window | 131,072 tokens | 256,000 tokens | 128,000 tokens |
| LiveCodeBench | 81.6 (verbose) | 65.6 | 80.0 |
| MATH-500 | 98.2 | 96.6 | 87.9 |
| GPQA Diamond | 70.2 | 81.7 | 84.3 |
| Tokens per AIME problem | ~19,500 | ~31,200 | Not reported |
| Licence | Non-commercial only | Apache 2.0 | Gemma licence (commercial use allowed with terms) |
| Tool use / agents evaluated? | No | Yes | Yes |
The choice comes down to what you value. TwIL-8B wins on coding and contest maths, and it thinks in fewer tokens than Qwen3.5-9B — but its non-commercial licence is the decisive difference. Qwen3.5-9B is Apache 2.0: you can build a product on it, ship it, and charge for it. TwIL-8B you cannot, without webAI’s permission. For personal and research use, its coding edge is real. For anything commercial, Qwen3.5-9B is the safer default, and its knowledge scores are far stronger. Gemma 4 31B is the strongest all-rounder of the three on knowledge, but at 31B parameters it needs substantially more hardware — roughly four times the memory of the model at the same quantisation.
For readers weighing the wider open-weight landscape, our Drex Max open-weights guide covers another recent local model in the same spirit, and the Kimi K3.1 Pro weights guide shows what the other end of the scale looks like — a much larger model with a very different hardware bill.
Pricing: Free to Download, Not Free to Run
TwIL-8B costs nothing to download. There is no subscription tier, no per-token API price, and no paid plan — because there is no API at all. That is the whole pricing story on webAI’s side. The cost you actually pay is on yours: the hardware to run it, and the electricity to keep it running.
That is worth spelling out, because “free” in AI usually means “free until the bill arrives.” With TwIL-8B, the bill is honest and one-off. A laptop you already own, 5 GB of disk space, and a few cents of electricity per session is genuinely all it takes to run the 4-bit build. Compare that with the alternative: renting a frontier model through an API, where every answer costs tokens and a long reasoning trace costs real money. A single hard problem can cost a reasoning model 30,000-plus output tokens on an API. Run locally, those tokens cost you nothing but time.
Time is the hidden price, though. The independent coding test put it plainly: 15 tasks took 65 minutes locally against about 1.6 minutes through Claude’s API. Your time has a value, and for paid work the API is usually cheaper than the hour. The model’s economics only win when your time is flexible, your tasks are small, or your reason for running locally is privacy, learning, or independence from a vendor — not raw speed. And remember the licence: “free” here covers research and study, not commercial use. If the model makes you money, the licence says you owe webAI a conversation first.
Who Should Use It — and Who Should Skip It

TwIL-8B is a strong pick for:
- Local-AI enthusiasts who want a small model that is genuinely strong at maths and code, and who are fine with long reasoning traces. If you already run models with llama.cpp, this is a 5 GB download that earns its disk space.
- Students and researchers studying reasoning models. The balanced variant is a rare public example of length-aware RL — a model trained explicitly to trade accuracy for fewer tokens — and the two variants make that trade-off visible and testable.
- Developers comparing open reasoning models. TwIL-8B is a useful data point next to Qwen3.5-9B and Gemma 4, especially on code generation and instruction following. Treat the model card as a lead to test, not a verdict.
- Anyone who values privacy. The model runs entirely on your machine. Your prompts, your code, and your documents never leave your hardware — which is the one advantage no API model can match at any price.
TwIL-8B is the wrong pick for:
- Anyone building a commercial product. The non-commercial licence blocks it unless webAI grants terms. Use an Apache 2.0 model such as Qwen3.5-9B instead.
- Anyone who needs broad knowledge. General question-answering, trivia, and factual work are this model’s weak spots. Read the GPQA Diamond and Humanity’s Last Exam rows before downloading.
- Anyone building coding agents. Tool use and agentic tasks were never evaluated, and the first independent agent test found the model writing tool calls into its thinking instead of executing them. Wait for agentic benchmarks, or use a model that has them.
- Anyone who needs speed above all. Sixty-five minutes for 15 tasks that take a frontier API under two minutes is a real cost. If your time is billable, the API wins.
Frequently Asked Questions
What is TwIL-8B?
TwIL-8B is an 8.79-billion-parameter reasoning model from webAI, published on Hugging Face on 4 November 2026. It is post-trained from IBM’s Granite 4.2 8B with full-parameter supervised fine-tuning followed by GRPO/DAPO reinforcement learning. It targets maths, code, and instruction following, and it emits a think block before answering.
What are the headline benchmark claims for the model?
webAI’s model card reports 98.2 on MATH-500, 88.3 on AIME 2026, and 81.6 on LiveCodeBench — the last measured on the verbose variant, not the default balanced one. The company says this is 88–93% of the best frontier score on several benchmarks. These are webAI’s own runs, compared with competitor figures it did not re-run, and they have not been independently reproduced.
Can I run TwIL-8B on my own machine?
Yes. The balanced variant has a 4.98 GiB Q4_K_M GGUF file for llama.cpp, and the full bf16 weights are 16.38 GiB. The card notes that scores were measured on bf16, so the quantised build may deviate slightly. The model needs a large generation budget because it reasons at length — give it up to 32,768 output tokens or it will cut its thinking short.
Can I use the model commercially?
No — not without permission. The model is distributed under the webAI Non-Commercial License 1.0, which covers research and educational purposes only. The IBM Granite base model is Apache 2.0, but that licence does not carry over to webAI’s post-trained weights. Read the LICENSE file in the Hugging Face repository before building on it.
Is TwIL-8B open source?
No. Its weights are open — anyone can download them — but the non-commercial licence means it does not meet the definition of open source. “Open weights” and “open source” are different things, and TwIL-8B is the former, not the latter.
Does TwIL-8B beat frontier models?
Not overall. webAI says it reaches 93% of the best frontier score on coding, but only 69% on the hardest contest set (HMMT February 2026) and 26% on Humanity’s Last Exam. It also beats Claude Opus 4.8 on IFBench by 12.2 points — but the comparison uses older frontier models, because the newest ones no longer report these benchmarks. It is a strong specialist, not a frontier replacement.
Where can I download the model?
From Hugging Face, at huggingface.co/webAI-Official/TwIL-8B. There is no managed API and no hosted inference provider, so local download is currently the only way to use it. For an independent claimed-versus-verified breakdown of the model card, see the analysis at explainx.ai.
The Bottom Line
TwIL-8B is the most interesting small-model launch of November 2026, and the most honestly presented. webAI claims a 5 GB model that codes at 93% of the frontier, and on the evidence available a few days after launch, the claim is roughly right in the narrow sense it was made: on code generation and contest maths, this small reasoning model is genuinely strong, it thinks in fewer tokens than its closest open rival, and it runs on hardware most developers already own. The independent spot checks support the direction of the claim, even as the harder agent test shows its limits.
But the honest reading has three asterisks, and they are the ones that decide whether you should download it. First, the headline numbers are webAI’s own, measured on the verbose variant and the full-precision weights — not the default file you will actually run. Second, the model is weak where small models are always weak: stored knowledge, where it reaches only a quarter of the frontier on the hardest test. Third, and most important, it is not open source. The non-commercial licence means TwIL-8B is a model to learn from, not a model to build a business on.
If that fits your use — personal coding help, maths practice, research into reasoning models, or a private local assistant that never sends your data anywhere — download it. It is free, it is fast for its size, and it is a genuine step toward Karpathy’s argument that small models will be enough for most everyday work. If you need a commercial product, a knowledge engine, or a coding agent, look elsewhere. TwIL-8B knows what it is good at. The model card says so, the benchmarks say so, and the independent tests say so. The smart move is to believe all three.
