GPT-Image-2.5 Sunburst vs Flare vs GPT Image 2: Precision, Speed, API Routing, Token Pricing, and Rate Limits

Why this comparison starts with routing, not sticker price

GPT-Image-2.5 Sunburst, GPT-Image-2.5 Flare, and GPT Image 2 should not be evaluated as a simple “premium model costs more, cheaper model costs less” ladder. OpenAI’s published pricing page lists the same standard token rates for Sunburst, Flare, and GPT Image 2: text input at $5 per million tokens, cached text input at $1.25 per million tokens, image input at $8 per million tokens, cached image input at $2 per million tokens, and image output at $30 per million tokens. That means the operational question is not whether Sunburst has a higher listed per-token price than Flare; it does not, according to the published pricing table. The practical question is which model produces the acceptable asset fastest, with the fewest retries, at the right quality setting, inside the rate-limit envelope available to your organization.

OpenAI positions GPT-Image-2.5 Flare as the faster, everyday API choice for most applications and describes it as suitable for high-volume and rapid creative workflows. OpenAI positions GPT-Image-2.5 Sunburst for premium workflows where editing precision and tighter control matter more, while noting that Sunburst has longer generation times. GPT Image 2 remains the pricing baseline and established comparison point: OpenAI states that Sunburst and Flare use GPT Image 2 token rates, while also warning that the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption. That warning matters because token rates and realized per-image cost are not the same thing; actual cost depends on measured text input, image input, image output, quality, size, reference images, edit strategy, and retry behavior.

This DALL-E GPT retirement and ChatGPT Images migration guide explains how users preserved older image assets and moved workflows to the newer ChatGPT Images system, providing a product-history baseline for the Sunburst, Flare, and GPT Image 2 comparison. The complete How to Save Your DALL-E GPT Images Before August 30: Complete Migration Guide to ChatGPT Images article provides the destination-specific detail for this section’s OpenAI Image Models decision because the target is specifically about OpenAI image products and model-era migration, unlike the selected general language-model history article.

The 2.5 release also changes the way teams should think about model selection. OpenAI says Images 2.5 improves detail, natural lighting, textures, reference-subject preservation, targeted editing, multi-turn edit consistency, instruction following, real-world information, style control, and transparent-background generation. OpenAI also reports generation latency reduced by up to 50% versus Images 2.0, but that is a vendor-reported maximum and should not be treated as a universal service-level guarantee for every prompt, quality setting, image size, reference set, region, account tier, or production queue. For engineering teams, the right interpretation is: there is enough official positioning to justify a new routing policy, but not enough to skip your own acceptance tests.

The three-model baseline: what is documented, and what is not

OpenAI’s model pages document two new image models by explicit model ID. GPT-Image-2.5 Sunburst is available as gpt-image-2.5-sunburst, with default snapshot gpt-image-2.5-sunburst-2026-09-08. GPT-Image-2.5 Flare is available as gpt-image-2.5-flare, with default snapshot gpt-image-2.5-flare-2026-09-08. Both accept text and image input and output images. Both support the documented quality settings low, medium, high, xhigh, max, and auto. Both support image generations, image edits, and inpainting. Those shared capabilities make the comparison less about whether one model can technically perform an edit and more about which one clears your precision, latency, and review bar for a specific class of work.

GPT Image 2 is still important because it is the prior-generation reference point used in OpenAI’s pricing and release positioning. The pricing page lists GPT Image 2 at the same standard text, cached text, image input, cached image input, and image output token rates as Sunburst and Flare. OpenAI’s launch post compares Flare against GPT Image 2 by saying Flare delivers higher-quality images than GPT Image 2 at 50% lower latency for the API use case described by OpenAI. That statement should be attributed as OpenAI’s positioning, not converted into a universal benchmark for every application. A catalog thumbnail generator, a product-retouching pipeline, a character-consistency workflow, and a print-campaign approval process will experience different bottlenecks.

Why matching token rates still produce different production costs

Matching published token rates do not imply matching job cost. A model that takes the same rate per output token can still be more expensive in a real workflow if it requires more attempts, larger prompts, additional reference images, higher quality settings, more human review cycles, or downstream correction. Conversely, a model with longer generation time can be cheaper for a premium workflow if it reduces rejected drafts, preserves non-target regions better, and prevents manual retouching. The economic unit for production image systems is not “one request”; it is “one accepted asset that passes rights, brand, safety, and technical checks.”

A useful routing policy therefore measures at least four things per workflow: accepted-output rate, median and tail latency as observed by your system, actual token usage, and human review burden. For example, a product-marketing team may find that Flare is the best default for campaign concepts because reviewers only need broad composition and style direction in early rounds. The same team may route final product-photo edits to Sunburst because localized accuracy, preservation of the original subject, and fewer manual corrections matter more than speed. In both cases, the listed token rates can match while the total cost per accepted deliverable diverges.

OpenAI’s own documentation reinforces this distinction by warning that the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption. Teams should not take a historical GPT Image 2 per-image estimate, swap in a 2.5 model ID, and treat the result as a budget forecast. The safer procedure is to run a controlled sample with production-like prompts, reference images, quality settings, image sizes, and edit actions; record the usage returned by the API; and then calculate realized cost from actual token consumption. A pricing table tells you the rate schedule, not the consumption profile of your workflow.

API routing: direct Image API versus the Responses image-generation tool

OpenAI documents two routes for API image generation. The Image API is the direct path for single-prompt image generation or editing, where the request selects the image model directly as Sunburst or Flare. The Responses API route is for conversational or multi-step workflows, where a supported mainline model is selected at the top level and the image-generation tool’s model is set separately. This distinction is operationally important because Sunburst and Flare are image-generation models; the documentation does not make them ordinary text models for the top-level Responses text endpoint.

For a simple product-background replacement, the Image API may be the cleanest route: provide the source image, define the edit region or instruction, choose Flare or Sunburst, select quality and output parameters, and send the result to review. For a multi-step creative assistant that first gathers requirements, asks clarifying questions, compares brand constraints, and then generates or edits an image, the Responses API image-generation tool can keep the conversational workflow intact while still routing the image operation to the chosen image model. In that architecture, the top-level model handles reasoning and dialogue, while the image tool model handles rendering or editing.

This guide explains how to choose among GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna, and GPT-5.5 based on capability tiers, cost, latency, and use case fit. The complete The Complete GPT-5.5 and GPT-5.6 Model Selection Guide: Choosing Between Sol, Terra, Luna, and GPT-5.5 for Every Use Case article provides the destination-specific detail for this section’s AI Model Selection Framework decision because the marker calls for a model-selection framework, and this target is explicitly about choosing the right OpenAI model tier for different workloads.

OpenAI’s image-generation guide also notes that the image tool’s action can be auto, generate, or edit. Forcing edit without an image in context returns an error, so production systems should validate context before selecting the action. A practical safeguard is to store source image IDs, reference-image lineage, prompt versions, selected model, quality setting, and reviewer decision together. That record lets a team reproduce an approval path, investigate why a specific edit failed, and avoid silently routing a precision-sensitive job through the wrong model.

Quality settings are routing variables, not magic guarantees

Sunburst and Flare both support low, medium, high, xhigh, max, and auto. The presence of xhigh and max gives teams more explicit control over quality tradeoffs, but it does not guarantee flawless typography, perfect identity preservation, legally safe transformations, or error-free multi-turn editing. Quality settings should be treated as configuration variables in an evaluation matrix. If high already clears acceptance for internal thumbnails, moving every thumbnail to max may increase cost and latency without improving business outcomes. If a premium packaging image fails review because of texture, edge, or localized edit artifacts, testing xhigh or max may be justified.

A disciplined test plan should isolate quality from model choice. Run Flare and Sunburst with the same prompt, same source images, same output constraints, and the same quality setting before attributing differences to the model. Then vary quality settings within the model that performed best for the task. This prevents a common evaluation error: comparing Flare at a fast draft setting against Sunburst at a premium setting and concluding that all observed differences came from the model. The model, quality, input complexity, and acceptance criteria all interact.

Capacity and rate limits belong in the first design meeting

The Sunburst model page lists tiered rate limits from 100,000 to 8,000,000 tokens per minute and from 5 to 250 images per minute across tiers 1 through 5. OpenAI’s Flare model page lists matching text and image token rates and matching rate-limit tiers. These figures matter because image workloads often arrive in bursts: a marketplace may regenerate thousands of listing variants after a template change, a creative team may produce campaign contact sheets before a review meeting, and an enterprise content system may reprocess assets when brand rules change. A model that is ideal for one premium edit can still be the wrong default for a bursty pipeline if the organization’s images-per-minute ceiling becomes the bottleneck.

Rate-limit planning should separate prototype traffic, production traffic, retries, and human-triggered rework. If the application automatically retries failed generations without a hard cap, it can consume capacity that should be reserved for user-visible work. If an approval workflow allows reviewers to request unlimited variants, a small number of intense sessions can starve background jobs. The opening decision is therefore not only “Flare or Sunburst?” but also “which jobs deserve scarce image-per-minute capacity, which jobs can queue, and which jobs should degrade to a lower quality setting or later processing window?”

Safety, provenance, and acceptance testing remain part of model selection

OpenAI’s ChatGPT Images 2.5 system card states that higher realism can create more convincing deepfake risks and describes a safety stack that includes upstream LLM policy checks, input blocking, output blocking before images are shown, online and offline monitoring, and additional higher-risk evaluations. In OpenAI’s fixed automated adversarial evaluation, final unsafe outcomes were reported as 1.09% for Sunburst, 1.41% for Flare, and 1.64% for the Images 2.0 baseline. OpenAI notes that automated labels may contain errors, sample sizes affect precision, findings apply to the evaluated configuration, and no unsafe-shown difference reached the stated significance threshold. Those caveats are essential: the published safety results are not a promise of zero unsafe outputs in production.

OpenAI also states that provenance measures include C2PA metadata and an invisible SynthID watermarking layer across ChatGPT, Codex, and the OpenAI API, while explicitly saying that no single provenance mechanism is sufficient. For enterprise administrators and creative-production teams, provenance should be treated as one control in a larger governance stack. It can support disclosure, traceability, and platform policy, but it does not prove that an image is truthful, that a depicted event occurred, that the user owns the underlying source photo, or that all rights and consents are present. Routing policy must therefore include rights checks for reference images, restrictions on edits involving real people, human review for high-risk content, and archive records for prompts and approvals.

The opening decision rule

A practical starting rule is to route everyday generation, high-volume ideation, rapid creative drafts, and latency-sensitive application flows to Flare; route precision-sensitive edits, premium production assets, subject-preservation tasks, and localized changes with high rejection cost to Sunburst; keep GPT Image 2 as a measured incumbent baseline where existing workflows already depend on it. This rule is intentionally provisional. It should be replaced or refined once your team has measured acceptance rate, observed latency, actual token usage, reviewer effort, failure modes, and rate-limit behavior on production-like tasks.

The most expensive mistake is to optimize only for the published token rate when the published token rates match. The second most expensive mistake is to route every job to the model that sounds highest quality without checking whether the additional precision changes acceptance outcomes. The durable strategy is to define image categories, assign an initial model and quality setting to each category, run controlled evaluations, record actual usage, and revisit routing as prompts, asset types, and review standards evolve.

Capability map: choose the model, route, and state pattern before you tune prompts

The practical distinction between GPT-Image-2.5 Sunburst, GPT-Image-2.5 Flare, and GPT Image 2 is not a single “best model” ranking. OpenAI’s documentation separates three decisions that production teams often collapse into one: which image model renders or edits the image, which API route carries the request, and whether the workflow needs conversational state across turns. Treat those as separate configuration choices because a correct model choice can still fail operationally if it is routed through the wrong interface, loses prior image context, or assumes a quality setting that the selected model does not document.

OpenAI identifies the new 2.5 models by explicit model IDs. Sunburst is `gpt-image-2.5-sunburst`, with default snapshot `gpt-image-2.5-sunburst-2026-09-08`. Flare is `gpt-image-2.5-flare`, with default snapshot `gpt-image-2.5-flare-2026-09-08`. The official model pages state that both accept text and image input and output images. In production configuration files, record both the human routing label, such as “premium edit,” and the exact model ID, because a routing rule that only says “use Sunburst” is harder to audit when snapshots, quality settings, or evaluation results change.

GPT Image 2 remains the pricing and migration baseline in the official pricing material, but the supplied model-source set for this comparison gives the precise snapshot information only for Sunburst and Flare. That matters for change control: do not infer that GPT Image 2 shares the 2.5 snapshots, the new 2.5 quality vocabulary, or the same operational recommendations unless the relevant GPT Image 2 documentation for your integration states it. For this article’s routing matrix, GPT Image 2 is best treated as the incumbent image model family used for comparison against the documented 2.5 model pages and pricing rows.

This developer guide covers OpenAI’s Responses API for building multi-step agents with web search, file analysis, and computer-use capabilities. The complete The Complete Guide to OpenAI’s New Responses API: How to Build Multi-Step AI Agents with Web Search, File Analysis, and Computer Use Capabilities article provides the destination-specific detail for this section’s OpenAI Responses API Tools decision because it directly matches the Responses API tooling context and gives readers implementation-level detail beyond the current article’s API-routing discussion.

Feature matrix for production routing

Direct Image API calls: use when the job is a single image operation

OpenAI’s image-generation guide documents the Image API as the straightforward route for single-prompt generation or editing. In operational terms, that means a product thumbnail job, a hero-background concept, a localized banner edit, or a reference-image transformation can set the image model directly to Sunburst or Flare. This route is easier to reason about when the application already owns the prompt, the reference files, the output settings, and the acceptance checklist outside the model conversation.

A direct Image API request should make the routing intent visible in code or configuration. If the job is high-volume ideation, select Flare first and use measured pass rates to decide whether escalation is needed. If the job is a precision edit, subject-preservation task, or premium production asset, select Sunburst and budget for the longer generation profile that OpenAI associates with its precision positioning. Do not encode that distinction only in the prompt; the model ID is the actual routing control.

{
  "model": "gpt-image-2.5-flare",
  "prompt": "Generate three clean product-background concepts for a winter campaign using the approved palette and no visible text.",
  "quality": "high"
}

The request body above is a routing example, not a pricing estimate. The published token rates are per million tokens for text input, cached text input, image input, cached image input, and image output; the actual charge depends on measured token usage, input images, output settings, size, quality, and the final response. OpenAI also warns that the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption, so teams should collect usage data from their own 2.5 calls rather than adapting calculator outputs.

Responses image-tool routing: use when orchestration and state matter

OpenAI documents the Responses API image-generation tool for conversational or multi-step workflows. The critical architectural detail is that the top-level Responses model and the image-tool model are separate choices. A supported mainline model can manage the user request, inspect prior context, decide whether an image operation is needed, and call an image-generation tool whose model is separately set to Sunburst or Flare. The Sunburst or Flare model page does not make the image model an ordinary top-level text Responses model.

{
  "model": "<supported-mainline-responses-model>",
  "tools": [
    {
      "type": "image_generation",
      "model": "gpt-image-2.5-sunburst"
    }
  ],
  "input": "Using the approved reference image already in context, make only the background warmer and preserve the product, label, angle, and shadows."
}

This separation prevents a common integration mistake: setting the image model as though it were responsible for all text reasoning, policy explanation, campaign analysis, and tool orchestration. In a Responses workflow, the top-level mainline model handles the conversational control plane, while the image-generation tool performs the image operation. That design is especially useful when a user says, “Try two variants, keep the second one’s lighting, then remove only the distracting object on the left,” because the system can maintain context and choose image actions over multiple turns.

Multi-turn image state is useful, but it is not an edit guarantee

For multi-turn work, OpenAI’s image-generation guide states that Responses can use image-generation outputs or image IDs in context, or continue using `previous_response_id`. That is an important state-management capability for creative review sessions, but it should not be treated as a mathematical guarantee that every pixel, identity cue, brand mark, or non-target region will remain unchanged. Production teams should retain source references, generated image IDs, prompt versions, masks where applicable, and human acceptance notes so a later edit can be compared against the approved baseline.

A reliable multi-turn image workflow should define the state object before the first render. For example, a commerce team can store the original product reference, the accepted first-generation image ID, the edit instruction, the intended protected regions, the requested quality setting, the selected model, and the reviewer’s pass/fail criteria. That record makes it possible to distinguish a model-quality issue from a prompt ambiguity, a lost context issue, or a reviewer changing requirements midstream.

The `action` field: let the tool decide, or force generation and editing deliberately

OpenAI’s guide documents image-tool `action` values of `auto`, `generate`, and `edit`. In a product UI, `auto` is appropriate when the user’s instruction may require either a new image or an edit to existing context, and the top-level model is allowed to choose the operation. Use `generate` when the job must produce a new image rather than mutate an existing one. Use `edit` only when the workflow has an image in context and the user’s intent is a targeted change.

The operational warning is explicit in the documentation: forcing `edit` without an image in context returns an error. That makes `edit` a state-dependent action, not merely a stylistic preference. Before submitting an edit request, validate that the required image output, uploaded reference, or image ID is available in the current context or via `previous_response_id`. If your application lets users clear the conversation, replace an image, or branch from an earlier version, treat those UI actions as changes to edit eligibility.

{
  "tool_choice": {
    "type": "image_generation",
    "action": "edit"
  },
  "input": "Change only the mug color to matte black. Preserve the logo, handle shape, background, perspective, and lighting."
}

The edit example demonstrates the level of specificity reviewers should require for precision work. It names the target change, lists protected regions, and avoids asking the model to reinterpret the whole composition. Even with Sunburst, higher quality settings, and a clear edit instruction, teams should inspect the result for unintended changes to identity, logos, labels, text, shadows, object geometry, and brand compliance before approving the asset.

Six quality settings are controls, not promises

Sunburst and Flare both document six quality settings: `low`, `medium`, `high`, `xhigh`, `max`, and `auto`. The new `xhigh` and `max` settings expand the tuning surface for teams that need premium output, but they should be tested against actual prompts and acceptance criteria. OpenAI’s release language describes improvements in detail, lighting, textures, reference-subject preservation, targeted editing, multi-turn consistency, instruction following, style control, and transparent-background generation; it does not claim flawless text rendering, perfect identity preservation, or error-free edits.

A practical policy is to map quality to review risk. Use `low` or `medium` for rough ideation where speed and breadth matter. Use `high` for normal production candidates. Reserve `xhigh` or `max` for assets where additional rendering effort is justified by expected value, such as paid campaign imagery, executive creative review, high-resolution product concepts, or edits that previously failed at lower settings. Use `auto` when the application intentionally delegates that trade-off, but log it because finance and QA cannot later infer which quality setting was chosen from the prompt alone.

Organization verification and entitlement checks belong before integration testing

OpenAI’s image-generation guide notes that organization verification may be required. Administrators should treat that as a launch dependency rather than a support-ticket footnote. Before engineering schedules load tests or creative teams schedule a campaign migration, verify that the organization, project, billing posture, and allowed routes can access the intended Image API or Responses image-tool flow. A failure at this layer can look like a code bug even when the request body and model ID are correct.

For enterprise administrators, the minimum readiness checklist is short but consequential: confirm organization verification status where required, confirm the exact model IDs permitted for the project, confirm the intended API route, record applicable TPM and IPM limits, validate retry behavior for rate and overload errors, and document who can change routing defaults. This checklist prevents a common governance failure in which a prototype quietly uses Flare, a production job later switches to Sunburst, and no one has updated capacity assumptions, review time, or acceptance criteria.

Recommended routing policy for capability-first deployments

Recommended workflow: make Flare the first route for everyday generation, internal ideation, high-volume variant creation, and rapid creative exploration. Escalate to Sunburst when the job is precision-sensitive, involves targeted edits, requires tighter reference preservation, or has a high cost of reviewer rejection. Keep GPT Image 2 available only where continuity, existing batch economics, or established regression baselines justify staying with the incumbent route; do not keep it merely because the token rates appear familiar.

Recommended engineering pattern: define a routing object that contains `route_type`, `top_level_model`, `image_tool_model`, `direct_image_model`, `quality`, `action`, `state_source`, and `acceptance_profile`. In direct Image API calls, `direct_image_model` is the main control. In Responses workflows, `top_level_model` and `image_tool_model` must both be set deliberately. For multi-turn edits, `state_source` should identify whether the request depends on an image ID, prior generated output, uploaded reference, or `previous_response_id`.

{
  "route_type": "responses_image_tool",
  "top_level_model": "<supported-mainline-responses-model>",
  "image_tool_model": "gpt-image-2.5-sunburst",
  "quality": "xhigh",
  "action": "edit",
  "state_source": "previous_response_id plus approved image ID",
  "acceptance_profile": "localized product edit; preserve logo, geometry, shadows, and background"
}

This routing object is deliberately more verbose than a prompt because production image generation is not only a language task. It is a controlled transformation with cost, capacity, rights, safety, provenance, and reviewer-acceptance implications. Sunburst, Flare, and GPT Image 2 can then be compared on measurable outcomes: pass rate by task class, token usage by accepted asset, retry rate, reviewer correction count, latency distribution observed by your application, and the percentage of jobs that require escalation from Flare to Sunburst.

Economics and evaluation: measure tokens, capacity, latency, quality, and safety together

OpenAI’s pricing pages create an important operational surprise: GPT-Image-2.5 Sunburst, GPT-Image-2.5 Flare, and GPT Image 2 have the same published standard token rates. That means an application team should not route to Flare because it is cheaper per token, or to Sunburst because it has a different premium token schedule. The documented cost levers are actual text input tokens, cached text input tokens, image input tokens, cached image input tokens, image output tokens, quality setting, size, source images, and how many attempts are needed before an asset is accepted.

This pricing guide explains the GPT-5.6 Sol, Terra, and Luna API pricing structure and how developers can choose a tier based on budget and workload needs. The complete The Complete Guide to GPT-5.6 Sol, Terra, and Luna API Pricing — Choosing the Right Tier for Your Budget article provides the destination-specific detail for this section’s Multimodal API Pricing decision because although focused on GPT-5.6 rather than image generation specifically, it is the strongest allowed match for token-based API pricing and tier-selection economics.

Documented token rates for Sunburst, Flare, and GPT Image 2

OpenAI lists the same standard token rates for GPT-Image-2.5 Sunburst, GPT-Image-2.5 Flare, and GPT Image 2: text input at $5 per million tokens, cached text input at $1.25 per million tokens, image input at $8 per million tokens, cached image input at $2 per million tokens, and image output at $30 per million tokens. The useful comparison is therefore not “which 2.5 model has the lower token price,” but “which route produces an accepted asset with fewer attempts, less elapsed time, and acceptable policy and provenance handling.”

A practical budget formula should multiply measured token consumption by the documented rate category, then add retry and rejection effects. A campaign that generates ten drafts and accepts one has a different effective asset cost than a workflow that generates two drafts and accepts one, even if both use the same model and the same list price. A precision model can be economically preferable for a narrow editing task if it reduces rejected attempts, while a faster model can be preferable for broad ideation if human reviewers need many visual directions quickly.

Recommended cost ledger per job:
  text_input_cost        = measured_text_input_MTOK * 5
  cached_text_cost       = measured_cached_text_input_MTOK * 1.25
  image_input_cost       = measured_image_input_MTOK * 8
  cached_image_cost      = measured_cached_image_input_MTOK * 2
  image_output_cost      = measured_image_output_MTOK * 30
  total_generation_cost  = sum(all categories across all attempts)
  accepted_asset_cost    = total_generation_cost / number_of_accepted_assets

This formula is intentionally not a fixed per-image estimate. OpenAI warns that the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption, so teams should not use that calculator as a proxy for Sunburst or Flare. For 2.5 models, the only defensible estimate comes from representative jobs, measured token use, the documented token rates, and the number of attempts required to reach approval.

Batch economics require the same caution. OpenAI’s pricing information lists Batch pricing for GPT Image 2 and older models, but the supplied official pricing notes do not list Batch pricing for GPT-Image-2.5 Sunburst or GPT-Image-2.5 Flare. Procurement spreadsheets should therefore keep 2.5 Batch cells blank or marked “not listed in the official pricing source,” rather than assuming GPT Image 2 Batch terms automatically extend to the 2.5 models.

Rate limits: Sunburst and Flare match on documented tier ranges

OpenAI’s Sunburst and Flare model pages show matching rate-limit structures. The supplied official notes state that Tier 1 through Tier 5 limits range from 100,000 to 8,000,000 tokens per minute and from 5 to 250 images per minute. That range matters because image systems can be constrained by either token throughput or image count. A small number of high-quality, reference-heavy edits can pressure TPM, while a bursty thumbnail generator can hit IPM first.

The capacity design should separate three controls: request admission, model routing, and human review availability. If reviewers can only approve 40 assets per hour, sending 250 images per minute into a queue may increase storage and review debt without improving publishing throughput. If a checkout page generates personalized visuals, a lower IPM tier may require pre-generation, caching of stable assets, or a fallback to non-personalized creative rather than uncontrolled retries.

Latency evaluation: measure elapsed time by task class, not only by model

OpenAI reports generation latency reduced by up to 50% versus Images 2.0 for Images 2.5, and positions Flare as the faster everyday API option while positioning Sunburst for precision-sensitive work with longer generation times. Those are vendor claims and routing descriptions, not guarantees that every prompt, quality setting, edit, or reference-image workflow will see the same reduction. A credible latency test must measure your own request shapes.

Recommended latency instrumentation should record request start time, first successful response time, final asset availability time, model, route, quality setting, generation versus edit action, number of input images, prompt length, output format, retry count, and terminal error state. For the Responses API image-generation tool, log the top-level model separately from the image tool model, because those are distinct routing choices. For direct Image API calls, log the image model directly and keep prompt versions immutable.

Acceptance-rate evaluation: count approved assets, not attractive failures

The strongest economic metric is accepted assets per unit of cost and time. A beautiful image that changes a real person’s identity, damages a product logo, misplaces required text, or violates brand rules is a rejected output. Evaluation should therefore use explicit pass/fail rubrics rather than reviewer vibes. Each test item should have a task brief, permitted transformations, protected regions, required text, disallowed changes, safety notes, and a reviewer checklist.

This article explains how to measure AI output quality using KPIs, guardrails, and stop conditions across generated text, images, code, and other content types. The complete Measuring AI Output Quality: KPIs, Guardrails, And ‘Stop’ Conditions article provides the destination-specific detail for this section’s AI Image Quality Evaluation decision because it directly supports the image-quality evaluation marker by covering practical quality metrics and guardrails for AI-generated outputs, including images.

For each candidate model and route, run the same prompt pack across a balanced set of tasks: net-new generation, simple edit, inpainting, reference-subject preservation, multi-turn refinement, text-bearing design, transparent-background asset, and complex composition. Keep the prompt and references constant within a comparison cell. If a reviewer changes the prompt after seeing an output, record that as a new attempt rather than silently folding it into the same trial.

Identity and edit-locality tests require rights discipline. The reviewer should confirm that every reference image is owned by the organization, licensed for the test, or otherwise authorized for distribution and transformation. The test prompt should state the permitted transformation and explicitly protect identity, non-target regions, logos, product geometry, and sensitive marks. If the test uses a person’s likeness, the approval record should separate visual quality from consent and distribution authorization.

Safety evaluation: use OpenAI’s system-card figures as vendor evidence with boundaries

OpenAI’s ChatGPT Images 2.5 system card reports final unsafe outcomes of 1.09% for Sunburst, 1.41% for Flare, and 1.64% for the Images 2.0 baseline in a fixed automated adversarial evaluation. Those figures should be treated as OpenAI’s vendor evaluation for the evaluated configuration, not as a promise that a production deployment will have the same rates or that unsafe outputs cannot occur. OpenAI notes that the adversarial test set was designed to elicit policy violations and is not representative of ordinary production traffic.

The system card also states that automated labels may contain errors, sample sizes affect precision, findings apply to the evaluated configuration, and no unsafe-shown difference reached OpenAI’s stated significance threshold. For enterprise evaluation, that means the figures can inform risk review but should not replace an application-specific safety test. A children’s education app, a political-content workflow, a medical-communications team, and an entertainment poster generator have different risk surfaces even when they use the same model.

OpenAI reports that neither Sunburst nor Flare crossed its Bio High or Cyber High thresholds in adapted capability assessments, while also applying precautionary biological-risk mitigations. That combination should be read carefully: the published assessment is not a zero-risk guarantee, and the mitigations do not remove the need for product policy, logging, reviewer escalation, and abuse monitoring in higher-risk domains.

Provenance should be evaluated as a separate operational control. OpenAI says its provenance measures include C2PA metadata and an invisible SynthID watermarking layer across ChatGPT, Codex, and the OpenAI API, and explicitly states that no single provenance mechanism is sufficient. Your acceptance checklist should therefore verify that provenance signals are preserved where expected, but it should not treat C2PA or SynthID as proof of copyright ownership, consent, factual truth, or absence of manipulation.

A recommended evaluation set for model routing

A compact but useful first evaluation set contains 120 tasks: 30 everyday generations, 20 high-volume concept prompts, 20 precision edits, 15 identity-preservation edits, 15 text-bearing assets, 10 complex compositions, and 10 safety/provenance stress cases. Run each task against the current production baseline, Flare, and Sunburst where the route is supported and relevant. Keep GPT Image 2 in the matrix if it is already deployed, because the migration decision should compare real acceptance rates, real latency, real token consumption, and reviewer effort.

Each test result should store the model, snapshot if recorded by the integration, route, quality setting, prompt version, source image identifiers, reviewer, acceptance status, rejection reasons, measured latency, retry count, and measured token categories. The evaluator should classify failures using a controlled vocabulary: identity drift, non-local edit, text error, composition error, policy concern, provenance concern, brand mismatch, low fidelity, wrong action, timeout, rate-limited, or other terminal error. Controlled labels make weekly routing reviews more useful than screenshots in a shared folder.

Recommended routing metric:
  accepted_assets_per_hour =
    accepted_assets / total_elapsed_review_and_generation_hours

Recommended economic metric:
  accepted_asset_cost =
    total_measured_generation_cost / accepted_assets

Recommended precision metric:
  local_edit_pass_rate =
    tasks_with_requested_region_changed_and_protected_regions_preserved
    / completed_precision_edit_tasks

The final route should be chosen by task class, not by a single global winner. Use Flare as the default candidate for fast everyday generation and high-volume creative exploration because OpenAI positions it that way. Use Sunburst as the default candidate for premium edits where identity preservation, localized changes, and instruction precision are more important than generation time. Keep GPT Image 2 in the comparison until your measured acceptance, latency, token, and safety records justify migration for each production workflow.

Production routing framework: turn the comparison into operating rules

The practical decision is not “which model is best?” but “which route should this task take, what evidence would promote it, and what happens when it fails?” OpenAI positions GPT-Image-2.5 Flare as the faster everyday/default API choice for most image-generation applications, while GPT-Image-2.5 Sunburst is intended for precision-sensitive and premium editing workflows with longer generation times. Because Sunburst, Flare, and GPT Image 2 share the same published standard token rates, the routing policy should be based on task class, measured token usage, acceptance rate, latency, rate-limit pressure, and review burden rather than an assumed per-token discount.

This Codex image-generation playbook shows how developers incorporate visual assets into UI mockup and design-prototyping work, providing a concrete production workflow in which speed, edit precision, retries, and human acceptance can guide model routing. The complete How to Use Codex Image Generation for UI Mockups and Design Prototyping: Complete Developer Playbook article provides the destination-specific detail for this section’s Production AI Image Pipeline decision because the target is an actual AI image production workflow and is much closer to the marker than the selected coding-agent CI/CD case study.

Recommended routing rules by production job

Completed-task-cost formula for real production accounting

Do not calculate a fixed per-image price without measured usage. OpenAI’s pricing page lists the same standard token rates for Sunburst, Flare, and GPT Image 2: text input at $5 per million tokens, cached text input at $1.25 per million tokens, image input at $8 per million tokens, cached image input at $2 per million tokens, and image output at $30 per million tokens. OpenAI also warns that the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption, so finance teams should calculate costs from actual usage records rather than from assumed image counts.

completed_task_cost =
  sum_over_attempts(
    (text_input_tokens / 1,000,000) * text_input_rate
  + (cached_text_input_tokens / 1,000,000) * cached_text_input_rate
  + (image_input_tokens / 1,000,000) * image_input_rate
  + (cached_image_input_tokens / 1,000,000) * cached_image_input_rate
  + (image_output_tokens / 1,000,000) * image_output_rate
  )
  + internal_review_cost
  + rework_cost
  + storage_and_delivery_cost

This formula intentionally counts every attempt that contributed to the completed task, not only the final approved image. A cheap-looking route can become expensive if it requires many rejected generations, repeated edits, or manual repair. A slower Sunburst route can be cheaper for a product-edit class if it reduces rework and approval cycles. The decision metric should therefore be cost per accepted task, not cost per raw generation.

Model-promotion gate: when Flare output earns Sunburst finishing

A model-promotion gate prevents teams from sending every task to the most controlled route by habit. The gate should be expressed as measurable conditions that an asset must satisfy before escalation. This keeps high-volume systems fast while reserving Sunburst for the work that benefits from tighter editing precision.

1. Rights gate: Confirm that the user owns or is authorized to use and distribute every reference image, product photo, likeness, logo, or brand element involved in the task.
2. Task-value gate: Mark the asset as paid media, product-commerce, executive-facing, customer-specific, regulated, or otherwise high value.
3. Defect-class gate: Identify the remaining issue as localized editing precision, subject preservation, product accuracy, transparent-background cleanup, or multi-turn consistency rather than broad ideation.
4. Acceptance-history gate: Check whether Flare attempts for this task class meet the team’s measured approval threshold. If they do, keep the task on Flare unless precision defects remain.
5. Capacity gate: Verify that Sunburst rate-limit headroom and review staffing are available before promotion, because a premium route that queues for too long can miss campaign deadlines.
6. Audit gate: Record the source asset ID, prompt version, model, quality setting, output format, reviewer, and approval decision before the promoted attempt is made.

A practical promotion rule is: use Flare until the creative direction is accepted, then use Sunburst only for final edits where the acceptance criteria name specific regions that must change and specific regions that must not change. This rule follows OpenAI’s positioning without assuming that either model guarantees perfect text, identity preservation, or edit isolation.

Retry, fallback, and terminal-failure policy

Retries should protect user experience without hiding systemic failures or multiplying cost. OpenAI’s September API behavior notes distinguish traffic that increases too quickly from temporary model overload: a 429 response can include code slow_down, and a 503 response can include code server_is_overloaded. Either may include Retry-After; when it is present, clients should wait at least that long. When it is absent, use exponential backoff with jitter, a small retry limit, and request tracing.

recommended_retry_policy:
  if response has Retry-After:
    wait at least Retry-After
  else:
    wait exponential_backoff_with_jitter

  retry only if:
    request is safe to replay
    idempotency or duplicate-suppression is in place
    attempt_count is below policy limit
    user deadline has not expired

  stop and surface terminal failure if:
    policy violation or rights failure occurs
    edit requires missing image context
    repeated overload exceeds retry budget
    output fails mandatory human review

Fallbacks should preserve task intent rather than silently changing quality expectations. For a high-volume creator job, a reasonable fallback is to reduce concurrency, queue the task, or return a “delayed generation” state instead of promoting every failed Flare request to Sunburst. For a precision product edit, falling back from Sunburst to Flare should require explicit acceptance that the result may not meet the same edit-control target. For a campaign asset, the safest fallback is often to use the last approved image from the asset manifest rather than generate a new unreviewed replacement under time pressure.

Observability fields every image attempt should record

Production image routing needs a record that can explain why an asset was created, which route produced it, how much it cost, whether it was approved, and how it can be rolled back. The fields below are recommendations for an internal log schema; they do not describe an OpenAI API response contract.

Human review and rollback rules

Human review should be mandatory whenever an output contains a real person, a product representation, a trademark, a medical or safety implication, a political or news-adjacent context, or a paid campaign claim. OpenAI’s Images 2.5 system card describes safeguards, C2PA metadata, and an invisible SynthID watermarking layer, but OpenAI also states that no single provenance mechanism is sufficient. Treat provenance as an audit signal, not as proof of truth, ownership, consent, or legal clearance.

Rollback should be a first-class product feature, not an emergency script. Keep the last approved asset, source references, prompt version, output settings, review notes, and export manifest. A rollback is required when a new route changes non-target regions in a product edit, reduces brand compliance, breaks channel specifications, loses required transparency or compression settings, introduces unacceptable safety risk, or increases cost per accepted task beyond the team’s threshold. The rollback record should explain whether the failure came from model choice, quality setting, prompt change, missing image context, rate-limit pressure, or review-policy mismatch.

Conclusion: the durable routing policy is measured, not assumed

Sunburst, Flare, and GPT Image 2 should be managed as production routes with different operating roles, not as a simple quality ladder. Flare is the sensible default for fast everyday generation and high-volume creative exploration. Sunburst belongs where precision-sensitive editing, premium finishing, or product accuracy justifies longer generation times and stricter review. GPT Image 2 remains relevant as the baseline comparison point for pricing and legacy workflow evaluation, but OpenAI’s documentation says the GPT Image 2 calculator does not estimate GPT Image 2.5 token consumption.

The strongest teams will record every attempt, calculate cost from actual token usage, measure acceptance rate by task class, separate Image API calls from Responses image-tool orchestration, and keep human review close to rights-sensitive and brand-critical work. That evidence turns routing from a preference debate into an operational control system.

Useful Links

• Introducing ChatGPT Images 2.5
• GPT-Image-2.5 Sunburst model documentation
• GPT-Image-2.5 Flare model documentation
• OpenAI image generation guide
• OpenAI API pricing
• ChatGPT Images 2.5 system card