Reasoning

Reasoning allows language models to perform deeper, structured thinking before producing a final answer. How this reasoning is exposed or whether it appears at all depends entirely on the model provider.

Some models reveal part of their thinking process, while others keep it hidden but still use it internally.

What Is Reasoning?

Reasoning refers to the model’s deeper analytical process: evaluating options, forming intermediate steps, and then producing a final answer.

Note: Depending on the model provider, this reasoning may appear in various formats:

• mixed into the normal content

• in a dedicated reasoning_content field

• inside structured thinking_blocks (only returned for Anthropic models)

Other models keep their chain-of-thought hidden but still support configurable reasoning behavior.

Controlling Reasoning

To provide a consistent experience across providers that support it, Cortecs accepts:

"reasoning_effort": "low" | "medium" | "high"

This parameter represents how much reasoning effort you want the model to use.

• If the provider supports configurable reasoning, Cortecs translates the value appropriately.

• If the provider does not support adjustable reasoning, the parameter is simply ignored.

• If the provider uses reasoning by default, the parameter may still help increase or reduce thinking depth.

When to choose which level?

• Use low if you want fast responses, low cost, or the task is simple.

• Use medium for general use: coding, explanations, multi-step tasks.

• Use high for reasoning-intensive tasks: debugging, strategy, multi-constraint planning, mathematical reasoning, or anything requiring precision.

Provider Behavior

Different model families use different mechanisms for reasoning. Below is how Cortecs handles reasoning_effort for each provider.

Anthropic

Model support: Support for adaptive and extended thinking depends on the Anthropic model. Some newer models support adaptive thinking only and reject thinking.type: "enabled". See Anthropic’s supported-model configuration table before choosing a mode.

Adaptive Thinking

Anthropic models that support adaptive thinking (for example, Claude Opus 5) can dynamically decide how much reasoning to use. If adaptive thinking is not enabled by default for a model, enable it by passing a thinking parameter:

extra_body={
    "thinking": {"type": "adaptive"}
}

You can control the effort level with Anthropic's output_config.effort parameter:

extra_body={
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "high"}
}

Alternatively, use the standard reasoning_effort parameter. Cortecs maps it to output_config.effort for supported Anthropic models.

For models that allow thinking to be turned off, disable it with:

extra_body={
    "thinking": {"type": "disabled"}
}

To configure whether reasoning content is included in the response, set thinking.display to "summarized" or "omitted":

extra_body={
    "thinking": {
        "type": "adaptive",
        "display": "summarized"
    }
}

Use "summarized" to return summarized reasoning content or "omitted" to hide it. For newer adaptive-thinking models such as Claude Opus 5, the default is "omitted".

Extended Thinking

Anthropic models that support extended thinking use budget_tokens to set a fixed reasoning budget. Enable it by setting thinking.type to "enabled":

extra_body={
    "thinking": {
        "type": "enabled",
        "budget_tokens": 1024
    }
}

For these models, Cortecs can convert the user’s reasoning_effort input into the appropriate reasoning budget:

Effort	Budget
low	1024
medium	2048
high	4096

Azure OpenAI

Azure OpenAI follows the same general behavior as OpenAI:

• Azure OpenAI does not expose raw reasoning tokens, so the internal chain of thought is never shown.

• For newer reasoning-capable models (such as GPT-5), you can still use reasoning_effort to control the depth of reasoning; older ones ignore it.

Google Gemini (2.5 and later)

• Reasoning is enabled by default.

• Provided efforts are converted into a reasoning budget similar to Anthropic.

Custom Budget (Gemini)

Users may specify a custom numeric budget similar to Anthropic.

Mistral Models

• Some models support reasoning_effort (e.g., Magistral, mistral-small), while others ignore it.

• When supported, it enables internal reasoning and may return reasoning_content.

AKI Models

• reasoning_effort is not supported by all models. When supported, accepted values are none, low, medium, and high Otherwise, the parameter is ignored.

Tensorix Models

• Reasoning capabilities differ per model family.

• Cortecs accepts the standard reasoning_effort parameter and automatically maps it to Tensorix’s format.

• Some model families (e.g., Kimi) always use reasoning and do not support configurable reasoning effort. Others (e.g., DeepSeek) have reasoning disabled by default and require reasoning_effort to be provided to enable it.

Reasoning behavior varies across models, and not all reasoning steps may be visible in the response. Using reasoning_effort lets you request deeper or lighter reasoning when supported, while Cortecs automatically handles internal budgets where applicable. Keep in mind that some models expose reasoning explicitly, others hide it, and some include it by default.

Reasoning token counts are currently included in the completion token count.