Reasoning models and effort

Reading thinking in a response

A reply's content is a list of blocks. Each block is a dictionary with a type. Thinking comes back in thinking blocks. They arrive before the text block that holds the answer.

By default, the thinking text is left empty. The model did think, but you only get the answer. To see a readable summary of its reasoning, ask for one:

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

You never get the model's raw reasoning, only a summary. A summary is still useful. It helps you fix a prompt that goes wrong. It can also show users why an answer came out the way it did.

Here is a full request. It asks a budget question about two kinds of ads, at high effort:

import requests

response = requests.post(
    "https://api.anthropic.com/v1/messages",
    headers={"x-api-key": "added-by-the-academy-server", "anthropic-version": "2026-10-21"},
    json={
        "model": "claude-opus-5-5",
        "max_tokens": 4000,
        "thinking": {"type": "adaptive", "display": "summarized"},
        "output_config": {"effort": "high"},
        "messages": [{"role": "user", "content": "We have $5,000. Search returns $5.20 per $1, display $2.70. Split the budget?"}],
    },
    timeout=120,
)
data = response.json()
for block in data["content"]:
    if block["type"] == "thinking":
        print("THINKING SUMMARY:", block["thinking"][:120])
    elif block["type"] == "text":
        print("ANSWER:", block["text"][:120])
print("output tokens:", data["usage"]["output_tokens"])

The loop walks through the blocks one at a time. It checks each block's type. A thinking block prints the first 120 characters of the summary. A text block prints the first 120 characters of the answer. The last line prints how many output tokens the reply used. That count includes the thinking.

Thinking costs tokens

Thinking tokens are output tokens. You pay for them at the output price, even when you can't see the text. They also count toward max_tokens, the cap you set on how much the model may write. Two rules follow from that.

1. Leave room. Say max_tokens is tight. The model can spend it all on thinking and stop before it finishes the answer. The reply's stop_reason field, which says why the model stopped, will then be "max_tokens". For anything beyond a simple task, a max_tokens of several thousand is normal.
2. Check usage. usage["output_tokens"] includes the thinking. So it can be much larger than the answer you see. That's the number to use when you estimate cost.

You met the cost rule in the tokens lesson:

cost = tokens ÷ 1,000,000 × price per million

In plain words: work out what share of a million tokens you used. Then take that share of the price. For thinking, use the output price and the full output count.

Here it is with small numbers. Say output costs $20 per million tokens. A reply shows you a 200-token answer, but usage reports 2,000 output tokens. The other 1,800 were thinking. You pay for all 2,000: 2,000 ÷ 1,000,000 = 0.002, and 0.002 × $20 = $0.04. The visible answer alone would have been $0.004. So the thinking made this reply ten times as expensive.

INPUT_PRICE = 4.00    # dollars per million input tokens
OUTPUT_PRICE = 20.00  # dollars per million output tokens

def cost(usage):
    input_cost = usage["input_tokens"] / 1_000_000 * INPUT_PRICE
    output_cost = usage["output_tokens"] / 1_000_000 * OUTPUT_PRICE
    return input_cost + output_cost

low = {"input_tokens": 50, "output_tokens": 300}
high = {"input_tokens": 50, "output_tokens": 3000}

print(f"low effort:  ${cost(low):.4f} per request")
print(f"high effort: ${cost(high):.4f} per request")
print(f"10,000 requests: ${cost(low) * 10_000:,.2f} vs ${cost(high) * 10_000:,.2f}")

print(5000 / 1_000_000 * 20)

Keeping thinking blocks in conversations

In a conversation with several turns, you send the earlier messages back with each new request. The lesson on conversations and memory covers how. When you do, send the assistant's whole content list back. Include the thinking blocks, and don't change them.

This matters most once the model uses tools, which you'll meet soon. With its earlier thinking in front of it, the model picks up where it left off. Without it, the model starts its reasoning over.