GPT-5.5 Responses API Reasoning and Multi-turn State Configuration

One-sentence takeaway

GPT-5.5 should preferably be used with the Responses API, starting with medium reasoning effort; multi-turn tool agents should preserve reasoning items between response states and tool calls to avoid breaking the context.

Use cases

• Suitable tasks: Coding agents, complex data analysis, research, and multi-turn workflows that require consecutive tool calls.

• Unsuitable tasks: Simple retrieval or classification that requires no planning; evaluate low first, and evaluate none when latency is extremely sensitive.

• Applicable model version: GPT-5.5; the page also describes other reasoning models, but tables and defaults should follow the GPT-5.5 model page.

• Applicable client, agent, or API: OpenAI Responses API, Python SDK; Chat Completions remains available, but the official recommendation is Responses.

• Recommended reasoning level and parameters: Start with reasoning={"effort":"medium"}; compare high for complex debugging and deep planning; do not unconditionally use the highest level just because a task is complex. Reserve sufficient max_output_tokens for reasoning tokens and visible output.

Ready-to-use content

Basic call template (the official example rewritten with GPT-5.5's medium configuration):

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.5",
    reasoning={"effort": "medium"},
    input=[{
        "role": "user",
        "content": "Inspect this repository, identify the likely bug, and return evidence plus a safe patch plan.",
    }],
)

print(response.output_text)

Minimal state template for two consecutive calls:

first = client.responses.create(
    model="gpt-5.5",
    reasoning={"effort": "medium"},
    input="Inspect this repository and identify the likely bug.",
)

second = client.responses.create(
    model="gpt-5.5",
    previous_response_id=first.id,
    input="Now patch the bug and explain the change.",
    reasoning={"effort": "medium"},
)

print(second.output_text)

Testing/workflow steps

1. Confirm GPT-5.5's context, maximum output, and supported effort levels on the model page; do not directly copy parameters from other GPT-5 versions.

2. Send the task through the Responses API, use medium as the baseline, and record usage.output_tokens_details.reasoning_tokens in the response, total tokens, latency, and whether the response is incomplete.

3. When tools are involved, pass back the previous response's reasoning items, function call items, and function call output items together; when using previous_response_id, the API preserves the state.

4. When using store=false or a non-persistent mode, retain every output item (including encrypted reasoning content), replay them in full, and then append the next user message.

5. Check the response status; if it is incomplete because of max_output_tokens, increase the limit or shorten the input. Do not treat an answer with no visible response as a success.

Original evidence and data

• The official documentation lists medium as GPT-5.5's default reasoning effort and explains that the available levels vary by model.

• The official recommendation is to reserve at least 25,000 tokens for reasoning and visible output when beginning experiments; actual usage can range from hundreds to tens of thousands, so rely on the response's usage data.

• For multi-turn function calls, the official recommendation is to pass back the reasoning items, function call items, and tool output items that followed the previous function call.

• Reasoning tokens are not included in the visible answer, but they occupy context and are billed as output tokens; max_output_tokens limits reasoning, visible output, and format tokens together.

Scope and limitations

• This article records only official API configuration rules and does not represent a quality improvement for any particular business task; compare effort levels on representative evals.

• “Preserving reasoning items” is a state-continuity requirement, not exposure of the model's original chain of thought; the reasoning content returned by the API remains unreadable directly.

• The page also includes parameter guidance for other new model families; GPT-5.5's effort, context window, pricing, and snapshot must be based on the GPT-5.5 model page.

• 25,000 tokens is the official starting recommendation, not a fixed amount that every request must consume; adjust it according to cost and latency budgets.

Source excerpt or observation (for compliant short quotation only)

The official documentation recommends that “Reasoning models work better with the Responses API” and notes that reasoning tokens “still occupy space in the model’s context window”.