Prompt Engineering for Reasoning Models: When to Use Them, How to Prompt, How to Save Tokens

The same prompt can land completely differently on a regular GPT model and a reasoning model -- not because of model capability, but because of a writing mismatch: classic prompt engineering teaches you to coach the steps, and reasoning models are exactly the ones that do not need coaching. Based on the official Reasoning Best Practices (verified 2026-09-01), this guide covers which tasks belong on reasoning models, the prompting rules, reasoning-token cost control, and the division of labor between reasoning.effort and the o-series in the GPT-5.6 era.

1. First, Know Who Is the Planner and Who Is the Workhorse

OpenAI's metaphor for the two model lines is blunt: the o-series are the planners -- trained to think longer and harder about complex tasks, effective at strategizing, planning solutions, and deciding under large volumes of ambiguous information, well suited to domains that would otherwise require a human expert (math, science, engineering, financial services, legal services). Lower-latency GPT models are the workhorses -- built for straightforward execution of well-defined tasks.

The most common production architecture mixes both: a reasoning model plans and decides, GPT models execute. The official selection criteria:

The GPT-5.6 era adds a twist: GPT models now have their own reasoning dial -- reasoning.effort, continuously adjustable from none to max. So today's decision order is: tune effort on GPT-5.6 first; move to the o-series only when that is not enough (the o-series runs effort fixed at max -- slow and expensive, reserved for must-be-right work). For tuning details, see our guide reasoning.effort in Practice: Making Reasoning Depth a Tunable Parameter.

2. Seven Tasks Worth Delegating to a Reasoning Model

Official patterns observed across customers and internal use -- use them as a checklist:

1. Ambiguous tasks: with incomplete or scattered information, reasoning models grasp intent from a simple prompt and fill gaps -- often asking clarifying questions before making uneducated guesses.
2. Needle in a haystack: when passing large amounts of unstructured information, they pull out only what matters -- the classic case is finding deal-affecting clauses buried in dozens of contracts.
3. Cross-document synthesis: reasoning over hundreds of pages of dense documents (legal contracts, financial statements, insurance claims), reaching conclusions not evident in any single document.
4. Multistep agentic planning: the reasoning model acts as the planner, producing a detailed multistep solution and assigning each step to the right GPT model based on whether high intelligence or low latency matters more.
5. Visual reasoning: interpreting hard visual inputs -- charts with ambiguous structure, photos with poor image quality.
6. Code review: reviewing and improving large amounts of code -- higher latency, but it runs in the background and reliably detects minor cross-file changes a human might miss.
7. Evaluating model outputs (LLM-as-judge): using a reasoning model to score other models' outputs and validate data, especially for fine-grained differences.

The negative list matters just as much: well-defined execution tasks (classification, formatting, rewriting, simple extraction) do not deserve a reasoning model -- slower, more expensive, zero benefit.

3. How to Prompt: Less Technique, More Constraints

The official best practices reduce to one sentence: reasoning models perform best with straightforward prompts. Expanded into six actionable rules:

1. Delete chain-of-thought instructions. "Think step by step" and "explain your reasoning" are unnecessary -- sometimes harmful. The model already does internally what you are coaching it to do.
2. Keep prompts short and direct. These models excel at understanding brief, clear instructions; technique stacking loses to a clearly stated requirement.
3. Use delimiters. Markdown, XML tags, and section titles split background material, tasks, and output requirements into clearly interpretable blocks.
4. Try zero-shot first. These models often do not need examples. If output requirements are complex, add a few examples -- strictly consistent with your instructions; discrepancies produce poor results.
5. State constraints explicitly. Hard constraints like "propose a solution with a budget under $500" belong in the prompt verbatim -- do not expect the model to guess boundaries.
6. Be very specific about the end goal. Describe what a successful response looks like and encourage the model to keep reasoning and iterating until it matches your criteria.

A side-by-side example -- the left is the regular-model habit, the right is the reasoning-model habit:

# Old habit (an anti-pattern for reasoning models)
Please think step by step: first list all possible locations of payment terms,
then explain your reasoning, and finally summarize...

# Reasoning-model habit
Summarize the payment terms in the contract below: amount, payment window, penalty interest.
Output a JSON array only; each item has amount / term_days / penalty_rate fields;
use null for any field that cannot be determined.

<contract>
{full contract text}
</contract>

Everything lives in rules 3, 5, and 6: delimiters around the source, hard output constraints, verifiable success criteria -- and not a single word about how to think.

4. Cost Control: the Reasoning-Items Mechanism

This is the most commonly missed line item in multi-turn tool loops. The official mechanism:

• Responses API: starting with the o3 / o4-mini generation, some reasoning items adjacent to function calls are included in the model's context. The official recommendation: set store to true and continue conversations with previous_response_id (or pass the previous output items in as new input) -- OpenAI automatically includes the relevant reasoning items and ignores the irrelevant ones. The model does not restart its reasoning after a function call, giving better function-calling performance and lower total token usage. For finer control, at least include all reasoning items between the latest function call and the previous user message.
• Chat Completions: a stateless API that never includes reasoning items. In complex agentic cases with many function calls this means slightly degraded performance and greater reasoning token usage; without complex multi-turn function calling, there is no difference between the APIs.

One-line takeaway: for multi-turn tool-calling agents, Responses API + store: true + previous_response_id is the officially recommended way to save.

from openai import OpenAI

client = OpenAI()
resp = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "high"},   # high effort for multistep tasks
    store=True,                     # official recommendation: persist for reasoning-item reuse
    input="Check stock for SKU-1234; if below 10 units, draft a restocking order",
)
print(resp.output_text)

# Next turn: continue with previous_response_id; reasoning items are reused
resp2 = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "high"},
    store=True,
    previous_response_id=resp.id,
    input="Change the restock quantity to 50 and regenerate",
)

The Node.js form is isomorphic (same-named reasoning: { effort } parameter):

import OpenAI from "openai";

const client = new OpenAI();
const res = await client.responses.create({
  model: "gpt-5.6-terra",
  reasoning: { effort: "high" },
  store: true,
  input: "Check whether the rollback steps in this runbook are complete",
});
console.log(res.output_text);

5. Common Mistakes and Troubleshooting

• Over-coaching the prompt: stacked steps, demanded explanations, piles of few-shot examples -- against a reasoning model these are likely liabilities. Subtract first.
• Using the o-series where effort would do: for everyday "think a bit harder" needs, GPT-5.6 with reasoning.effort is cheaper; the o-series is for must-be-right tasks.
• Stateless multi-turn tool loops: re-assembling history into input every turn without reasoning items makes the model restart reasoning each turn. Switch to the Responses API's previous_response_id pattern.
• Starved output budgets: high effort spends output tokens on internal reasoning; a tight budget returns incomplete responses -- raise the output cap or compress the output format. See reasoning.effort in Practice: Making Reasoning Depth a Tunable Parameter for incomplete-status handling.
• Assuming reasoning implies clarification: per the official description, reasoning models often ask clarifying questions before making uneducated guesses -- provided your prompt does not pretend the information is complete.

6. Next Steps

• Choosing an effort tier and doing the math: reasoning.effort in Practice: Making Reasoning Depth a Tunable Parameter.
• The full function-calling mechanics: Function Calling with the OpenAI API: A Complete Guide to Tool Use in the Responses API.
• Model selection (the full speed-vs-accuracy decision table): GPT-5.6 Model Selection Guide (2026): Sol, Terra, or Luna?.
• General prompting patterns (complementary to this article): Prompt Engineering Advanced: Multi-Turn Context, Structured Outputs, and GPT-5.6 Tuning.