Reasoning

Overview

ASI:One models can reason before they answer. When reasoning is on, the model produces a train of thought first, then writes its actual reply. You get both back: the reasoning in reasoning_content, the answer in content.

Reasoning helps on problems with several steps, ambiguous requirements, or a chain of logic to follow. It costs extra tokens and adds latency, so it is something you ask for per request. Set enable_thinking explicitly on requests where it matters, rather than leaving it to a default. See Model support.

How you ask for reasoning depends on the endpoint:

• On /v1/chat/completions, use the ASI:One parameters enable_thinking and thinking_budget, described below.
• On /v1/responses, use OpenAI’s standard reasoning object. If you are already writing against the OpenAI Responses API, nothing changes.

Turning reasoning on

Set enable_thinking to true. It is a top-level field, supported on every ASI:One model.

$
curl -X POST https://api.asi1.ai/v1/chat/completions \
>
  -H "Authorization: Bearer $ASI_ONE_API_KEY" \
>
  -H "Content-Type: application/json" \
>
  -d '{
>
    "model": "asi1",
>
    "messages": [
>
      {"role": "user", "content": "A train leaves at 14:05 and arrives at 17:40, stopping twice for 12 minutes each. How long is it moving?"}
>
    ],
>
    "enable_thinking": true
>
  }'

The OpenAI SDK does not know about enable_thinking, so pass it through extra_body. With raw HTTP it is a normal top-level field.

Reading the reasoning

The reasoning arrives in a reasoning_content field alongside the usual content.

On a normal response it sits on the message:

1
{
2
  "choices": [
3
    {
4
      "message": {
5
        "role": "assistant",
6
        "reasoning_content": "Total elapsed is 3h35m. Two stops of 12 minutes each is 24 minutes...",
7
        "content": "The train is moving for 3 hours and 11 minutes."
8
      }
9
    }
10
  ]
11
}

When streaming, it arrives in the delta, generally before any content deltas:

data: {"choices":[{"delta":{"reasoning_content":"Total elapsed is 3h35m..."}}]}
data: {"choices":[{"delta":{"content":"The train is moving"}}]}

reasoning_content is null when reasoning is off. Treat it as display-only: it is there for transparency and debugging, and you should not parse it for structured values.

Limiting how much the model thinks

thinking_budget caps the tokens spent on reasoning. Pass a value up to 16384, or omit it to use the server-side default.

To stop the model reasoning, set enable_thinking to false. That is the switch for turning reasoning off; thinking_budget only sizes it.

1
{
2
  "model": "asi1",
3
  "messages": [{ "role": "user", "content": "..." }],
4
  "enable_thinking": true,
5
  "thinking_budget": 2048
6
}

A lower budget trims latency and cost but gives the model less room on hard problems. thinking_budget only takes effect on asi1; see Model support.

Reasoning on the Responses API

/v1/responses also takes OpenAI’s standard reasoning object, so a client already written against OpenAI’s API needs no changes to control reasoning here.

1
{
2
  "model": "asi1",
3
  "input": "A train leaves at 14:05 and arrives at 17:40...",
4
  "reasoning": { "effort": "medium" }
5
}

Each effort maps to a reasoning budget:

Any other value is rejected with a 400. That includes xhigh, which the OpenAI SDK accepts but which would exceed the maximum budget ASI:One allows.

If you omit reasoning entirely, or send it without an effort, the request falls back to enable_thinking and thinking_budget, so both styles work on this endpoint and you can migrate at your own pace.

On this endpoint the reasoning comes back as a reasoning output item rather than a reasoning_content field, with the text in that item’s content. It streams as response.reasoning_text.delta events, followed by response.reasoning_text.done.

effort maps onto the same budget mechanism as thinking_budget, so the same per-model support applies: on asi1 it sets the budget, and on asi1-ultra and asi1-mini it turns reasoning on or off.

Model support

Not every parameter applies to every model.

You can send the same request body to any of the three models without branching your code: enable_thinking works on all of them, and switching models never turns a request into an error. Only the budget controls differ, so tune thinking_budget on asi1 and rely on enable_thinking elsewhere.

Next steps

1. Responses API - Where OpenAI’s reasoning object applies, and how reasoning streams there
2. Chat Completions API - Where enable_thinking applies, and how reasoning streams there
3. Planner Mode - Break complex requests into steps executed against tools and agents
4. ASI:One Models - Which model to reach for