1. Learn
  2. Pick a model

The best local LLM for reasoning and math

Which open models reason best through math, logic and multi-step problems on 8 GB to 64 GB+, how thinking mode works, and why speed matters more than you'd expect.

Updated Oct 26, 2026 · RunItLocal.io

For math, logic puzzles and multi-step problems, the models to use are the ones that think before they answer. Qwen3 and gpt-oss both write out their working first, then give the answer. That makes them much more accurate on hard problems, and much slower, because the thinking is extra text the model has to generate.

Picks by memory

MemoryPickCommandNotes
8 GBQwen3 8Bollama run qwen3:8bThinking mode on a small card
12 GBQwen3 14Bollama run qwen3:14bA clear step up in reasoning
16 GBgpt-oss 20Bollama run gpt-oss:20bStrong reasoning, and fast
24 GBQwen3 32B or gpt-oss 20Bollama run qwen3:32b32B for careful work, 20B for speed
64 GB+gpt-oss 120Bollama run gpt-oss:120bThe strongest reasoning you can run at home

Gemma 3 and Llama 3.3 don't have a thinking mode. They're good at writing and knowledge, but for math and logic, Qwen3 and gpt-oss do better at the same size.

How to turn thinking on

  • Qwen3: the model thinks by default. Add /no_think to a message to skip it for simple questions, and /think to turn it back on.
  • gpt-oss: always reasons, with an effort level of low, medium or high. Higher effort means longer thinking and better answers on hard problems. Many apps expose this as a setting; you can also ask for it in the system prompt.

More on how this works in thinking models explained.

Why speed matters more here

A thinking model can write a thousand or more tokens of working before it starts the answer. At reading speed that's fine for chat, but for reasoning it's the difference between waiting seconds and waiting minutes.

Some arithmetic using our calculator's estimates on a 24 GB RTX 3090, for a problem that takes 2,000 tokens of thinking:

ModelEstimated speedTime to think 2,000 tokens
gpt-oss 20B~164 tok/sabout 12 seconds
Qwen3 30B-A3B~164 tok/sabout 12 seconds
Qwen3 32B~26 tok/sabout 77 seconds

That's why gpt-oss 20B is such a good reasoning pick on 16 to 24 GB: it's a mixture-of-experts model that only works a few billion parameters per token, so it can afford to think. Use Qwen3 32B when you'd rather wait for a more careful answer.

RTX 3090, 24 GB · estimated with our calculator · full page

  • Qwen3 4BQuick everyday chat and summaries
    ~210 tok/s
    Runs greatqwen3:4b
  • Qwen3 8BA solid all-rounder for chat and writing
    ~99 tok/s
    Runs greatqwen3:8b
  • Gemma 3 12BReads images as well as text
    ~64 tok/s
    Runs greatgemma3:12b
  • Qwen3 14BNoticeably smarter at reasoning and code
    ~55 tok/s
    Runs greatqwen3:14b
  • gpt-oss 20BOpenAI's open model. Fast, strong reasoning
    ~160 tok/s
    Runs greatgpt-oss:20b
  • Gemma 3 27BGoogle's best open model for its size
    ~30 tok/s
    Runs greatgemma3:27b
  • Qwen3 30B-A3B30B smarts at small-model speed
    ~160 tok/s
    Runs greatqwen3:30b
  • Qwen3 32BStrong coding and long answers
    ~26 tok/s
    Usableqwen3:32b
  • Llama 3.3 70BClose to the big cloud models
    needs 45 GB
    Too bigllama3.3:70b
  • gpt-oss 120BOpenAI's largest open model
    needs 67 GB
    Too biggpt-oss:120b
  • Qwen3 235B-A22BAlibaba's flagship open model, for multi-GPU rigs
    needs 144 GB
    Too bigqwen3:235b
  • DeepSeek R1 671BThe full DeepSeek R1, for the biggest rigs
    needs 406 GB
    Too bigdeepseek-r1:671b

Give it room to think

  • Raise the context length. Thinking uses context. If the conversation plus the model's working goes past the context limit, it forgets the start of the problem. Ollama's default is short; see increase Ollama's context length.
  • Ask for the steps. "Show your working, then give the final answer on its own line" makes the result easier to check.
  • Ask it to check. "Substitute your answer back into the original equation" catches a surprising number of mistakes.

Know the limits

  • Arithmetic on big numbers is unreliable. Models predict text, they don't calculate. For exact numbers, ask it to write a short Python script and run that instead.
  • Long chains drift. On very long problems, small models lose track. Break the problem into parts.
  • It will sound sure when it's wrong. Check anything that matters, especially from 8B and 14B models.

Good uses

  • Working through homework-style math and physics problems step by step, and explaining each step.
  • Logic puzzles, scheduling constraints, and "what am I missing" checks on a plan.
  • Reviewing a spreadsheet formula or a proof for errors.
  • Debugging code, where reasoning catches more than a quick answer. See the best local LLM for coding.

Want to know what your own machine can run? Check every GPU, or for the big models, see 32 GB and up and 64 GB+ Macs.