Dev Note

OpenAI o3 and Reasoning Models: A Developer’s Practical Guide
Reasoning models like OpenAI’s o3 and o4-mini have fundamentally changed what AI can do for developers. Unlike standard language models that respond instantly, reasoning models “think” before answering — spending extra compute on chain-of-thought deliberation to solve harder problems.
This guide explains what reasoning models are, when to use them, and how to integrate them into your applications effectively.
Photo by Steve Johnson on Unsplash
What Makes Reasoning Models Different?
Traditional LLMs (like GPT-4o) generate tokens left-to-right in a single forward pass. Reasoning models introduce an internal scratchpad — a hidden chain-of-thought — where the model works through the problem step by step before producing a final answer.
Key differences:
Feature
      Standard LLM (GPT-4o)
      Reasoning Model (o3)
    
Latency
      Fast (1-5s)
      Slower (10-60s+)
    
Thinking tokens
      None
      Up to 100k+
    
Best for
      Conversation, generation
      Logic, math, code
    
Cost
      Lower
      Higher
    
Context handling
      Standard
      Better at long-context reasoning
    
The o3 Model Family
OpenAI’s reasoning lineup as of 2026:
o4-mini — Fast, cheap reasoning. Great for coding tasks and straightforward logic
o3 — Full-power reasoning. Handles PhD-level math, complex multi-step code, and science
o3-pro — Maximum capability, highest cost. For the hardest problems
from openai import OpenAI
client = OpenAI()
# Basic reasoning model call
response = client.chat.completions.create(
    model="o3",
    messages=[
        {
            "role": "user",
            "content": "Implement a red-black tree with insertion, deletion, and rebalancing in Python."
        }
    ],
    reasoning_effort="high"  # low | medium | high
)
print(response.choices[0].message.content)
Reasoning Effort Levels
The reasoning_effort parameter is critical for balancing cost vs. quality:
# Low effort - faster, cheaper, good for simpler reasoning tasks
response = client.chat.completions.create(
    model="o4-mini",
    messages=[{"role": "user", "content": "Fix this SQL query: SELECT * from users WHERE id = '5'"}],
    reasoning_effort="low"
)
# High effort - slower, more expensive, better for hard problems
response = client.chat.completions.create(
    model="o3",
    messages=[{"role": "user", "content": "Prove that P ≠ NP or explain the strongest current evidence"}],
    reasoning_effort="high"
)
Think of it like asking a consultant to give a quick gut check vs. doing a full analysis.
When to Use Reasoning Models
✅ Use Reasoning Models For:
1. Complex code generation
prompt = """
Design a distributed rate limiter that:
- Works across multiple server instances
- Uses Redis for coordination
- Implements token bucket algorithm
- Handles Redis failures gracefully
- Is thread-safe and performant
Provide the full implementation with tests.
"""
2. Debugging hard problems
prompt = """
This code has a subtle concurrency bug that causes data corruption
under high load. Find the bug and fix it:
[paste 200 lines of async Python]
"""
3. Architecture decisions
prompt = """
We have a microservices system with 50 services. We're experiencing
cascading failures. Analyze these architecture diagrams and logs,
identify the root causes, and propose a resilience strategy.
"""
4. Math and algorithms
Competitive programming problems
Numerical optimization
Proof checking
❌ Don’t Use Reasoning Models For:
Simple Q&A or conversation
Text summarization
Translation
Basic CRUD code
Tasks where latency matters more than accuracy
Streaming Reasoning Responses
For better UX, stream the response while reasoning happens in the background:
import openai
client = openai.OpenAI()
with client.chat.completions.stream(
    model="o3",
    messages=[{"role": "user", "content": "Solve this optimization problem..."}],
    reasoning_effort="high"
) as stream:
    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
Accessing the Reasoning Summary
With certain API tiers, you can request a summary of the model’s reasoning:
response = client.chat.completions.create(
    model="o3",
    messages=[{"role": "user", "content": "Debug this code..."}],
    reasoning_effort="high",
    include=["reasoning.summary"]  # Request reasoning summary
)
# Access the reasoning summary
if hasattr(response.choices[0].message, 'reasoning'):
    print("REASONING:", response.choices[0].message.reasoning.summary)
    
print("ANSWER:", response.choices[0].message.content)
This is invaluable for debugging why the model reached a particular conclusion.
Cost Optimization Strategies
Reasoning models are expensive. Here’s how to use them wisely:
1. Cascade Model Selection
def smart_completion(prompt: str, task_complexity: str) -> str:
    """Route to appropriate model based on complexity."""
    
    if task_complexity == "simple":
        model, effort = "gpt-4o-mini", None
    elif task_complexity == "medium":
        model, effort = "o4-mini", "low"
    else:
        model, effort = "o3", "high"
    
    kwargs = {"model": model, "messages": [{"role": "user", "content": prompt}]}
    if effort:
        kwargs["reasoning_effort"] = effort
    
    return client.chat.completions.create(**kwargs).choices[0].message.content
2. Prompt Compression
Reasoning models are good at handling dense, compressed prompts. Unlike chat models, you don’t need to be as verbose:
# Verbose (unnecessary for reasoning models)
bad_prompt = """
Please carefully read the following code and then, step by step, 
identify any potential bugs or issues. After identifying them, 
please suggest fixes...
"""
# Compressed (reasoning model handles the rest)
good_prompt = "Find bugs and suggest fixes:\n\n```python\n[code]\n```"
3. Caching Common Reasoning Patterns
import hashlib
import json
from functools import lru_cache
reasoning_cache = {}
def cached_reasoning(prompt: str, model: str = "o3") -> str:
    cache_key = hashlib.sha256(f"{model}:{prompt}".encode()).hexdigest()
    
    if cache_key in reasoning_cache:
        return reasoning_cache[cache_key]
    
    result = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        reasoning_effort="high"
    ).choices[0].message.content
    
    reasoning_cache[cache_key] = result
    return result
Building a Code Review Agent with o3
Here’s a practical example — an automated code reviewer:
import openai
from pathlib import Path
client = openai.OpenAI()
def review_pull_request(diff: str, context: str = "") -> dict:
    """
    Use o3 to do a thorough code review of a git diff.
    Returns structured feedback.
    """
    
    system_prompt = """You are an expert code reviewer. Analyze the diff and provide:
1. Critical bugs (security, correctness, crashes)
2. Performance issues  
3. Code quality concerns
4. Positive highlights
Format as JSON: {"critical": [], "performance": [], "quality": [], "positives": []}"""
    response = client.chat.completions.create(
        model="o3",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": f"Context: {context}\n\nDiff:\n```\n{diff}\n```"}
        ],
        reasoning_effort="medium",
        response_format={"type": "json_object"}
    )
    
    return json.loads(response.choices[0].message.content)
# Example usage
diff = Path("feature.diff").read_text()
review = review_pull_request(diff, context="Auth service, security-critical code")
for issue in review["critical"]:
    print(f"🚨 CRITICAL: {issue}")
    
for issue in review["performance"]:
    print(f"⚠️ PERF: {issue}")
Reasoning Models in Agentic Workflows
Reasoning models shine as the “brain” in multi-step agentic systems:
from openai import OpenAI
client = OpenAI()
def agentic_problem_solver(problem: str, tools: list) -> str:
    """
    Use o3 for planning, cheaper models for execution.
    """
    
    # Step 1: Use o3 to create an execution plan
    plan_response = client.chat.completions.create(
        model="o3",
        messages=[
            {
                "role": "user",
                "content": f"""Given this problem: {problem}
                
Available tools: {[t['name'] for t in tools]}
Create a step-by-step execution plan. Be specific about which tool to use at each step and what inputs to provide."""
            }
        ],
        reasoning_effort="high"
    )
    
    plan = plan_response.choices[0].message.content
    
    # Step 2: Execute the plan with cheaper models
    execution_response = client.chat.completions.create(
        model="gpt-4o",  # Cheaper for execution
        messages=[
            {"role": "system", "content": "Execute this plan step by step using the available tools."},
            {"role": "user", "content": plan}
        ],
        tools=tools
    )
    
    return execution_response.choices[0].message.content
Photo by Luca Bravo on Unsplash
Benchmarks: Where o3 Excels
Benchmark
      GPT-4o
      o4-mini
      o3
    
HumanEval (coding)
      90.2%
      93.1%
      97.4%
    
MATH
      74.6%
      88.9%
      96.7%
    
MMLU
      88.7%
      90.1%
      92.3%
    
SWE-bench (real issues)
      45.2%
      61.3%
      71.8%
    
o3 is particularly strong at SWE-bench — solving real GitHub issues — making it exceptionally valuable for engineering workflows.
Key Takeaways
Match the model to the task — Don’t use o3 for simple queries; use it for genuinely hard reasoning problems
Leverage reasoning effort levels — low for quick tasks, high only when accuracy is critical
Stream for better UX — Reasoning takes time; streaming improves perceived responsiveness
Build cascading systems — Use cheap models for simple steps, reasoning models for complex decisions
Cache when possible — Reasoning is expensive; cache results for repeated queries
Reasoning models are a step-change in AI capability. Used wisely, they can solve problems that were previously intractable for AI systems — but they’re a tool, not a replacement for thoughtful engineering.
References:
OpenAI o3 System Card
OpenAI API Reasoning Guide
o3 vs o4-mini Comparison

OpenAI o3 and Reasoning Models: A Developer's Practical Guide

댓글