Reasoning Models

1. What is the trade-off when using a reasoning model (o3, R1) vs a standard LLM for a simple factual question? (Answer: Reasoning models are slower and more expensive: they generate 500–2000 thinking tokens before the final answer. For a simple question like 'What is the capital of France?' this is wasteful — a standard model answers correctly in 5 tokens. Reasoning models are valuable for: multi-step math, complex coding, logical puzzles, scientific analysis. Deployment best practice: route simple queries to fast standard models, complex reasoning queries to reasoning models.)
2. What is 'extended thinking' in Claude 3.7 Sonnet and how does it differ from standard chain-of-thought prompting? (Answer: Standard CoT: the model generates visible reasoning steps as part of the response — the reasoning appears in the final output. Extended thinking: Claude generates internal reasoning tokens (marked as in the API) that are not shown to the user by default but inform the final answer. The thinking is genuinely internal computation — the model can explore dead ends, backtrack, and self-correct in ways that would look odd in a visible response.)
3. DeepSeek-R1 showed reasoning emerges from RL on math problems without supervision of reasoning steps. What is the key insight? (Answer: You do not need human demonstrations of reasoning chains (expensive to collect). You only need verifiable final answers (cheap: just check if the math answer is correct). GRPO training on correct/incorrect signals causes the model to spontaneously develop internal reasoning strategies to maximize the reward. The model discovers that longer, structured thinking leads to more correct answers — without ever being taught what 'reasoning' looks like.)
4. What is the accuracy-compute trade-off in reasoning models and how do you optimize it? (Answer: Reasoning models spend more compute (tokens) per question to achieve higher accuracy. The relationship is approximately log-linear: doubling thinking tokens gives diminishing accuracy improvements. Optimize by: (1) Setting a thinking budget (max tokens for reasoning). (2) Routing — use reasoning models only for high-stakes queries. (3) For production: measure accuracy vs compute per query type, find the Pareto-optimal point. OpenAI offers o1-mini for faster/cheaper reasoning than o1-full.)
5. Why do reasoning models sometimes 'overthink' simple problems? (Answer: Reasoning models are trained to think before answering — this becomes a strong prior even when unnecessary. For straightforward problems, the extended thinking may introduce errors by considering irrelevant alternative interpretations or second-guessing correct first answers. Studies show reasoning models sometimes perform WORSE than standard models on easy questions. This is an active alignment problem: teaching models to calibrate the amount of thinking to problem complexity.)

Claude Extended Thinking — configurable reasoning budget with visible thinking trace

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000   # how many tokens Claude can spend thinking
        # increase budget for harder problems; 1000–3000 is fine for most tasks
        # max: 32000 for claude-opus-4-6
    },
    messages=[{
        "role": "user",
        "content": (
            "Solve this competition math problem step by step, showing your work:

"
            "A sequence is defined by a(1)=1, a(2)=1, and a(n)=a(n-1)+a(n-2)+n for n>2. "
            "Find the units digit of a(2026)."
        )
    }]
)

# Separate the thinking trace from the final answer
for block in response.content:
    if block.type == "thinking":
        print(f"[THINKING — {len(block.thinking)} chars]")
        print(block.thinking[:500], "...
")   # first 500 chars of scratchpad
    elif block.type == "text":
        print("[ANSWER]")
        print(block.text)

# Practical tip: higher budget_tokens → better accuracy on hard problems
# but also higher latency and cost. Sweet spot for most math: 8000–12000.

OpenAI o3 and o3-mini — reasoning effort control

from openai import OpenAI

client = OpenAI()

# o3-mini: fast reasoning, lower cost — great for coding and math
response = client.chat.completions.create(
    model="o3-mini",
    reasoning_effort="high",    # "low" | "medium" | "high"
                                # high = best accuracy, slower + pricier
    messages=[
        {
            "role": "user",
            "content": "Write a Python function that checks if a number is prime using the Miller-Rabin test, then verify it on all primes up to 1000."
        }
    ]
)

print(response.choices[0].message.content)

# o3: maximum reasoning capability — for hardest problems
response_o3 = client.chat.completions.create(
    model="o3",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "Prove that there are infinitely many prime numbers using Euclid's method, then explain why the proof fails if we replace primes with perfect squares."}]
)

# Cost guide (approximate April 2026):
# o3-mini low:    $0.15/1M input,  $0.60/1M output  — fast, cheap
# o3-mini high:   $1.10/1M input,  $4.40/1M output  — best for coding
# o3 high:        $10/1M input,   $40/1M output     — hardest problems only
# DeepSeek-R1:    $0.55/1M input,  $2.19/1M output  — open-source competitive