TwIL-8B: Run webAI’s Small Maths and Code Reasoning Model Locally (Ollama, LM Studio, llama.cpp)

TwIL-8B is a small reasoning model from webAI that punches well above its size on maths and code.

It scores 98.2 on MATH-500 and 88.3 on AIME 2025, and its verbose version hits 81.6 on LiveCodeBench, ahead of Gemma 4 31B on that test. Its Q4 file is just under 5 GB, so it runs on an ordinary gaming GPU.

There are a few catches: it is non-commercial, it is weak on general knowledge, and it thinks for a long time.

This guide covers what TwIL-8B is, which file to download, the exact Ollama, LM Studio and llama.cpp commands, the settings that matter, how it compares with Qwen3.5-9B and Gemma 4, and fixes for the usual problems.

What TwIL-8B Is

TwIL-8B comes from webAI. It starts from IBM’s open Granite 4.2 8B base and adds two rounds of training:

1. Full-parameter supervised fine-tuning on maths, code and instruction data.
2. Reinforcement learning with GRPO and DAPO, the same family of methods used to train many recent reasoning models.

webAI does not give a release date on the card. The comparison figures on it were collected on 3 November 2026, so it is a very new model.

Balanced vs Verbose

The repo holds two trained versions of the same model.

Start with balanced. Switch to verbose only when balanced gets a hard problem wrong and you do not mind waiting longer. Some of the headline benchmark scores (LiveCodeBench, IFBench, MMLU-Pro, HumanEval) come from the verbose version.

Files and VRAM

The GGUF files sit in the same repo as the main weights.

The “suggested GPU” column is my own sizing rule, not webAI’s: the file plus a few GB for the context. Because TwIL thinks for tens of thousands of tokens, the context cache matters more than usual.

On an 8 GB card, Q4_K_M with a moderate context is the realistic setup, and a 12 GB or 16 GB card gives room for the full 40K context the card uses.

Our VRAM guide and GGUF quantization guide explain how to size a model for your card.

Run It in Ollama

Ollama can pull GGUFs straight from Hugging Face. If you do not have Ollama yet, see our Ollama install guide.

ollama run hf.co/webAI-Official/TwIL-8B:Q4_K_M

That pulls a Q4_K_M build and opens a chat. Because the repo has two Q4_K_M files, check which one Ollama picked with ollama show hf.co/webAI-Official/TwIL-8B:Q4_K_M. If you want to be sure you get balanced, use llama.cpp or LM Studio and choose the file by name.

Raise Ollama’s context, or long answers will be cut off. Inside the chat, type:

/set parameter num_ctx 40960

Our Ollama commands cheat sheet lists the other parameters you can set.

Run It in LM Studio

1. Open the TwIL-8B model page and press the LM Studio button under “Use this model”, or search for webAI-Official/TwIL-8B in LM Studio’s model search.
2. Pick TwIL-8B-Q4_K_M-balanced.gguf (or a verbose file).
3. When you load it, set the context length to at least 40,960.
4. In the model settings, set temperature 1.0 and top_p 0.95.

LM Studio hides the <think> block in a collapsible section, which keeps long reasoning readable.

Run It in llama.cpp

For a chat in the terminal, with the balanced file and the card’s context and output budget:

llama-cli -hf webAI-Official/TwIL-8B --hf-file TwIL-8B-Q4_K_M-balanced.gguf -cnv -c 40960 -n 32768

Add -ngl 99 to put every layer on the GPU if your build does not do that already. To serve an OpenAI-compatible API that tools like Open WebUI can use:

llama-server -hf webAI-Official/TwIL-8B --hf-file TwIL-8B-Q4_K_M-balanced.gguf -c 40960 -ngl 99 --port 8080

The card also gives llama serve -hf webAI-Official/TwIL-8B:Q4_K_M for newer llama.cpp builds. Our Open WebUI setup guide shows how to add a local server as a model.

Run It in Python (Transformers)

For the full bf16 weights (about 16.4 GiB) on a 24 GB GPU:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

repo = "webAI-Official/TwIL-8B"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(
    repo, torch_dtype=torch.bfloat16, device_map="auto"
    # add subfolder="verbose" for the verbose version
)

messages = [{"role": "user", "content": "Find all real x with x^2 - 5x + 6 = 0. Reason step by step."}]
inputs = tok.apply_chat_template(
    messages, add_generation_prompt=True,
    return_tensors="pt", return_dict=True
).to(model.device)

out = model.generate(**inputs, max_new_tokens=32768, temperature=1.0, top_p=0.95, do_sample=True)
print(tok.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

On Transformers 5.x, keep return_dict=True. Without it, apply_chat_template returns a BatchEncoding and the generate call fails. For serving, vLLM and SGLang both work and give an OpenAI-compatible endpoint.

Settings That Matter

The output budget is the setting people get wrong most. TwIL-8B averaged about 19.5k output tokens per AIME 2026 problem and about 33k per HMMT February 2026 problem in webAI’s tests. Ollama’s and LM Studio’s default context lengths are far smaller than that.

The two speed switches (thinking off and low effort) go through chat_template_kwargs. None of the card’s scores use them, so expect much weaker answers with them on.

Benchmarks vs Qwen3.5-9B and Gemma 4

These are webAI’s own numbers. Competitor scores were taken from published sources, not re-run, so small gaps are within the noise of different test setups. A dagger (†) marks a verbose-version score.

The pattern is clear. On maths and competitive code, TwIL-8B is level with or ahead of models up to four times its size. On knowledge tests (GPQA Diamond, MMLU-Pro, HLE), it trails Qwen3.5-9B and both Gemma 4 models.

It also writes fewer tokens than Qwen3.5-9B for similar maths scores: 19.5k vs 31.2k per AIME 2026 problem. That matters on a slow local GPU.

Frontier models are still far ahead on the hardest tests. GPT-5.5 and Claude Opus 4.8 both score 100 on AIME 2026 and over 93 on GPQA Diamond in the same table. For general local picks, see our Gemma 4 local guide and best Ollama models by VRAM.

What It Is Good and Bad At

Good at:

• Maths homework, olympiad-style problems and step-by-step proofs.
• Algorithm and contest coding questions.
• Following precise formatting instructions.
• Running offline on an 8 GB to 12 GB GPU.

Not good at, according to webAI:

• General knowledge and facts. It is weaker than larger models here.
• Agent and tool-use work. There is no tool-use, preference or safety tuning beyond what Granite 4.2 already has, and SWE-bench and agent tasks were not tested.
• Being a chat assistant. The card says plainly it is “not a general assistant”.
• Languages other than English.

If you want a local coding agent rather than a maths solver, look at the models in our Qwen3.8-Flash-Next guide instead.

Licence

TwIL-8B uses the webAI Non-Commercial License ver. 1.0. As the name says, it is for non-commercial use. The full terms are in LICENSE.md in the repo, so read it before you use the model in anything you sell or run for clients.

The Granite 4.2 8B base model it starts from is Apache 2.0, and IBM’s licence and attribution are kept in the repo.

Troubleshooting

Answers stop half way through the thinking

The output budget or context is too small. Set max tokens to 32,768 and context to 40,960 (in Ollama, /set parameter num_ctx 40960). This is the number one problem with TwIL-8B.

It takes minutes to answer a simple question

That is the long thinking. Use balanced instead of verbose, keep all layers on the GPU, and for easy questions consider a general model. You can turn thinking off with enable_thinking=False, but quality drops a lot.

It gets facts or dates wrong

Expected. It was trained for maths and code, and its knowledge scores are low. Do not use it for factual lookups.

It never stops or prints <|im_end|>

The chat template is not being applied. The GGUFs use a ChatML-style template with <|im_end|> as the end token. Update your app, and in llama.cpp use chat mode (-cnv) or llama-server, which read the template from the file.

Transformers error about BatchEncoding

Pass return_dict=True to apply_chat_template, as in the example above.

Out of memory on an 8 GB card

Lower the context to 16K to 24K, or offload a few layers to the CPU. Our VRAM usage guide shows how to see what is filling the card.

FAQ

Is TwIL-8B free?

It is free to download and use for non-commercial work under the webAI Non-Commercial License. Commercial use is not covered.

Can I run TwIL-8B on an 8 GB GPU?

Yes. The Q4_K_M file is 4.98 GiB, which leaves room for a moderate context on an 8 GB card.

Should I pick balanced or verbose?

Balanced for most use. Verbose only for hard problems where you will wait for a better answer.

Is TwIL-8B better than Qwen3.5-9B?

On code (LiveCodeBench) and MATH-500, yes, by webAI’s numbers. On AIME 2026, HMMT and knowledge tests, Qwen3.5-9B is ahead. TwIL also uses fewer tokens per problem.

Does it support tool calling?

Not in a tuned way. It has only what Granite 4.2 includes, and webAI did not test tool use.

What does TwIL stand for?

webAI does not explain the name on the model card.

Can I use it in Cline or Continue for coding?

You can point them at a local llama-server or Ollama endpoint, but it is not tuned for agent work. For editor agents, see our Cline and Continue setup guide.

Sources

• webAI-Official/TwIL-8B model card (specs, files, commands, benchmarks, licence)
• IBM Granite 4.2 8B (base model)