Reasoning Models Cheatsheet: o1, DeepSeek-R1 and When to Use Them

Four months ago, "reasoning model" meant one product: OpenAI's o1-preview. Today there is a full o1 in the API, an announced o3, Google's Gemini 2.0 Flash Thinking, Alibaba's QwQ-32B-Preview, and, since January 20th, DeepSeek-R1: an open-weight model under the MIT license that matches o1 on several math and coding benchmarks at a fraction of the API price. On Monday, January 27th, Nvidia lost about 17% of its value in a single day, roughly $589 billion, largely on the market's reaction to DeepSeek.

The engineering questions are simpler than the noise. What are these models doing differently? When are they worth 10-30x the cost and latency of a chat model? Do your prompts still work?

This post is a practical cheatsheet: the concepts, the timeline, the prompting changes, how billing works when the "thinking" is invisible, and a decision table for choosing between a reasoning model and a standard one.

1. What a reasoning model is

A reasoning model is an LLM trained to generate a long chain of thought before it answers, and trained with reinforcement learning so that this thinking actually improves the answer.

OpenAI's description of o1: a large-scale reinforcement learning algorithm "teaches the model how to think productively using its chain of thought", and performance "consistently improves with more reinforcement learning (train-time compute) and with more time spent thinking (test-time compute)". That second axis is the new part. Until 2024, the main lever for quality was a bigger model trained on more data. Now there is a second lever you can turn per request.

DeepSeek's R1 paper made the training recipe concrete and public. DeepSeek-R1-Zero was trained with large-scale RL directly on a base model, with no supervised fine-tuning first, using simple rule-based rewards (is the answer correct, is the format right). Its pass@1 on AIME 2024 rose from 15.6% to 71.0% during training, and the model learned on its own to spend longer on hard problems and to re-check its work (the paper's "aha moment"). R1-Zero's output was hard to read and mixed languages, so DeepSeek-R1 added a small "cold start" of curated long-CoT examples before RL, plus later fine-tuning rounds for general tasks.

2. Timeline (to late January 2025)

3. When to use a reasoning model (and when not to)

Reasoning models are not "better chat models". They are better at a specific kind of task and worse value on most others.

Where they shine:

• Multi-step problems with a checkable answer: math, algorithms, competitive programming, logic puzzles, scheduling and constraint problems.
• Hard debugging and code reasoning: tracing why a test fails, finding the bug across several functions, reviewing a tricky diff.
• Planning: breaking an ambiguous task into steps, designing a schema or an architecture with many constraints, acting as the "planner" that cheaper models execute.
• Analysis of dense documents where the answer requires combining several facts: contracts, specs, research papers, financial filings.

The numbers behind the hype are real. On AIME 2024 (competition math), OpenAI reported GPT-4o solving about 12% of problems and o1 74% with one sample. DeepSeek reports R1 at 79.8% pass@1, slightly above o1-1217, and 97.3% on MATH-500.

Where they are a waste:

• Simple or latency-sensitive tasks: classification, extraction, short rewrites, autocomplete, chat small talk. A standard model is faster, cheaper and just as accurate.
• Knowledge lookup: thinking longer does not add facts the model does not know. Use retrieval.
• Creative and stylistic writing: in OpenAI's own human preference tests, o1-preview beat GPT-4o by a large margin on coding, math and data analysis, but was "not preferred on some natural language tasks".
• High-volume pipelines: at 10-30x the per-call cost, the budget runs out before the quality gain shows up.
• Tasks needing features the model lacks: at launch, R1 in DeepSeek's API supports no function calling or JSON output; o1-mini lacks some o1 API features. Check before you design around one.

A useful rule: if a careful human would need a scratchpad, consider a reasoning model. If they would answer immediately, do not.

4. Prompting reasoning models

Most of what you learned prompting GPT-4-class models still applies (clear task, context, output format). Three habits need to change.

1. Stop scripting the thinking. OpenAI's advice for o1 since launch: keep prompts simple and direct, and avoid chain-of-thought prompts. "Think step by step" or a hand-written 12-step procedure is redundant at best, and can make results worse by constraining a model that was trained to plan on its own.

2. Give goals, constraints and the definition of done. Describe the problem, what a correct answer must satisfy, and the output format. Let the model figure out the steps.

3. Be careful with extra context and examples. OpenAI recommends limiting retrieved context to the most relevant pieces (and using delimiters to separate parts of the input). DeepSeek found R1 "sensitive to prompts": few-shot prompting consistently degraded its performance, and recommends zero-shot prompts that describe the problem and specify the output format.

Provider-specific notes, as of this week:

• OpenAI o1: system instructions go in a developer message in the API. Use max_completion_tokens (not max_tokens), which caps reasoning plus visible output. OpenAI suggests reserving at least 25,000 tokens for reasoning and output when you start, so answers are not cut off while you still pay for the thinking.
• DeepSeek-R1: put all instructions in the user message (no system prompt). For self-hosted weights, use temperature 0.5-0.7 (0.6 recommended) to avoid repetition. For math, DeepSeek suggests asking the model to reason step by step and put the final answer in \boxed{}. In DeepSeek's API, temperature and top_p are accepted but ignored.

5. Reasoning effort, hidden tokens and billing

The cost model is different from what you are used to, because you pay for tokens you may never see.

Why OpenAI hides it: OpenAI says it wants to be able to monitor the raw chain of thought for signs of misbehavior, which works better if the CoT is not trained to look good to users, and cites competitive advantage. Why DeepSeek shows it: so users can "view, display, and distill it". For an engineer the practical difference is debuggability. With visible reasoning you can see why the model went wrong; with hidden reasoning you can only see the token count.

List prices per million tokens in January 2025 (input / output):

A quick estimator. The point is the multiplier from reasoning tokens, which do not appear in the answer:

PRICES = {  # USD per 1M tokens (input, output), list prices in January 2025
    "gpt-4o": (2.50, 10.00),
    "o1-mini": (3.00, 12.00),
    "o1": (15.00, 60.00),
    "deepseek-reasoner": (0.55, 2.19),  # R1, cache-miss input
}


def cost(model: str, input_toks: int, visible_out: int, reasoning: int = 0) -> float:
    p_in, p_out = PRICES[model]
    return (input_toks * p_in + (visible_out + reasoning) * p_out) / 1_000_000


# Same task: 2,000 tokens in, 500-token answer. Reasoning models also "think".
print(f"gpt-4o            ${cost('gpt-4o', 2000, 500):.4f}")                       # $0.0100
print(f"o1-mini           ${cost('o1-mini', 2000, 500, reasoning=5000):.4f}")      # $0.0720
print(f"o1                ${cost('o1', 2000, 500, reasoning=5000):.4f}")           # $0.3600
print(f"deepseek-reasoner ${cost('deepseek-reasoner', 2000, 500, reasoning=5000):.4f}")  # $0.0131

With 5,000 reasoning tokens, one o1 call costs about 36 times a GPT-4o call for the same visible answer. Measure real reasoning token counts on your own tasks: they vary a lot with difficulty and effort level.

Reading the hidden token count from OpenAI, and the visible reasoning from DeepSeek, with the same SDK:

from openai import OpenAI

# OpenAI o1: reasoning is hidden, but counted
client = OpenAI()
r = client.chat.completions.create(
    model="o1",
    reasoning_effort="medium",           # low | medium | high
    max_completion_tokens=25_000,        # reasoning + visible answer
    messages=[
        {"role": "developer", "content": "Answer with a unified diff only."},
        {"role": "user", "content": "Fix the off-by-one error in:\n<code>...</code>"},
    ],
)
print(r.usage.completion_tokens_details.reasoning_tokens)

# DeepSeek-R1: reasoning is returned as a separate field
ds = OpenAI(api_key="<DeepSeek API key>", base_url="https://api.deepseek.com")
r = ds.chat.completions.create(
    model="deepseek-reasoner",
    messages=[{"role": "user", "content": "Which is larger, 9.11 or 9.8?"}],
)
thinking, answer = r.choices[0].message.reasoning_content, r.choices[0].message.content
# Next turn: append only `answer` as the assistant message, never `thinking`

6. Distilled R1 models and open weights

DeepSeek did two things that matter for anyone who self-hosts:

• MIT license for the R1 code and weights, explicitly allowing commercial use and distillation. The distilled models also inherit the license of their base model (Apache 2.0 for Qwen 2.5, the Llama 3.x licenses for Llama).
• Six distilled dense models, fine-tuned on about 800K samples generated by R1:

Two findings from the paper are worth remembering. First, distilling a big reasoning model into a small one worked better than running large-scale RL on the small model directly: R1-Distill-Qwen-32B beat a Qwen-32B trained with R1-Zero-style RL on every reported benchmark. Second, the distills are specialists: they are tuned on reasoning traces, so do not expect them to beat a general instruct model of the same size at chat, tool calling or writing. The full R1 also lags DeepSeek-V3 on function calling, multi-turn, role-play and JSON output, by DeepSeek's own account.

Self-hosting caveats: the full 671B model needs a cluster, so most teams will use the API or a distill. Distills inherit R1's habits (long outputs, a <think> block, language mixing, few-shot sensitivity). Strip the <think> section before showing the answer, and keep it in logs for debugging. Expect latency in tens of seconds on hard prompts and set timeouts accordingly.

7. Decision table

Whatever you pick, evaluate on your own tasks: run the same set of real prompts through the current model and the candidate, compare quality, cost and latency, and only then switch.

Why this matters

• A second scaling lever. Quality now depends on how much a model thinks per request, not only on model size. Expect "how much reasoning?" to become a normal configuration choice, like temperature.
• Costs are less predictable. Hidden reasoning tokens can dominate the bill. Log reasoning token counts per request from day one.
• Open weights caught up fast. An MIT-licensed model matching o1 on key benchmarks, plus small distills you can run locally, changes the build-vs-buy math for reasoning-heavy features.
• Routing beats picking one model. Most systems will send most traffic to fast models and reserve reasoning models for the few hard steps.

Final Thoughts

Reasoning models are the most important change in how LLMs are used since instruction tuning. They are also easy to misuse: pointing o1 at a classification endpoint is like running a compiler optimization pass on a config file.

Treat them as a specialized tool. Use them where a human would need a scratchpad, give them goals and constraints instead of scripts, budget for the tokens you cannot see, and keep measuring. With R1's open weights and o3 already announced, the prices and the options will change quickly. The decision process above should not.

Sources

• OpenAI, Learning to Reason with LLMs (September 12, 2024): RL on chains of thought, train-time and test-time compute scaling, AIME results, reasons for hiding the chain of thought.
• OpenAI, OpenAI o1 and new tools for developers (December 17, 2024): o1 in the API for tier 5, function calling, Structured Outputs, developer messages, vision, reasoning_effort, 60% fewer reasoning tokens than o1-preview.
• OpenAI, API pricing (as of January 2025): o1, o1-mini and GPT-4o prices; output tokens include hidden reasoning tokens.
• OpenAI, Reasoning models guide: prompting advice (simple prompts, avoid chain-of-thought prompts, delimiters, limited RAG context), reasoning tokens, max_completion_tokens, 25,000-token reserve.
• DataCamp, OpenAI o1 API tutorial (September 2024): o1 API beta limitations and the 25,000-token recommendation.
• TechCrunch, OpenAI announces full o1 and $200 ChatGPT Pro (December 5, 2024).
• TechCrunch, OpenAI announces new o3 model (December 20, 2024): o3 announced, not released.
• Qwen Team, QwQ: Reflect Deeply on the Boundaries of the Unknown (November 28, 2024) and model card: 32B, Apache 2.0, known limitations.
• SiliconANGLE, Google's Gemini 2.0 Flash Thinking (December 19, 2024): Gemini 2.0 Flash Thinking Experimental release.
• DeepSeek, DeepSeek-R1 release notes (January 20, 2025): MIT license, six distilled models, API pricing.
• DeepSeek, Reasoning Model (deepseek-reasoner) guide (January 2025 version): reasoning_content, unsupported features and parameters, multi-turn rule.
• DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (January 22, 2025): R1-Zero, cold start, benchmark results, distillation vs. RL, few-shot degradation, limitations.
• DeepSeek, DeepSeek-R1 model card: 671B/37B MoE, distill base models and licenses, usage recommendations (temperature, no system prompt, \boxed{}).
• Bloomberg, Nvidia's $589 Billion DeepSeek Rout Is Largest in Market History (January 27, 2025).