GPT-5.5 API and Evaluation Guide: Facts, Cost, and Migration

What Is Verified

OpenAI announced GPT-5.5 on April 23, 2026. The post was updated on April 24 to state that gpt-5.5 and GPT-5.5 Pro were available in the API. As of October 3, 2026, that same page directs readers to GPT-5.6 as the newer release.

That makes GPT-5.5 a versioned production option, not a synonym for “the latest OpenAI model.” A defensible engineering record should contain:

• exact model ID;
• API endpoint and SDK version;
• reasoning settings;
• context and output limits;
• price-table date and service tier;
• tool configuration;
• evaluation dataset and harness revision;
• fallback and rollback model.

This article separates three evidence classes:

None of those sources publishes full training or serving architecture. A benchmark score also cannot reveal expert routing, parameter count, training data, or model topology.

What “Architecture” Does Not Mean Here

Earlier commentary around GPT-5.5 often repeated claims such as:

• a “Spud” codename;
• Sparse Mixture-of-Experts with a specific expert count;
• dynamic internal routing layers;
• a single unified omnimodal backbone;
• a specific GB300 deployment topology.

The cited primary sources do not establish those claims. Do not put them into capacity plans, procurement documents, security reviews, or technical explanations as facts.

The GPT-5.5 System Card does establish one useful relationship: GPT-5.5 Pro uses the same underlying model with a setting that applies parallel test-time compute. That describes inference behavior at a high level; it does not disclose the model's internal neural architecture.

The release post includes a NVIDIA customer statement that GPT-5.5 was built and served on GB200 NVL72 systems. A testimonial does not define every production region, rack topology, quantization mode, or serving path. API consumers should design against the service contract and measured behavior rather than inferred infrastructure.

Current API Contract

The current GPT-5.5 model catalog entry documents:

• model ID gpt-5.5;
• use through the Responses API;
• a one-million-token context window;
• configurable reasoning effort;
• supported tool and structured-output capabilities listed by the catalog.

Use the Responses API for new integrations. Do not assume a ChatGPT product label maps one-to-one to the API model, and do not send the string latest when reproducibility matters.

A Minimal Go Request

The following program uses only the Go standard library so the wire contract remains visible. In a larger service, use a pinned, reviewed SDK or wrap this client with timeouts, retries, telemetry, and response parsing.

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

type responseRequest struct {
	Model     string         `json:"model"`
	Input     string         `json:"input"`
	Reasoning map[string]any `json:"reasoning,omitempty"`
}

func main() {
	apiKey := os.Getenv("OPENAI_API_KEY")
	if apiKey == "" {
		panic("OPENAI_API_KEY is required")
	}

	payload, err := json.Marshal(responseRequest{
		Model: "gpt-5.5",
		Input: "Return three migration risks as concise JSON.",
		Reasoning: map[string]any{
			"effort": "medium",
		},
	})
	if err != nil {
		panic(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(
		ctx,
		http.MethodPost,
		"https://api.openai.com/v1/responses",
		bytes.NewReader(payload),
	)
	if err != nil {
		panic(err)
	}
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	body, err := io.ReadAll(io.LimitReader(res.Body, 4<<20))
	if err != nil {
		panic(err)
	}
	if res.StatusCode/100 != 2 {
		panic(fmt.Sprintf("OpenAI status %d: %s", res.StatusCode, body))
	}
	fmt.Println(string(body))
}

Production changes should include:

• a dedicated http.Client with transport and connection limits;
• bounded retries for 429 and transient 5xx responses;
• server-provided retry guidance and request IDs;
• idempotency for application side effects;
• strict response schemas where supported;
• cancellation propagation;
• usage and cost records;
• redaction before logs or traces.

Never retry validation, permission, or safety-policy failures as if they were transient network errors.

Reasoning Effort Is a Budget Control

GPT-5-family API schemas expose reasoning effort controls. The available set is model-dependent and can include none, low, medium, high, xhigh, and max; GPT-5.5 defaults to medium in the current contract. Verify accepted values against the pinned model page rather than copying a setting from another model.

Higher effort may improve some difficult tasks, but it can also increase:

• output-token usage;
• end-to-end latency;
• timeout probability;
• cost variance;
• the amount of context consumed before the visible answer.

Reasoning tokens are billed as output tokens and consume context even when they are not returned as user-visible text. Therefore, the right setting is empirical:

1. choose representative tasks;
2. run each supported effort level with identical inputs and tools;
3. measure task success, not answer length;
4. record input, cached input, reasoning/output usage, latency, and errors;
5. select the lowest effort that satisfies the target by task class.

For background research, coding, and high-impact decisions, allow a larger budget only when the evaluation demonstrates value. For classification or routing, a smaller model or lower effort may be more reliable and economical.

One Million Tokens Is a Limit, Not a Retrieval SLA

A one-million-token context window changes what can fit in a request. It does not prove that the model will:

• find one fact anywhere in that window;
• preserve relations across hundreds of documents;
• ignore contradictory or malicious instructions;
• produce the same answer when evidence moves from the start to the middle;
• remain economical at maximum length.

Build a long-context evaluation with controlled evidence positions:

Keep room for tool output, reasoning, and the final response. If the request fills the entire nominal context, truncation or insufficient generation headroom can invalidate the run.

For factual enterprise work, a retrieval pipeline often beats indiscriminately sending a repository or document archive. Use the context-window guide to separate capacity from reliable recall, and evaluate retrieval with the RAG evaluation guide.

Pricing and Cost Model

The OpenAI API pricing page checked October 3, 2026 lists standard GPT-5.5 rates below 270K context:

The minimum token cost of a run is:

cost =
  uncached_input_tokens / 1,000,000 * 5.00
  + cached_input_tokens / 1,000,000 * 0.50
  + output_and_reasoning_tokens / 1,000,000 * 30.00

For example, 100,000 uncached input tokens and 20,000 output-plus-reasoning tokens cost:

0.1 * $5.00 + 0.02 * $30.00 = $1.10

That excludes tools, storage, containers, regional processing, retries, and any long-context price treatment. The public page notes that its displayed standard rates apply below 270K context. Verify detailed pricing before estimating a 1M-context workload.

Cache savings also require an actual cache hit. Record provider-reported cached tokens rather than estimating that a shared prefix “should” have been cached.

For a complete ledger design, see AI inference cost engineering.

Read the Published Benchmarks Correctly

The release post reports:

These numbers are useful release evidence, not a workload guarantee. Before comparing models, inspect:

• model snapshot and access tier;
• prompt and tool harness;
• number of attempts and sampling;
• timeout and token budget;
• scorer and human-review policy;
• environment version;
• whether the provider used private scaffolding;
• confidence intervals or task-level variance.

Expert-SWE is explicitly internal, so an external team cannot reproduce it from the score alone. “Wins or ties” is not the same metric as exact task accuracy. Agent benchmarks are especially sensitive to tool permissions, environment setup, retry policy, and wall-clock budget.

Do not turn this table into “GPT-5.5 is 82.7% accurate at coding.” Terminal-Bench measures a specific harness and task distribution.

Build a Workload-Specific Evaluation

1. Define the Decision

Examples:

• migrate a coding agent from GPT-5.4;
• use GPT-5.5 only for escalation;
• replace long-context retrieval with direct context;
• enable a higher reasoning effort for incident analysis.

Each decision needs different evidence.

2. Freeze the Harness

Pin:

• dataset revision;
• prompt and system instructions;
• tool schemas and permissions;
• repository or document snapshot;
• model IDs and settings;
• timeouts, retries, and maximum turns;
• evaluator version;
• price table date.

3. Use Deterministic Oracles First

For coding, run build, tests, linters, security checks, and patch-scope validation. For extraction, compare typed fields. For workflows, verify tool target, policy, and downstream state. Use a model judge only for qualities that deterministic checks cannot capture, and calibrate it against human labels.

4. Report Slices, Not One Score

Useful slices include:

• easy versus long-horizon tasks;
• familiar versus new repositories;
• short versus long context;
• no tools versus one tool versus multi-tool;
• clean versus adversarial evidence;
• first attempt versus recovered attempt;
• low, medium, and high reasoning effort.

Report pass rate, severe-error rate, latency percentiles, token distribution, tool-call count, retry rate, and cost per successful task.

5. Evaluate Safety and Authority

Test whether the model:

• treats retrieved documents and web pages as untrusted data;
• requests tools outside its assigned role;
• follows approval gates;
• leaks secrets into output or tool arguments;
• acts on stale or cross-tenant objects;
• repeats side effects after uncertain timeouts;
• stops at step, time, and spend limits.

A stronger model does not eliminate the need for authorization. Review the AI agent tool security guide before expanding tool access.

Migration Playbook

1. Inventory the current contract. Record every prompt, parser, tool, model alias, limit, timeout, and fallback.
2. Create a fixed GPT-5.5 candidate. Use the exact model ID and explicit reasoning effort.
3. Run offline paired evaluation. Compare on identical inputs and authoritative oracles.
4. Shadow production traffic. Remove side effects and compare outputs, latency, and usage.
5. Canary by task class. Route a small, reversible slice rather than random high-impact traffic.
6. Keep the old model available. Roll back routing without rewriting prompts during an incident.
7. Re-baseline after any model or harness change. A new snapshot, tool, prompt, or evaluator creates a new experiment.

Do not migrate because a release table has a higher aggregate score. Migrate when your workload meets a predeclared quality, safety, latency, and cost gate.

Evidence Record Template

Decision: GPT-5.4 -> GPT-5.5 for repository maintenance
Model: gpt-5.5
API: Responses
Reasoning: medium
Dataset: repo-maintenance-v7
Harness: agent-harness-3.2
Tools: read, search, patch, test; no push
Primary oracle: tests + patch policy
Safety gate: zero unauthorized writes
Latency target: p95 <= 12 min
Cost target: <= $4 per successful task
Price table checked: 2026-10-03
Fallback: pinned GPT-5.4 route
Owner / expiry: platform-ai / 2026-11-03

An expiry date matters. Model documentation, pricing, safeguards, and successor recommendations change.

Sources

• Introducing GPT-5.5
• GPT-5.5 System Card
• GPT-5.5 model catalog
• Text generation with the Responses API
• Reasoning models
• OpenAI API pricing
• GPT-5.6 announcement

Conclusion

The useful GPT-5.5 story is not an unverified neural-architecture diagram. It is a dated, testable service contract: gpt-5.5, Responses API behavior, a one-million-token context limit, reasoning controls, measurable token economics, published provider evaluations, and explicit safeguards. Pin those facts, test them on your workload, and keep architecture rumors out of engineering decisions.