25 ChatGPT-5.5 Prompts to Benchmark Reasoning Effort for Research, Coding, and Agent Workflows

Benchmark GPT-5.5 Reasoning Effort Before You Route Real Work

GPT-5.5 is documented by OpenAI as an official flagship API model for complex professional work, and its API model ID is gpt-5.5. In the official GPT-5.5 model documentation, OpenAI lists text and image inputs with text output, a 1,050,000-token context window, and a 128,000 maximum output-token budget. Those numbers make GPT-5.5 relevant for long research packets, large codebase excerpts, multi-document analysis, and agent planning, but they do not remove the need to measure latency, cost, output completeness, and task-specific reliability before changing production routing.

This prompt masterclass treats GPT-5.5 as an API model, not as a generic label for whatever a user sees in the ChatGPT model picker. OpenAI’s API reasoning controls use a parameterized reasoning.effort setting, while the ChatGPT UI exposes model and thinking choices through the product interface according to plan, workspace, allowance, and safety-routing behavior. A natural-language instruction such as “think harder” should not be treated as equivalent to changing the selected ChatGPT thinking level, and a ChatGPT UI selection should not be assumed to map one-to-one to an API reasoning.effort value.

For API evaluations, the documented GPT-5.5 model ID to use is gpt-5.5. No official gpt-5.5-mini model ID is documented on OpenAI’s GPT-5.5 model page, so benchmark plans, code samples, dashboards, and procurement notes should not invent or reference that model name. If your team needs to compare GPT-5.5 against smaller or cheaper alternatives, list only model IDs that are actually documented in the OpenAI API documentation available to your organization at the time of testing.

OpenAI documents GPT-5.5 reasoning efforts as none, low, medium, high, and xhigh, with medium as the default. The reasoning guide characterizes low as a speed-and-cost-oriented starting point for workflows such as planning, search, data analysis, drafting, execution-oriented coding, and customer-support tasks. It describes medium as the balanced default for quality and reliability, high as suitable for difficult debugging, planning, and long-horizon work, and xhigh as something to use only when evaluations justify the additional latency and cost.

The most important cost rule for this article is that reasoning tokens are billed as output tokens. Under the GPT-5.5 pricing documented by OpenAI, standard text pricing is $5 per million input tokens, $0.50 per million cached input tokens, and $30 per million output tokens. Because reasoning tokens count as output tokens, a higher reasoning effort can increase output-token spend even when the visible answer is short. Prompts over 272K input tokens receive the documented long-context multiplier for the full session, and regional processing adds the documented uplift, so long-context evaluations need their own cost line rather than being mixed into ordinary short-prompt averages.

Reasoning effort also affects output-budget risk. OpenAI’s reasoning guide states that reasoning tokens can consume the response budget before visible output appears. In practice, this means an evaluation can fail in two different ways: the model can produce a wrong visible answer, or it can spend enough budget on hidden reasoning that the visible answer is truncated, missing required sections, or incomplete. A fair benchmark must record both failure modes instead of scoring only the final text that appears in the response.

Reasoning state and visible conversation state are separate. OpenAI documents that earlier GPT families such as GPT-5.5 default to current-turn reasoning context, that reasoning reuse does not cross model families, and that persisted reasoning does not expose raw reasoning text. For benchmark design, that means you should evaluate observable artifacts: the answer, citations or evidence handling when requested, tool-call plan if applicable, structured output validity, latency, token usage, and reviewer judgment. Do not build an evaluation method that depends on reading hidden chain-of-thought or comparing private reasoning traces.

This developer guide is a 35-page technical playbook covering GPT-5.1 through GPT-5.5 with production backend code patterns, cost math, named tools, and API implementation guidance. The complete GPT-5 & GPT-5.5 API Developer Guide 2026 (Free PDF) article provides the destination-specific detail for this section’s GPT-5.5 API Guide decision because it is the most direct match for a marker pointing readers from GPT-5.5 benchmarking prompts to practical GPT-5.5 API implementation details.

The Evaluation Contract Used by All 25 Prompts

The 25 prompt templates that follow are not designed to crown one effort level as universally best. They are designed to help teams produce reproducible evaluation artifacts for specific workloads: research synthesis, coding, data analysis, customer support, tool-use planning, long-context review, regression testing, and agent workflow design. A useful benchmark compares effort levels against the same task inputs, the same scoring rubric, the same execution environment, and the same human-review standard.

Use the following evaluation contract before running any of the prompt templates. The contract is deliberately strict because small changes in instructions, context order, allowed tools, or acceptance criteria can make results incomparable. If one run includes a hidden hint, a different document set, a larger output budget, or a more permissive tool policy, treat it as a separate experiment rather than another row in the same benchmark.

Contract element	Required decision	Operational reason
Fixed inputs	Freeze the prompt, source documents, code files, schemas, tool permissions, and expected deliverable format for every effort level.	Changing the task while changing effort makes it impossible to attribute differences to reasoning.effort.
Repeated runs	Run each effort level multiple times under the same conditions and record each run separately.	Single-run comparisons can confuse ordinary response variance with a durable quality difference.
Task metrics	Define measurable acceptance criteria such as factual accuracy, compile success, schema validity, defect discovery, citation discipline, or escalation quality.	A model that writes polished prose can still fail the operational task if it misses required facts or produces invalid output.
Latency	Record end-to-end response time using the same client path and workload conditions.	Higher effort can improve difficult-task outcomes but may be unsuitable for interactive support or user-facing agents.
Token cost	Capture input tokens, cached input tokens where applicable, visible output tokens, reasoning tokens when reported by the API response, and total billed output tokens.	Reasoning tokens are billed as output tokens, so visible answer length alone understates cost exposure.
Error taxonomy	Classify failures with stable labels such as hallucinated fact, unsupported citation, incomplete output, invalid JSON, unsafe action plan, missed edge case, or reviewer rejection.	Error labels let teams see whether higher effort reduces the failures that actually matter for the workflow.
Human review	Require an accountable reviewer to approve any production routing, support-policy, code-generation, or agent-autonomy change.	Benchmark artifacts support decisions; they do not replace engineering, legal, security, privacy, medical, or domain review.

This article explains the GPT-5.1 reasoning_effort parameter, including its discrete levels and how teams tune reasoning-token use to balance cost and output quality. The complete Why Reasoning Effort Matters: Tuning GPT-5.1 reasoning_effort for Cost vs Quality article provides the destination-specific detail for this section’s Reasoning Effort Explained decision because the current article benchmarks reasoning effort, so a dedicated explanation of reasoning_effort and its cost-quality tradeoff is semantically precise.

A Minimal Runner Specification for Reproducible Tests

A practical GPT-5.5 effort benchmark should run the same task against none, low, medium, high, and xhigh unless a workload has an explicit reason to exclude one level. For example, a latency-sensitive support draft may exclude xhigh after an initial pilot if the cost and response time are clearly outside the product’s service target, but that exclusion should be documented rather than silently omitted. The default medium run should remain in the table because it is OpenAI’s documented default and functions as a baseline for many teams.

{
  "model": "gpt-5.5",
  "reasoning": {
    "effort": "medium"
  },
  "benchmark_contract": {
    "fixed_inputs": true,
    "repeated_runs_per_effort": 3,
    "record_latency": true,
    "record_token_usage": true,
    "record_error_taxonomy": true,
    "require_human_review_before_routing_change": true
  }
}

The JSON above is a proposed benchmark-record shape, not a claim that every field is an OpenAI API request field. Use it as an internal evaluation manifest: the API request should follow the current OpenAI documentation, while the benchmark metadata should capture the decisions your team needs for governance, reproducibility, and audit review. Keep raw prompts, frozen inputs, outputs, reviewer notes, and cost records together so later regressions can be compared against the original evidence.

For research tasks, prioritize factual precision, evidence separation, uncertainty labeling, and completeness against the supplied source set. For coding tasks, prioritize reproducible build or test results, defect localization, patch minimality, and reviewer acceptance. For agent workflows, prioritize safe plan construction, correct tool boundaries, escalation decisions, incomplete-output handling, and whether the model asks for missing information instead of inventing it. These workload-specific metrics matter more than a generic “best answer” score.

The safest decision rule is conservative: route production traffic to a higher effort only when repeated runs show a meaningful task-specific improvement that justifies added latency and output-token cost, and route to a lower effort only when repeated runs preserve the acceptance criteria that matter. If results are mixed, keep medium as the baseline, narrow the task category, add reviewer annotations, and rerun the benchmark with better fixtures before changing customer-facing or agentic behavior.

Prompts 1–9: Build the Reasoning-Effort Benchmark Before Comparing Outputs

These first nine prompts establish the evaluation harness: what to test, how to sample tasks, how to score outputs, and how to compare adjacent GPT-5.5 API reasoning efforts without turning a single anecdote into a routing policy. OpenAI documents GPT-5.5 reasoning efforts as none, low, medium, high, and xhigh, with medium as the default; the practical question is not which level is “best,” but which level is justified for a specific workload under quality, latency, output-budget, and cost constraints.

This 30-day AI feature launch playbook embeds model selection, evals-as-CI, guardrails, and a launch checklist, giving teams a practical evaluation framework for turning the masterclass prompts into repeatable routing evidence. The complete Ship Your First AI Feature in 30 Days: Startup Playbook article provides the destination-specific detail for this section’s Model Evaluation Framework decision because the target directly discusses operational evaluation and evals-as-CI, making it stronger than a domain-specific prompt collection.

Prompt 1: Benchmark design brief for reasoning effort

Purpose

This prompt creates the benchmark plan before any model calls are compared. It forces the evaluator to define the workload, effort levels, acceptance criteria, measurement fields, and decision boundary so that later results do not become a subjective preference contest.

Copy-paste prompt

You are designing a GPT-5.5 API reasoning-effort benchmark.

Use only these fixed test inputs:
[TASK_SET]
[USER_PERSONAS]
[KNOWN_CONSTRAINTS]
[PRODUCTION_RISK_LEVEL]
[AVAILABLE_EFFORT_LEVELS: none, low, medium, high, xhigh]

Produce a benchmark design brief that includes:
1. Explicit assumptions and exclusions.
2. The task categories represented by the fixed test inputs.
3. Which reasoning.effort levels will be tested and why.
4. Evidence-versus-uncertainty separation for every design choice.
5. Acceptance criteria for quality, reliability, refusal behavior, formatting, and completeness.
6. Required recording fields for token use, reasoning-token impact on output budget, latency, retries, incomplete responses, and estimated cost.
7. A rule that no production routing change may occur without human review of raw cases, scores, failures, and cost/latency tradeoffs.

Do not rank effort levels in advance. Do not assume one level is universally best.

Required inputs

• A stable task set that will not change mid-test.
• User personas or workflow roles, such as researcher, support analyst, developer, or agent operator.
• Operational constraints, including latency ceiling, cost tolerance, and unacceptable failure modes.

Expected output

The output should be a concise benchmark charter with test scope, fields to log, comparison rules, and a sign-off requirement. It should also state that reasoning tokens are billed as output tokens and may reduce the visible output budget before the answer appears.

Verification checkpoint

Reject the brief if it omits any effort level under consideration, lacks measurable acceptance criteria, fails to log token and latency data, or suggests changing production routing without human review.

Prompt 2: Representative task sampling plan

Purpose

This prompt turns a broad workload into a representative sample. It is useful when teams have hundreds of candidate tasks but need a manageable benchmark that still includes easy, typical, ambiguous, long-context, and high-risk cases.

Copy-paste prompt

You are constructing a representative GPT-5.5 reasoning-effort test sample.

Use only these fixed candidate inputs:
[CANDIDATE_TASKS]
[TASK_METADATA]
[KNOWN_PRODUCTION_FREQUENCIES]
[KNOWN_RISK_TAGS]

Create a sampling plan with:
1. Explicit assumptions about representativeness and missing data.
2. A stratified sample across task type, difficulty, length, ambiguity, risk, and expected tool or agent use.
3. Evidence-versus-uncertainty separation for inclusion and exclusion decisions.
4. Acceptance criteria for the sample: minimum cases per stratum, required edge cases, and excluded out-of-scope tasks.
5. A logging schema for reasoning.effort, input tokens, cached-input tokens if applicable, output tokens, possible reasoning-token budget pressure, latency, retries, incomplete responses, and estimated cost.
6. A human-review gate before any production routing changes are made from the sample results.

Keep test inputs fixed once the benchmark starts. Do not replace failed cases with easier cases.

Required inputs

• Candidate tasks with metadata such as domain, input length, expected answer type, and severity of errors.
• Production frequency estimates or a clear note that frequency is unknown.
• Risk tags for privacy, safety, customer impact, financial impact, or code-change impact.

Expected output

The output should be a sample matrix that explains why each case is included. It should preserve low-frequency but high-impact cases instead of optimizing only for the most common queries.

Verification checkpoint

Reject the plan if it samples only convenient tasks, removes hard cases after failure, or lacks enough repeated examples to compare none, low, medium, high, and xhigh fairly.

Prompt 3: Task-specific scoring rubric

Purpose

This prompt creates a scoring rubric before outputs are inspected. The goal is to prevent reviewers from rewarding verbosity, style, or apparent confidence when the actual requirement is correctness, completeness, safety, or faithful use of provided evidence.

Copy-paste prompt

You are writing a scoring rubric for a GPT-5.5 reasoning-effort benchmark.

Use only these fixed test inputs and expected task goals:
[TEST_CASES]
[REFERENCE_MATERIAL]
[EXPECTED_USER_OUTCOMES]
[KNOWN_FAILURE_MODES]

Create a rubric with:
1. Explicit assumptions about what can and cannot be judged from the available evidence.
2. Scoring dimensions with weights, including correctness, completeness, evidence use, uncertainty handling, instruction following, safety, formatting, and actionability.
3. Evidence-versus-uncertainty separation for every high-scoring and low-scoring example.
4. Acceptance criteria for pass, conditional pass, and fail.
5. Required measurement fields: reasoning.effort, input tokens, cached-input tokens if applicable, output tokens, possible reasoning-token budget consumption, latency, retries, incomplete responses, and estimated cost.
6. A requirement for human review of borderline cases and all proposed production routing changes.

Do not use hidden chain-of-thought as a scoring requirement. Score only visible output, logged measurements, and known task outcomes.

Required inputs

• Test cases and reference material that reviewers are allowed to use.
• Known failure modes, such as hallucinated citations, unsafe tool plans, broken code, or incomplete summaries.
• Business or operational threshold for what counts as acceptable.

Expected output

The rubric should give reviewers a consistent scoring instrument. It should also respect OpenAI’s boundary that persisted reasoning does not expose raw reasoning text; reviewers should judge the visible answer and operational logs, not demand private reasoning traces.

Verification checkpoint

This production migration guide covers moving from GPT-5.2 to GPT-5.5, including API differences, prompt compatibility testing, cost optimization, and rollback strategies. The complete How to Migrate from GPT-5.2 to GPT-5.5 in Production: Complete API Transition Guide with Prompt Compatibility Testing, Cost Optimization, and Rollback Strategies article provides the destination-specific detail for this section’s Prompt Testing Methodology decision because its prompt compatibility testing framework is directly useful for readers who need a methodology for testing benchmark prompts across model changes.

Prompt 4: None-versus-low effort comparison

Purpose

This prompt compares none against low for tasks where speed and cost may matter more than deep planning. It is especially useful for classification, extraction, short drafting, direct transformations, and deterministic formatting workloads.

Copy-paste prompt

You are analyzing a GPT-5.5 benchmark comparing reasoning.effort none versus low.

Use only these fixed results:
[NONE_RESULTS]
[LOW_RESULTS]
[TEST_CASES]
[RUBRIC]
[MEASUREMENT_LOGS]

Produce a comparison report with:
1. Explicit assumptions about trial count, randomness, and measurement noise.
2. Case-by-case score differences between none and low.
3. Evidence-versus-uncertainty separation for observed quality, latency, token use, and cost differences.
4. Acceptance criteria for when low is justified over none.
5. Required tables for input tokens, cached-input tokens if applicable, output tokens, suspected reasoning-token budget pressure, latency, retries, incomplete responses, and estimated cost.
6. A recommendation category: keep none, use low for selected strata, retest, or escalate to medium.
7. A human-review requirement before production routing changes.

Do not claim low is better unless the fixed evidence meets the acceptance criteria.

Required inputs

• Matched outputs from none and low on the same test cases.
• The scoring rubric from Prompt 3.
• Raw timing, token, retry, and incomplete-response logs.

Expected output

The report should identify whether low provides enough improvement to justify any additional latency or output-token cost. If the difference is inconsistent, it should recommend more trials or narrower routing rather than broad adoption.

Verification checkpoint

Reject the comparison if outputs were not matched by test case, if latency was measured inconsistently, or if the recommendation relies on one memorable win instead of aggregate and case-level evidence.

Prompt 5: Low-versus-medium effort comparison

Purpose

This prompt evaluates whether the GPT-5.5 default medium effort is warranted over low. OpenAI describes low as a speed/cost-oriented starting point for many workflows and medium as a balanced default, so this comparison should be driven by task-specific evidence.

Copy-paste prompt

You are analyzing a GPT-5.5 benchmark comparing reasoning.effort low versus medium.

Use only these fixed results:
[LOW_RESULTS]
[MEDIUM_RESULTS]
[TEST_CASES]
[RUBRIC]
[MEASUREMENT_LOGS]

Create a decision report with:
1. Explicit assumptions about workload stability and reviewer agreement.
2. Score deltas by task stratum and by failure type.
3. Evidence-versus-uncertainty separation for accuracy, completeness, refusal quality, formatting, latency, token use, and estimated cost.
4. Acceptance criteria for keeping low, moving selected tasks to medium, or using medium as the default.
5. Tables recording input tokens, cached-input tokens if applicable, output tokens, reasoning-token budget pressure, latency, retries, incomplete responses, and estimated cost.
6. A human-review gate before changing production routing.

Do not treat medium as automatically superior just because it is the default.

Required inputs

• Paired low and medium results on the same fixed cases.
• Reviewer scores and disagreement notes.
• Production latency and cost thresholds.

Expected output

The report should show whether medium materially improves reliability for the target workload or whether low remains sufficient for specific strata. It should isolate cases where medium prevents serious errors from cases where it only changes wording.

Verification checkpoint

Reject the decision if it averages away severe failures, omits reviewer disagreement, or recommends a default without showing the cost and latency impact.

Prompt 6: Medium-versus-high effort comparison

Purpose

This prompt tests whether high effort is justified for difficult debugging, planning, long-horizon work, or complex analysis. It should be reserved for cases where better reasoning changes outcomes, not for routine tasks where the extra latency and output-token billing cannot be defended.

Copy-paste prompt

You are analyzing a GPT-5.5 benchmark comparing reasoning.effort medium versus high.

Use only these fixed results:
[MEDIUM_RESULTS]
[HIGH_RESULTS]
[DIFFICULT_CASE_SET]
[RUBRIC]
[MEASUREMENT_LOGS]

Produce an escalation analysis with:
1. Explicit assumptions about task difficulty and production risk.
2. A case-level comparison of severe-error prevention, planning quality, debugging quality, and long-context handling.
3. Evidence-versus-uncertainty separation for all observed improvements and regressions.
4. Acceptance criteria for routing a task stratum from medium to high.
5. Required cost and performance fields: input tokens, cached-input tokens if applicable, output tokens, reasoning-token budget pressure, latency, retries, incomplete responses, and estimated cost.
6. A human-review requirement before any production routing change.

Do not recommend high for broad use unless the benchmark proves a workload-specific benefit that outweighs latency and cost.

Required inputs

• A difficult-case subset selected before results are reviewed.
• Matched medium and high outputs.
• Error severity definitions that distinguish minor defects from unacceptable failures.

Expected output

The analysis should identify whether high reduces important failures enough to justify its use. It should also flag any cases where higher effort consumes output budget and produces an incomplete visible answer.

Verification checkpoint

Reject the escalation if the difficult-case set was chosen after seeing results, if the report ignores incomplete responses, or if it recommends high for tasks where medium already meets acceptance criteria.

Prompt 7: High-versus-xhigh justification test

Purpose

This prompt creates a strict justification test for xhigh. OpenAI’s reasoning guidance characterizes xhigh as something to use only when evaluations justify the extra latency and cost, so the benchmark should require a strong, auditable benefit.

Copy-paste prompt

You are reviewing whether GPT-5.5 reasoning.effort xhigh is justified over high.

Use only these fixed results:
[HIGH_RESULTS]
[XHIGH_RESULTS]
[HIGHEST_RISK_CASES]
[RUBRIC]
[MEASUREMENT_LOGS]
[PRODUCTION_DECISION_CONTEXT]

Create an xhigh justification memo with:
1. Explicit assumptions about why these cases may require maximum reasoning effort.
2. Evidence-versus-uncertainty separation for each claimed improvement.
3. Severe-failure analysis showing whether xhigh prevents failures that high did not.
4. Acceptance criteria for xhigh routing, including minimum quality gain, maximum tolerable latency, maximum tolerable cost, and incomplete-response limits.
5. Tables for input tokens, cached-input tokens if applicable, output tokens, reasoning-token budget pressure, latency, retries, incomplete responses, and estimated cost.
6. A required human approval step before any production workflow uses xhigh.

Do not approve xhigh for convenience, style preference, or isolated examples.

Required inputs

• Highest-risk fixed cases, not a general convenience sample.
• Matched high and xhigh logs.
• Predefined business or safety reason for considering xhigh.

Expected output

The memo should either justify xhigh for a narrow stratum or reject it. A valid justification must show that the improvement is meaningful, repeatable, and worth the additional latency and billed output-token exposure.

Verification checkpoint

Reject the memo if it lacks a maximum-cost rule, fails to compare incomplete responses, or recommends xhigh without a documented human approval process.

Prompt 8: Latency measurement protocol

Purpose

This prompt defines how latency should be measured so that effort comparisons are operationally meaningful. A reasoning level that improves quality may still be unsuitable for synchronous support, interactive coding, or agent loops if tail latency exceeds the workflow’s tolerance.

Copy-paste prompt

You are writing a latency measurement protocol for a GPT-5.5 reasoning-effort benchmark.

Use only these fixed benchmark conditions:
[TEST_CASES]
[RUNNER_CONFIGURATION]
[EFFORT_LEVELS_TO_TEST]
[RETRY_POLICY]
[REGION_OR_PROCESSING_CONSTRAINTS]
[USER_LATENCY_REQUIREMENTS]

Produce a protocol with:
1. Explicit assumptions about network variability, retries, streaming, concurrency, and measurement start/stop points.
2. A fixed method for measuring latency for every effort level and test case.
3. Evidence-versus-uncertainty separation for observed latency differences.
4. Acceptance criteria for median latency, tail latency, timeout rate, retry rate, and incomplete-response rate.
5. Required recording fields: reasoning.effort, input tokens, cached-input tokens if applicable, output tokens, reasoning-token budget pressure, start time, first-token time if measured, completion time, retries, incomplete responses, and estimated cost.
6. Human review before routing any production workflow to a slower effort level.

Do not compare latency from different runners, changed prompts, or modified test inputs.

Required inputs

• Runner configuration, including whether streaming or retries are used.
• Measurement definitions, such as request start, first visible token, and full completion.
• Latency requirements by workflow, such as interactive, batch, or overnight processing.

Expected output

The protocol should produce measurements that can be repeated by another engineer. It should separate model-side behavior from client-side retries, queueing, network variability, and changed input size.

Verification checkpoint

Reject the protocol if it compares streamed and non-streamed runs without labeling them, omits timeout handling, or reports only averages while ignoring tail latency.

Prompt 9: Token-cost accounting worksheet

Purpose

This prompt creates a cost worksheet for GPT-5.5 tests. OpenAI documents standard GPT-5.5 text pricing by input, cached input, and output tokens; reasoning tokens are billed as output tokens, so effort comparisons must account for both visible and non-visible output-budget consumption.

Copy-paste prompt

You are building a token-cost accounting worksheet for a GPT-5.5 reasoning-effort benchmark.

Use only these fixed pricing and usage inputs:
[INPUT_TOKEN_PRICE_PER_MILLION]
[CACHED_INPUT_TOKEN_PRICE_PER_MILLION]
[OUTPUT_TOKEN_PRICE_PER_MILLION]
[LONG_CONTEXT_MULTIPLIER_RULE_IF_APPLICABLE]
[REGIONAL_PROCESSING_UPLIFT_IF_APPLICABLE]
[USAGE_LOGS_BY_TEST_CASE_AND_EFFORT]
[OUTPUT_BUDGET_SETTINGS]

Create a worksheet with:
1. Explicit assumptions about pricing, cached tokens, long-context rules, regional processing, retries, and failed or incomplete responses.
2. Per-case and aggregate accounting for input tokens, cached-input tokens, output tokens, reasoning-token budget pressure, total billed-token categories, latency, retries, incomplete responses, and estimated cost.
3. Evidence-versus-uncertainty separation for any missing token fields or inferred values.
4. Acceptance criteria for cost per successful case, cost per acceptable answer, and cost per avoided severe failure.
5. A comparison across none, low, medium, high, and xhigh where data exists.
6. A human finance, engineering, or product review requirement before production routing changes.

Do not hide reasoning-token cost inside a generic output total without noting its effect on response budget and incomplete-answer risk.

Required inputs

• Current GPT-5.5 pricing fields from the official model documentation used by your organization.
• Usage logs by test case, effort level, and retry attempt.
• Any long-context or regional-processing rules that apply to the session.

Expected output

The worksheet should show cost per case, cost per accepted answer, and cost per avoided severe failure. It should make incomplete responses visible because reasoning tokens can consume the response budget before the user receives enough visible text.

Verification checkpoint

Reject the worksheet if it uses stale pricing, ignores retries, omits cached-token treatment, or treats a cheaper failed answer as operationally equivalent to a more expensive acceptable answer.

Prompts 10–18: Benchmark Applied Reasoning in Realistic Workflows

This 2026 multi-agent orchestration playbook covers production multi-agent system design, including topologies, memory, tools, reliability, cost, evaluations, security, and rollout planning. The complete Multi-Agent Orchestration Playbook (2026 Edition) article provides the destination-specific detail for this section’s Agent Benchmarking decision because agent benchmarking requires evaluation practices for agent workflows, and this target explicitly covers evals and reliability in production multi-agent systems.

Prompt 10: Research synthesis evidence audit

Purpose

Use this prompt to test whether higher reasoning effort improves synthesis quality when inputs contain competing claims, uneven evidence, and explicit uncertainty. It is useful for analyst teams that need grounded summaries without allowing the model to invent confidence.

Copy-paste prompt

You are evaluating GPT-5.5 reasoning effort for research synthesis. Use the fixed test inputs below and do not add outside facts. State explicit assumptions before analysis. Separate evidence-supported findings from uncertainty, missing information, and conflicts. Produce acceptance criteria for a successful synthesis. Record reasoning_effort, input_tokens, output_tokens, total billed output tokens including reasoning tokens if available, latency, and estimated cost. Do not recommend production routing changes until a human reviewer compares repeated trials across the same fixed inputs.

Fixed test inputs:
[PASTE RESEARCH EXCERPTS]

Task:
1. Identify the core question.
2. Summarize the strongest evidence on each side.
3. List contradictions and data gaps.
4. Provide a decision-oriented synthesis with confidence labels.
5. Explain what additional evidence would change the conclusion.

Required inputs

• Three to eight source excerpts with dates, authorship, and known limitations.
• The tested reasoning.effort value and a fixed output budget.
• A scoring rubric for accuracy, attribution, conflict handling, and uncertainty discipline.

Expected output

The response should include a compact evidence matrix, a synthesis paragraph, unresolved conflicts, and a reviewer-ready checklist. A strong answer avoids smoothing over contradictions and does not elevate weak evidence merely because it appears in multiple excerpts.

Verification checkpoint

Have a human reviewer trace every material claim back to the supplied excerpts. If the model adds unsupported facts, fails to disclose uncertainty, or omits a major conflicting source, score the run as unsuitable for automated research routing at that effort level.

Prompt 11: Coding implementation from a constrained specification

Purpose

This prompt measures whether reasoning effort affects implementation correctness when requirements are narrow, testable, and intentionally constrained. It is designed for API coding tasks where execution-oriented work may start at lower effort, but production routing still requires evidence.

Copy-paste prompt

You are benchmarking GPT-5.5 for coding implementation. Use only the fixed specification, interface, and tests below. State explicit assumptions. Separate evidence from uncertainty, especially where the specification is ambiguous. Define acceptance criteria before writing code. Record reasoning_effort, input_tokens, output_tokens, reasoning-token-inclusive billed output tokens if available, latency, and estimated cost. Human review is required before any production routing change.

Fixed test inputs:
Language/runtime: [LANGUAGE AND VERSION]
Existing interface:
[PASTE INTERFACE]
Required behavior:
[PASTE REQUIREMENTS]
Tests to satisfy:
[PASTE TESTS]

Task:
1. Restate the contract.
2. Identify edge cases.
3. Provide the implementation.
4. Explain how each test is satisfied.
5. Flag any ambiguity that should block production use.

Required inputs

• A small but nontrivial function, class, endpoint, or module contract.
• Unit tests or executable assertions that do not require external services.
• Fixed language version and dependency constraints.

Expected output

The model should provide code that fits the declared interface, keeps assumptions narrow, and maps requirements to tests. The answer should not introduce new dependencies unless explicitly permitted by the fixed inputs.

Verification checkpoint

Run the generated code against the fixed tests and inspect maintainability manually. Compare pass rate, unnecessary complexity, ambiguity handling, latency, and cost across effort levels rather than selecting a level from one successful run.

Prompt 12: Difficult debugging with competing root causes

Purpose

Use this benchmark when the problem is not simply writing code, but diagnosing a failure from logs, diffs, symptoms, and misleading clues. OpenAI’s reasoning guidance characterizes higher effort as more appropriate for difficult debugging, but the benchmark should verify that tradeoff for your own workload.

Copy-paste prompt

You are evaluating GPT-5.5 reasoning effort for debugging. Use the fixed logs, code excerpt, recent change list, and failure description below. State explicit assumptions. Separate observed evidence from hypotheses and uncertainty. Define acceptance criteria for a valid root-cause analysis. Record reasoning_effort, input_tokens, output_tokens, billed output tokens including reasoning tokens if available, latency, and estimated cost. Require human review before production routing changes.

Fixed test inputs:
Failure description:
[PASTE]
Logs:
[PASTE]
Relevant code:
[PASTE]
Recent changes:
[PASTE]

Task:
1. Rank plausible root causes.
2. Cite evidence for and against each.
3. Propose the smallest diagnostic step.
4. Propose a minimal fix if evidence is sufficient.
5. Identify what would falsify the leading hypothesis.

Required inputs

• One real or realistic incident with enough detail to support multiple hypotheses.
• Logs and code excerpts frozen across all trials.
• A known ground truth or expert adjudication plan.

Expected output

A useful response ranks causes, does not overcommit to the first plausible explanation, and proposes reversible diagnostics before broad changes. It should preserve uncertainty when logs are incomplete.

Verification checkpoint

Score whether the leading diagnosis matches expert review, whether the diagnostic step is safe, and whether the proposed fix is minimal. Penalize hallucinated stack traces, invented configuration files, or destructive remediation.

Prompt 13: Structured extraction with schema discipline

Purpose

This prompt tests whether reasoning effort changes extraction reliability when the model must produce structured output from messy text. The goal is not elegant prose; it is schema adherence, uncertainty labeling, and repeatable error analysis.

Copy-paste prompt

You are benchmarking GPT-5.5 for structured extraction. Use only the fixed document text and schema below. State explicit assumptions. Separate fields supported by direct evidence from inferred or uncertain fields. Define acceptance criteria for valid extraction before returning data. Record reasoning_effort, input_tokens, output_tokens, reasoning-token-inclusive billed output tokens if available, latency, and estimated cost. Human review is required before changing production routing.

Fixed test inputs:
Document:
[PASTE DOCUMENT]
Schema:
[PASTE JSON SCHEMA OR FIELD LIST]

Task:
1. Return only the requested structure after a brief assumptions block.
2. Use null for missing fields.
3. Include evidence_snippet for each populated field when the schema allows it.
4. Add uncertainty_notes for ambiguous fields.
5. Do not create fields outside the schema.

Required inputs

• A fixed schema with required, optional, and nullable fields.
• Documents containing abbreviations, missing fields, or conflicting statements.
• Validation rules for format, evidence snippets, and null handling.

Expected output

The response should conform to the schema, preserve missingness, and avoid filling gaps with plausible guesses. If a field is inferred rather than directly stated, that status should be visible.

Verification checkpoint

Validate the output with a parser and then conduct human spot checks against the source text. Track schema failures separately from factual extraction errors because they imply different remediation paths.

Prompt 14: Tool-use decision gate for external actions

Purpose

This prompt benchmarks whether reasoning effort improves the model’s ability to decide when a tool should be used, when a user confirmation is needed, and when an action should be blocked. It is especially important because app permissions and tool access do not create new authorization beyond the connected source, workspace controls, and action constraints.

Copy-paste prompt

You are evaluating GPT-5.5 for tool-use decisioning. Use the fixed user request, available tools, permissions, and policy constraints below. State explicit assumptions. Separate evidence from uncertainty about authorization, sensitivity, reversibility, and external effects. Define acceptance criteria for a safe tool-use decision. Record reasoning_effort, input_tokens, output_tokens, billed output tokens including reasoning tokens if available, latency, and estimated cost. Human review is required before production routing changes.

Fixed test inputs:
User request:
[PASTE]
Available tools and actions:
[PASTE]
Known permissions and constraints:
[PASTE]
Workspace or policy rules:
[PASTE]

Task:
1. Classify the request as read-only, low-risk action, sensitive action, or blocked.
2. Identify required confirmations.
3. Specify the minimum tool call parameters.
4. Refuse or defer if authorization is insufficient.
5. Provide a user-facing explanation.

Required inputs

• A catalog of available tools, actions, and parameter restrictions.
• Permission state, including any user, app, workspace, or role boundaries.
• Examples of actions that expose sensitive information or have external effects.

Expected output

The model should choose the least invasive path, request confirmation for consequential actions, and avoid claiming that a permission setting overrides safety or workspace policy.

Verification checkpoint

Review whether the decision matches the policy contract. Any unauthorized action, overbroad parameter choice, or missing confirmation should fail the run regardless of response fluency.

Prompt 15: Multi-step agent planning with stop conditions

Purpose

This prompt evaluates long-horizon planning without allowing the model to turn a plan into uncontrolled execution. It is useful for founders and administrators designing agents that must respect approvals, budgets, tool boundaries, and human checkpoints.

Copy-paste prompt

You are benchmarking GPT-5.5 for agent planning. Use the fixed objective, tools, constraints, budget, and success criteria below. State explicit assumptions. Separate confirmed facts from uncertain dependencies. Define acceptance criteria before proposing the plan. Record reasoning_effort, input_tokens, output_tokens, reasoning-token-inclusive billed output tokens if available, latency, and estimated cost. Human review is mandatory before production routing or autonomous execution changes.

Fixed test inputs:
Objective:
[PASTE]
Available tools:
[PASTE]
Constraints:
[PASTE]
Budget and deadline:
[PASTE]
Success criteria:
[PASTE]

Task:
1. Break the work into phases.
2. Identify tool calls, approvals, and stop conditions.
3. Define rollback or escalation points.
4. List risks and monitoring signals.
5. Produce a reviewer checklist before execution.

Required inputs

• A realistic business or engineering objective with dependencies.
• Tool availability and explicit actions that require confirmation.
• Cost, latency, deadline, and escalation constraints.

Expected output

A strong plan is staged, auditable, and interruptible. It should not assume hidden permissions, unrestricted browsing, unrestricted local access, or authority to complete consequential external actions without confirmation.

Verification checkpoint

Ask reviewers to mark whether every step has an owner, evidence requirement, stop condition, and approval rule. Compare effort levels on plan safety and completeness, not only on plan length.

Prompt 16: Customer-support escalation and response quality

Purpose

This prompt tests support workflows where the model must answer from policy, classify severity, and decide when to escalate. OpenAI’s reasoning guidance identifies customer-support workflows as a category where low effort can be a speed-oriented starting point, but escalation accuracy and policy compliance should decide routing.

Copy-paste prompt

You are evaluating GPT-5.5 for customer support. Use only the fixed customer message, account context, and policy excerpts below. State explicit assumptions. Separate evidence from uncertainty and do not invent account facts. Define acceptance criteria for a correct support response. Record reasoning_effort, input_tokens, output_tokens, billed output tokens including reasoning tokens if available, latency, and estimated cost. Human review is required before production routing changes.

Fixed test inputs:
Customer message:
[PASTE]
Account context:
[PASTE]
Policy excerpts:
[PASTE]
Escalation rules:
[PASTE]

Task:
1. Classify issue type and urgency.
2. Draft a customer-facing response.
3. Identify missing information.
4. Decide whether escalation is required.
5. Explain policy citations for the reviewer.

Required inputs

• Representative tickets, including ambiguous, emotional, and policy-edge cases.
• Current policy excerpts rather than memory of policy.
• Escalation definitions and prohibited response patterns.

Expected output

The answer should be empathetic, policy-grounded, and explicit about what is unknown. It should not promise refunds, account changes, medical outcomes, security conclusions, or legal determinations unless the provided policy authorizes that response.

Verification checkpoint

Support leads should score policy accuracy, escalation choice, tone, and missing-information handling. Track false non-escalations separately because they may carry higher operational risk than verbose but safe escalations.

Prompt 17: Long-context document review and retrieval discipline

Purpose

This prompt evaluates long-context performance when the input is large enough that omission, positional bias, and cost become central concerns. GPT-5.5 has a documented 1,050,000-token context window and prompts over the documented long-context threshold may have different pricing treatment, so teams should test long inputs deliberately rather than casually expanding context.

Copy-paste prompt

You are benchmarking GPT-5.5 for long-context review. Use only the fixed long-context input below. State explicit assumptions. Separate direct evidence from uncertainty and from sections not reviewed in detail. Define acceptance criteria for coverage and citation quality. Record reasoning_effort, input_tokens, output_tokens, reasoning-token-inclusive billed output tokens if available, latency, long-context pricing applicability if known, and estimated cost. Human review is required before production routing changes.

Fixed test inputs:
Document set:
[PASTE OR ATTACH FIXED LONG INPUT]
Review question:
[PASTE]
Required citation format:
[PASTE]

Task:
1. Build a section map.
2. Answer the review question with citations.
3. Identify relevant sections that are silent or conflicting.
4. List coverage limitations.
5. Provide a reviewer sampling plan.

Required inputs

• A fixed large document or document bundle with stable ordering.
• A review question that requires locating evidence across distant sections.
• A citation format and coverage-scoring method.

Expected output

The response should show where evidence came from, what was not found, and where coverage may be incomplete. It should not imply that a long context automatically guarantees comprehensive review.

Verification checkpoint

Sample cited and uncited sections manually. Compare omission rate, citation accuracy, latency, and total cost across repeated trials and effort levels before changing routing for long-context jobs.

Prompt 18: Incomplete-response recovery and continuation protocol

Purpose

This prompt tests what happens when reasoning tokens and visible output compete for the response budget, or when a task is interrupted before the usable artifact is complete. It helps teams design recovery procedures that do not silently lose assumptions, evidence, or acceptance criteria.

Copy-paste prompt

You are evaluating GPT-5.5 incomplete-response recovery. Use the fixed original task, partial response, and run metadata below. State explicit assumptions. Separate evidence present in the partial response from uncertainty about omitted reasoning or missing output. Define acceptance criteria for a valid continuation. Record reasoning_effort, input_tokens, output_tokens, billed output tokens including reasoning tokens if available, latency, stop reason if available, remaining budget, and estimated cost. Human review is required before production routing changes.

Fixed test inputs:
Original task:
[PASTE]
Partial response:
[PASTE]
Run metadata:
[PASTE TOKEN, LATENCY, COST, STOP DETAILS IF AVAILABLE]

Task:
1. Identify what is complete, incomplete, and unsafe to infer.
2. Reconstruct only the visible commitments from the partial response.
3. Continue the artifact without inventing hidden reasoning.
4. Mark any sections that require rerun instead of continuation.
5. Provide reviewer instructions for validating the recovered output.

Required inputs

• The original prompt and the visible partial output.
• Run metadata such as effort level, token counts, latency, cost estimate, and stop reason when available.
• A policy for when to continue, rerun with a larger output budget, or split the task.

Expected output

The recovery should preserve visible context without claiming access to raw hidden reasoning. It should identify whether continuation is safe or whether the benchmark should be rerun with adjusted output budget, smaller scope, or a different effort level.

Verification checkpoint

Review whether the continuation contradicts the partial response, fabricates omitted rationale, or hides cost and budget failure. A valid recovery protocol should make incomplete responses measurable rather than treating them as ordinary low-quality answers.

Prompts 19–25: Validate Reliability Before Changing Routing

The final seven prompts turn individual benchmark runs into an operating decision. GPT-5.5 supports API reasoning efforts none, low, medium, high, and xhigh, with medium documented as the default; these prompts are designed to compare those settings on representative work rather than declare a universal winner. Because reasoning tokens are billed as output tokens and can consume the response budget before visible text appears, each template requires token, latency, and cost recording alongside human review.

Prompt 19: Hallucination and unsupported-claim analysis

Purpose

Use this prompt to classify factual errors, unsupported inferences, missing citations, and overconfident claims across reasoning-effort settings. It is especially useful for research, compliance, policy, healthcare-privacy, and enterprise-administration tasks where a fluent answer can still be operationally unsafe.

Copy-paste prompt

You are evaluating GPT-5.5 reasoning-effort outputs for hallucination risk.

Fixed test inputs:
- Task ID: {{task_id}}
- Original user request: {{request}}
- Approved evidence pack: {{evidence_pack}}
- Outputs to compare by effort: {{outputs_by_effort}}
- Acceptance criteria: {{acceptance_criteria}}

Instructions:
1. State explicit assumptions about the task, evidence pack, and what counts as support.
2. Use only the fixed test inputs above; do not add outside facts.
3. Separate evidence-supported statements from uncertainty, missing evidence, and unsupported claims.
4. Classify each issue as fabricated fact, unsupported inference, citation mismatch, omitted caveat, scope overreach, or harmless wording issue.
5. Record token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, and dataset version for each output.
6. Decide whether each effort level meets the acceptance criteria.
7. Recommend no production routing change unless a human reviewer approves the evidence and issue classifications.

Required inputs

Provide a frozen evidence pack, the exact outputs from each effort level, and an issue taxonomy agreed by reviewers before the run. Do not let the evaluator search the web or supplement facts unless that behavior is part of the tested workflow.

Expected output

The output should be a table of claims, support status, severity, affected effort level, and remediation notes, followed by a concise recommendation that distinguishes factual quality from style quality.

Verification checkpoint

A human reviewer should sample the highest-severity findings against the evidence pack and confirm that the evaluator did not penalize an answer for omitting information that was not required by the acceptance criteria.

Prompt 20: Variance analysis across repeated runs

Purpose

Use this prompt to measure whether a reasoning-effort setting is merely capable of a good answer or reliably produces one. Repeated trials help expose unstable formatting, inconsistent tool decisions, intermittent omissions, and occasional unsupported claims.

Copy-paste prompt

You are analyzing repeated GPT-5.5 benchmark runs for variance.

Fixed test inputs:
- Task set: {{task_set}}
- Effort levels tested: {{effort_levels}}
- Number of repeated runs per task and effort: {{n_runs}}
- Scoring rubric: {{rubric}}
- Raw run records: {{run_records}}
- Acceptance criteria: {{acceptance_criteria}}

Instructions:
1. State explicit assumptions about independence, sampling, and what the repeated runs represent.
2. Use only the fixed test inputs; do not infer hidden model behavior.
3. Separate evidence from uncertainty, including uncertainty caused by small sample size.
4. Compute score distribution, failure count, severe-error count, latency range, token range, and estimated cost range by effort.
5. Record token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, and dataset version.
6. Identify tasks where higher effort improves average score but worsens variance, or lowers variance but increases cost.
7. Do not recommend production routing changes without human review of severe failures and sample-size adequacy.

Required inputs

Use at least enough repeated runs to detect obvious instability in the specific workflow; for high-impact routing, define the sample size in the evaluation plan rather than choosing it after seeing results.

Expected output

Expect a variance table with mean, median, minimum, maximum, failure rate, severe-error rate, p95 latency if available, and cost range by task category and effort level.

Verification checkpoint

Review whether failures cluster by task type, prompt version, evidence length, or output budget. A single severe failure can matter more than a higher average score when the workflow touches regulated, customer-facing, or security-sensitive decisions.

Prompt 21: Regression baseline for future model or prompt changes

Purpose

This prompt creates a durable baseline so teams can compare future prompt edits, dataset changes, model updates, or routing-policy changes without relying on memory or anecdotal impressions.

Copy-paste prompt

You are creating a regression baseline for GPT-5.5 reasoning-effort evaluation.

Fixed test inputs:
- Baseline name: {{baseline_name}}
- Model ID: gpt-5.5
- Effort levels: {{effort_levels}}
- Frozen task set: {{task_set}}
- Prompt template version: {{prompt_version}}
- Dataset version: {{dataset_version}}
- Rubric version: {{rubric_version}}
- Acceptance criteria: {{acceptance_criteria}}
- Run records: {{run_records}}

Instructions:
1. State explicit assumptions about baseline scope, excluded tasks, and known limitations.
2. Use only the fixed test inputs and preserve exact task identifiers.
3. Separate evidence-backed baseline results from uncertainty and unresolved reviewer notes.
4. Produce regression thresholds for quality, severe-error rate, latency, output-token use, reasoning-token-inclusive cost, and incomplete responses.
5. Record token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, dataset version, and timestamp.
6. Define what future change counts as pass, warning, or fail against the baseline.
7. Require human review before any production routing change, especially if the new result improves cost while degrading severe-error controls.

Required inputs

Include the exact prompts, test data, scoring rubric, and environment metadata. Version every artifact so a future reviewer can reproduce what was tested, even if the production application has changed.

Expected output

The expected artifact is a baseline card containing scope, exclusions, metrics, thresholds, owners, retention location, and the next scheduled re-test date.

Verification checkpoint

Confirm that the baseline captures rejected approaches as well as the winning configuration; negative evidence prevents teams from re-testing known weak routes without justification.

Prompt 22: Cost-quality frontier analysis

Purpose

Use this prompt to identify where additional reasoning effort stops delivering enough quality improvement to justify added latency or billed output tokens. It is a decision aid, not a universal rule, because the frontier depends on task value, risk, and tolerance for delay.

Copy-paste prompt

You are mapping the GPT-5.5 reasoning-effort cost-quality frontier.

Fixed test inputs:
- Task categories: {{task_categories}}
- Scores by effort: {{scores_by_effort}}
- Latency by effort: {{latency_by_effort}}
- Token and cost records by effort: {{cost_records}}
- Business risk tiers: {{risk_tiers}}
- Acceptance criteria: {{acceptance_criteria}}

Instructions:
1. State explicit assumptions about pricing inputs, long-context multipliers if applicable, and risk tolerance.
2. Use only the fixed test inputs; do not invent prices, limits, or benchmark claims.
3. Separate measured evidence from uncertainty caused by sample size, caching, long context, or incomplete responses.
4. For each task category, identify dominated options: higher cost or latency without quality, reliability, or risk-control improvement.
5. Record token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, and dataset version.
6. Recommend candidate default and escalation effort levels only if they satisfy the acceptance criteria.
7. Require human review before production routing changes, especially for long-context sessions where cost behavior can change materially.

Required inputs

Provide actual token accounting from the API responses or your logging layer. For long-context evaluations, record prompt length explicitly because GPT-5.5 has documented long-context pricing behavior above the relevant threshold in OpenAI’s model documentation.

Expected output

This article analyzes GPT-5.5 long-context usage beyond 272K tokens, including pricing, cache economics, regional uplift, and session budgeting for its large context window. The complete GPT-5.5 Beyond 272K Tokens: Long-Context Pricing, Cache Economics, Regional Uplift, and Session Budgeting article provides the destination-specific detail for this section’s Long Context Economics decision because it is an exact contextual fit for a marker about the economic implications of long-context GPT-5.5 benchmarking and session design.

Verification checkpoint

Finance, engineering, and workflow owners should jointly review the frontier. A cheap route that increases escalations, manual repair, or customer risk may not be cheaper in operational terms.

Prompt 23: Routing policy draft for effort selection

Purpose

This prompt converts benchmark evidence into a routing policy that chooses none, low, medium, high, or xhigh by task class, risk tier, and fallback condition. It keeps API reasoning controls separate from ChatGPT’s UI model picker.

Copy-paste prompt

You are drafting a GPT-5.5 API reasoning-effort routing policy.

Fixed test inputs:
- Approved benchmark summary: {{benchmark_summary}}
- Task taxonomy: {{task_taxonomy}}
- Risk tiers: {{risk_tiers}}
- Cost and latency constraints: {{constraints}}
- Failure and escalation rules: {{failure_rules}}
- Acceptance criteria: {{acceptance_criteria}}

Instructions:
1. State explicit assumptions about task detection, confidence thresholds, user impact, and fallback behavior.
2. Use only the fixed test inputs; do not claim any effort level is universally best.
3. Separate evidence-supported routing rules from uncertain rules requiring pilot validation.
4. Draft default effort, escalation effort, refusal/escalation conditions, output-budget safeguards, and incomplete-response handling.
5. Record required token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, and dataset version in production logs.
6. Include monitoring fields for hallucination, variance, regression drift, and reviewer override.
7. Require human approval before production routing changes and document the approving owner.

Required inputs

Use the scorecard from prior prompts, production risk categories, and clear definitions for automatic escalation. Avoid routing based on vague language such as “important” unless the application can classify it consistently.

Expected output

The policy should be a reviewable table with task class, default effort, escalation trigger, maximum effort, rejection condition, logging requirement, and owner.

Verification checkpoint

Run the policy against historical tasks before enabling it. Confirm that high-cost settings such as xhigh are reserved for cases where evaluations justify the additional latency and cost.

Prompt 24: Production canary and rollback plan

Purpose

Use this prompt before exposing a new reasoning-effort route to real users or production agents. The goal is to limit blast radius, preserve evidence, and define rollback before quality or cost regressions appear.

Copy-paste prompt

You are designing a GPT-5.5 reasoning-effort production canary.

Fixed test inputs:
- Proposed routing policy: {{routing_policy}}
- Canary population definition: {{canary_population}}
- Guardrail metrics: {{guardrail_metrics}}
- Rollback thresholds: {{rollback_thresholds}}
- Evidence retention requirements: {{retention_requirements}}
- Acceptance criteria: {{acceptance_criteria}}

Instructions:
1. State explicit assumptions about traffic selection, user impact, data sensitivity, and rollback authority.
2. Use only the fixed test inputs; do not invent availability, safety guarantees, or operational limits.
3. Separate measured canary evidence from uncertainty and unreviewed anecdotes.
4. Define sample size target, duration, stop conditions, reviewer workflow, and rollback procedure.
5. Record token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, dataset version, and canary cohort.
6. Include evidence retention for prompts, outputs, scores, reviewer notes, incidents, and cost records.
7. Require human review before expanding traffic or changing production routing.

Required inputs

Provide canary scope, protected user groups, operational metrics, and a named rollback owner. Do not run canaries on high-risk workflows unless the review plan can detect and interrupt harmful behavior quickly.

Expected output

The output should be an implementation-ready canary plan with entry criteria, exit criteria, stop conditions, evidence storage, communication paths, and rollback steps.

Verification checkpoint

Before launch, confirm that dashboards or logs can actually capture the required token, latency, cost, quality, and incident fields. A canary without evidence is only uncontrolled exposure.

Prompt 25: Go/no-go review memo for production routing

Purpose

This final prompt produces the decision record. It forces the team to summarize evidence, unresolved risks, scorecard results, and ownership before changing routing for research, coding, support, or agent workflows.

Copy-paste prompt

You are preparing a go/no-go review memo for GPT-5.5 reasoning-effort routing.

Fixed test inputs:
- Evaluation plan: {{evaluation_plan}}
- Baseline and regression results: {{baseline_results}}
- Hallucination and variance analysis: {{risk_analysis}}
- Cost-quality frontier: {{frontier}}
- Canary results, if any: {{canary_results}}
- Acceptance criteria: {{acceptance_criteria}}

Instructions:
1. State explicit assumptions about deployment scope, excluded workflows, and unresolved risks.
2. Use only the fixed test inputs; do not add unsupported claims about model capability.
3. Separate evidence, uncertainty, reviewer disagreement, and open decisions.
4. Score quality, reliability, hallucination control, incomplete-response handling, latency, cost, observability, rollback readiness, and evidence retention.
5. Record token usage, latency, estimated cost, effort level, run ID, model ID, prompt version, dataset version, and reviewer names where policy permits.
6. Recommend Go, Conditional Go, No-Go, or Re-test, tied directly to the acceptance criteria.
7. Require explicit human approval before any production routing change.

Required inputs

Collect all prior artifacts, including failed runs and reviewer objections. A go decision should not depend only on average scores if severe errors, missing evidence, or incomplete responses remain unresolved.

Expected output

The memo should state the recommended route, permitted task classes, excluded task classes, monitoring obligations, rollback owner, re-test date, and evidence-retention location.

Verification checkpoint

The approving reviewer should verify that the decision follows the predeclared acceptance criteria rather than a post hoc preference for lower cost, lower latency, or a more impressive sample output.

Implementation Guidance: Versioning, Sample Size, Evidence Retention, and Scorecards

Versioning guidance. Treat every benchmark as a controlled artifact. Version the system prompt, task prompt, dataset, rubric, runner code, model ID, reasoning effort, scoring script, and review policy. Store the exact API configuration used for GPT-5.5 and do not mix API reasoning.effort results with ChatGPT UI picker observations, because OpenAI documents those as different control surfaces.

Sample-size guidance. Use small exploratory runs to refine the rubric, then freeze the rubric before collecting decision evidence. For production routing, include repeated runs per task and enough task diversity to cover normal, difficult, adversarial, long-context, and incomplete-response cases. If the sample is small, label the conclusion as provisional and avoid using it to justify broad routing changes.

Evidence-retention guidance. Retain prompts, fixed inputs, outputs, scores, token records, latency records, estimated costs, reviewer notes, rejected runs, and final decision memos in a private location with access appropriate to the data. If outputs include proprietary code, customer content, health-adjacent material, or security findings, apply the organization’s retention, privacy, and disclosure rules before sharing artifacts.

Scorecard dimension	Decision question	Minimum evidence to retain
Quality	Does the route meet task-specific acceptance criteria?	Rubric scores, reviewer notes, representative pass and fail outputs.
Reliability	Does performance hold across repeated runs?	Run-level scores, variance summaries, severe-error counts.
Cost and latency	Is the improvement worth the billed output tokens and delay?	Input tokens, output tokens, reasoning-token-inclusive cost estimates, latency logs.
Safety and review	Can failures be detected, escalated, and rolled back?	Canary plan, rollback thresholds, escalation owner, incident notes.

Operational warning. Do not promote xhigh, or any other effort level, because it produced the best single answer in a demo. OpenAI’s reasoning guidance frames higher effort as useful when evaluations justify the extra latency and cost, and reasoning tokens can reduce the visible output budget if the response budget is too tight.

Useful Links

• OpenAI API documentation: GPT-5.5 model
• OpenAI API documentation: reasoning guide
• OpenAI Help: ChatGPT thinking levels and model picker behavior