Olmo-3.1-32B-Think

Olmo-3.1-32B-Think

Reasons step by step in English before it answers, which helps with math and coding questions. A 32B open model from allenai with published code, checkpoints and training details, run through transformers.

Made by allenai on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Olmo 3.1 32B Think is an open language model from allenai that thinks through a question at length before it answers. That long reasoning helps with math and coding tasks. It has 32.2B parameters, works in English, and starts from the Olmo-3-32B-Think-DPO model. It belongs to the Olmo 3 family, which comes in 7B and 32B sizes with Instruct and Think variants.

Who it suits: Researchers who want to study a fully open model fit best, and so do developers who want a reasoning model they can run through transformers on their own machine. Students and teachers who work on math problems can read its step-by-step thinking.

Industry | Who uses it | How they use it | Example
Research | Language-model researchers | Study a model whose code, checkpoints and training details are published | Loading an earlier training checkpoint by its step name
Software | Developers | Run a reasoning model locally through the transformers library | Asking a coding question and reading the thinking section before the answer
Education | Math students and teachers | Follow worked reasoning on math questions | Putting a math problem to the model and checking each step it writes

You can skip it if you need replies in a language other than English, since the record lists English only.

Where to use it: It runs in Python with the standard transformers library.

• Python with transformers 4.57.0 or higher
• Windows, macOS or Linux, where the files download through Python
• A CUDA GPU, which the card's optional lines use
• bitsandbytes, if you want the 8-bit option

Use case | Who | What they get back
Math questions | Students | Reasoning written out before the final answer
Coding questions | Developers | Code help that follows a thinking section
Training study | Researchers | Intermediate checkpoints loaded by step name

How to set it up: You need Python and room for the weights.

• Python on Windows, macOS or Linux
• transformers 4.57.0 or higher
• About 64.5 GB of disk for the BF16 weights, or about 16.1 GB at 4-bit, which is an estimate
• Optional: a CUDA GPU, and bitsandbytes for 8-bit loading

1. Install the Hugging Face hub library.
2. Download the model files with the hf command.
3. Install transformers at the version above.

pip install -U huggingface_hub
hf download allenai/Olmo-3.1-32B-Think

pip install transformers>=4.57.0

How to use it: Load the model and its tokenizer with transformers, tokenize a prompt, and call generate. The snippet below samples up to 100 new tokens and prints the decoded reply.

from transformers import AutoModelForCausalLM, AutoTokenizer
olmo = AutoModelForCausalLM.from_pretrained("allenai/Olmo-3.1-32B-Think")
tokenizer = AutoTokenizer.from_pretrained("allenai/Olmo-3.1-32B-Think")
message = ["Who would win in a fight - a dinosaur or a cow named Moo Moo?"]
inputs = tokenizer(message, return_tensors='pt', return_token_type_ids=False)
response = olmo.generate(**inputs, max_new_tokens=100, do_sample=True, top_k=50, top_p=0.95)
print(tokenizer.batch_decode(response, skip_special_tokens=True)[0])

Tool | What it does
AutoModelForCausalLM.from_pretrained | Loads the model weights
AutoTokenizer.from_pretrained | Loads the matching tokenizer
generate | Writes the reply tokens
batch_decode | Turns the tokens back into text
list_repo_refs | Lists every saved revision of the model

To load an earlier post-training checkpoint, add the revision argument with a step name.

olmo = AutoModelForCausalLM.from_pretrained("allenai/Olmo-3.1-32B-Think", revision="step_300")

The default system message sets up a plain helpful assistant.

<|im_start|>system
You are a helpful AI assistant.<|im_end|>

Example: You run the snippet and ask which of a dinosaur and a cow called Moo Moo would win in a brawl, the card's own sample question. The reply starts with a think section where the model reasons it through, and the answer follows.

For newcomers and experts: A Think model writes out its reasoning first and gives the answer after, so replies run longer than from a plain chat model. The first small thing to try is the 7B Think model in the same family, since it is much smaller than this 32B one.

The family trains in stages: SFT, then DPO, then RLVR for the final models. Pretraining used the Dolma 3 dataset, and the Dolci datasets were used afterwards. This 3.1 release starts from the Olmo-3-32B-Think-DPO model. Post-training checkpoints are saved as revisions named step_XXX, so you can load a point along the way. The 8-bit option reacts more to data types and CUDA, and the card advises moving the inputs onto the GPU. The sample caps output at 100 new tokens, so a long thinking section may use up that limit.

Download the weights with hf
Load model and tokenizer in transformers
Your prompt goes in as chat text
The model writes a think section first
The final answer follows

Good to know: The card says its logs are still coming soon.

• Family: Olmo 3 comes in 7B and 32B sizes, each as Instruct and Think.
• Other versions: the record counts 26 quantized and 15 fine-tuned versions made by other people.
• Quantizing: 8-bit loading needs bitsandbytes and reacts more to data types.

Title: Weight size by precision
BF16: 64.5 GB
4-bit (estimate): 16.1 GB

• License: Apache 2.0.
• Cost to run: no API key, account or paid service is named, but the BF16 weights take about 64.5 GB.
• Data it reaches: it downloads files from Hugging Face, and the snippet generates text on your own machine.
• Not for: the source names no forbidden uses.

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 32.2B
• Weights: about 64.5 GB in BF16; about 16.1 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 7,384
• Likes: 121
• License: apache-2.0
• Languages: en
• Based on: allenai/Olmo-3-32B-Think-DPO
• Quantized versions: 26
• Fine-tunes: 15
• Tags: transformers, safetensors, olmo3, text-generation, conversational

Links

• Model: https://huggingface.co/allenai/Olmo-3.1-32B-Think
• Files: https://huggingface.co/allenai/Olmo-3.1-32B-Think/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download allenai/Olmo-3.1-32B-Think

Then follow the usage in its model card. Nothing in this kit runs by itself.