Reasoning models

Reasoning models spend more computation on difficult problems before returning an answer. They are useful for math, logic, programming, planning, analysis, and tasks where a quick general-purpose response is not enough. They can be slower and more expensive than standard chat models, so use them when the task benefits from deeper reasoning.

When to use them

Task	Recommended model type
Translation, rewriting, short Q&A	Standard chat model
Math proof, logic puzzle, algorithm design	Reasoning model
Complex planning or architecture analysis	Reasoning model
High-volume simple classification	Standard or smaller model

Control reasoning effort

Some OpenAI-compatible reasoning models support reasoning_effort:

{
  "model": "gpt-5.4",
  "messages": [
    {"role": "user", "content": "Solve this logic puzzle step by step."}
  ],
  "reasoning_effort": "high"
}

Common values:

Value	Behavior	Use case
`low`	Faster, lower cost	Simple reasoning tasks
`medium`	Balanced	General reasoning tasks
`high`	More compute, slower, higher cost	Hard math, logic, or code tasks

Supported values depend on the selected model.

Reasoning content

Some providers expose a separate reasoning field, such as reasoning_content, while others return only the final answer. If the model exposes reasoning content, your application can display it, store it for debugging, or ignore it. Example response shape:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "reasoning_content": "I will compare the constraints and eliminate invalid options...",
        "content": "The correct answer is B."
      },
      "finish_reason": "stop"
    }
  ]
}

Field names and availability vary by model provider. For production systems, treat reasoning fields as optional.

Python example

Replace the entire sk-your-api-key value in API_KEY with your actual key. To use another reasoning model, change MODEL. Not every model returns reasoning_content, so the example reads it safely with getattr.

import httpx
from openai import OpenAI

API_KEY = "sk-your-api-key"
MODEL = "deepseek-v4-flash"

client = OpenAI(
    api_key=API_KEY,
    base_url="https://moxus.cloud/v1",
    # Connect directly to Moxus AI without reading system or terminal proxy variables.
    http_client=httpx.Client(trust_env=False, timeout=60.0),
)

response = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Prove the Pythagorean theorem."}],
)
message = response.choices[0].message

reasoning = getattr(message, "reasoning_content", None)
if reasoning:
    print("Reasoning:", reasoning)
print("Final answer:", message.content)

Node.js example

Replace the entire sk-your-api-key value in API_KEY with your actual key. To use another reasoning model, change MODEL. reasoning_content is an optional extension field, so the example checks whether it exists.

import OpenAI from "openai";

const API_KEY = "sk-your-api-key";
const MODEL = "deepseek-v4-flash";

const client = new OpenAI({
  apiKey: API_KEY,
  baseURL: "https://moxus.cloud/v1",
});

const response = await client.chat.completions.create({
  model: MODEL,
  messages: [{ role: "user", content: "Prove the Pythagorean theorem." }],
});

const message = response.choices[0].message;
if (message.reasoning_content) {
  console.log("Reasoning:", message.reasoning_content);
}
console.log("Final answer:", message.content);

Streaming reasoning output

In streaming mode, a provider may send reasoning deltas before final answer deltas. If you choose to display them, keep them visually separate from the final answer and make sure your parser handles missing fields.

Cost and latency

Reasoning tokens usually count toward output usage. A higher reasoning budget may improve quality on hard tasks, but it also increases latency and cost. Monitor usage in dashboard and usage.

Practical guidance

Start with a standard model for simple tasks.
Use reasoning models for hard tasks with measurable accuracy needs.
Keep prompts focused and provide the necessary facts up front.
Set reasoning controls only when the selected model supports them.
Validate final answers when they affect money, permissions, or user data.

Overview

Platform

Guides

Integrations

Reasoning models

When to use them

Control reasoning effort

Reasoning content

Python example

Node.js example

Streaming reasoning output

Cost and latency

Practical guidance

Next steps

​When to use them

​Control reasoning effort

​Reasoning content

​Python example

​Node.js example

​Streaming reasoning output

​Cost and latency

​Practical guidance

​Next steps

When to use them

Control reasoning effort

Reasoning content

Python example

Node.js example

Streaming reasoning output

Cost and latency

Practical guidance

Next steps