Visible Reasoning: Concept and 2026 Lineup

Updated November 3, 2026 based on the Models page and Reasoning guide from xAI: grok-4.6 and grok-4.7 complete the high-end lineup, with the xhigh effort setting. Sources: Models · Reasoning.

What Is Visible Reasoning?

A reasoning model produces an internal chain of thought before formulating its final answer: it breaks down the problem, explores avenues, and verifies its steps. Some models expose this reasoning in the API response, while others keep it internal. Understanding this distinction is the starting point for this entire course.

Historically at xAI, grok-3-mini (previous generation, removed from the catalog in 2026) popularized visible reasoning: its reasoning_content field contained the complete thought process, in plain text, directly readable. This transparency made it a remarkable teaching tool and a preferred choice for prompt debugging.

In July 2026, the lineup changed. Reasoning now works with two families of models:

• grok-4.20-0309-reasoning: the variant explicitly dedicated to reasoning, with 1 million context tokens.
• grok-4.7, grok-4.6, and grok-4.5: the high-end models (September, August, and July 2026), whose reasoning is adjustable—you tune the reasoning effort based on the task, up to xhigh on 4.6 and 4.7; grok-4.7 is the model xAI recommends.

Adjustable Reasoning Effort

The principle of adjustable reasoning effort is simple: the higher the effort, the more reasoning tokens the model consumes before answering, and the more reliable the response on complex problems.

• Low effort: the model thinks briefly. Suitable for simple questions where you want a structured answer without consuming too many tokens.
• High effort: the model develops deep reasoning. Suitable for logic problems, multi-step calculations, or complex code analysis.

On the previous generation, this setting used the reasoning_effort parameter (low / high) on grok-3-mini:

{
  "model": "grok-4.20-0309-reasoning",
  "reasoning_effort": "high",
  "messages": [
    {
      "role": "user",
      "content": "Prove that the square root of 2 is irrational."
    }
  ]
}

On grok-4.5, reasoning is configurable natively: it is even one of the model’s central arguments. The exact name and values of the parameter evolve with the API—check the official Models page (docs.x.ai) for the current syntax before writing your code.

Reasoning Traces in the Response

On the previous generation, grok-3-mini returned a reasoning_content field in the message object, containing the complete reasoning in plain text:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "The square root of 2 is irrational...",
        "reasoning_content": "I will use a proof by contradiction. Assume that √2 = p/q where p and q are coprime integers..."
      }
    }
  ]
}

Important caution: on the 2026 lineup (grok-4.5, grok-4.20-0309-reasoning), the official documentation does not guarantee that reasoning traces are exposed in plain text in the same way. Before building an interface that displays the model’s reasoning, test the response object returned by the model you are targeting and consult the official Models page. Never assume the behavior of the previous generation is preserved.

What This Means for You

The distinction to remember:

• Exposed reasoning: you can display the thought process, debug it, teach with it. Verify this model by model on the current lineup.
• Internal reasoning: the model thinks, but you receive only the final answer (and potentially an encrypted reusable content—see the next lesson).

If your application needs to show how the model reasons (tutor, educational tool, audit), validate this point first when choosing the model. If only the quality of the final answer matters, grok-4.5 with adapted effort is the natural choice.

Use Cases for Adjustable Reasoning

• Prompt debugging: high effort on grok-4.20-0309-reasoning reveals whether the model interprets your instructions correctly
• Teaching: break down mathematical or logical reasoning step by step
• Validation: verify the reasoning path on a sample before going to production
• Prototyping: test a reasoning chain with low effort before scaling up

Key Takeaways

• A reasoning model thinks before answering; some expose this reasoning, others do not
• grok-3-mini (previous generation, off catalog) exposed its reasoning in plain text via reasoning_content
• In 2026, reasoning works with grok-4.20-0309-reasoning (dedicated variant, 1M context) and grok-4.5 (configurable reasoning, 500k context)
• Exposure of traces on the current lineup is not guaranteed: test the API response and consult the official Models page
• Choose reasoning effort based on task complexity, not by default at maximum