GPT-Image-2.5 in Production: Default to Flare, Escalate to Sunburst

I’d treat GPT-Image-2.5 as a routing decision, not a blanket model upgrade. Flare is the sensible default for interactive generation. Sunburst is the precision tier for requests where preserving details matters more than returning quickly.

OpenAI announced the family on September 8, 2026, succeeding ChatGPT Images 2.0 and the GPT-Image-2 API generation. The naming has two layers:

• ChatGPT Images 2.5 is the experience inside ChatGPT.
• GPT-Image-2.5 is the model family, exposed through gpt-image-2.5-flare and gpt-image-2.5-sunburst.

The interesting upgrade isn’t just image quality. It’s the ability to change an asset without accidentally rebuilding everything around the requested edit: subject preservation, localized changes, and consistency across revisions.

Here’s how I’d evaluate the models, budget requests, and decide where each belongs.

Start with the workload, not the leaderboard

Flare and Sunburst share the generation’s core capabilities, but optimize different constraints.

Constraint	Flare	Sunburst
Main priority	Fast, high-quality generation at scale	Maximum generation and editing precision
Latency	Faster; suited to interactive use	Slower; trades time for fidelity
Typical workloads	Social assets, prototypes, visual search, batch generation	Campaign creative, product hero images, difficult edits
Reference editing	Improved fidelity and multi-turn consistency	Precision-focused option for preserving details
My routing choice	Default	Escalation tier

For a consumer-facing editor, I’d start with Flare. Users making background changes or exploring variations benefit from fast feedback. For a final campaign asset or a difficult reference-based revision, I’d make Sunburst available explicitly.

That distinction also prevents a common budgeting mistake: Flare does not have a lower official token rate than Sunburst. Its economic advantage is primarily speed and throughput, not cheaper tokens.

Image 2 still has a place in established integrations. It supports custom dimensions, 4K-class output, and transparent backgrounds too. The reasons to move are the newer family’s quality, editing behavior, and—particularly with Flare—latency, rather than those output features alone.

What actually changes in an editing pipeline

I care less about a model producing one impressive image than about what happens after the third revision. A useful editor must distinguish between “change this” and “leave everything else alone.”

Reference images become more useful constraints

OpenAI reports improved reference-image fidelity and precision editing. Subjects should remain more recognizable while clothing, lighting, environments, composition, or style change.

That matters for workflows such as:

• Replacing a product background without changing the product.
• Generating campaign variations around the same character.
• Changing an outfit while preserving identity and pose.
• Exploring compositions derived from an existing asset.

OpenAI’s “Remixed baby portrait” example illustrates the intended behavior: change the outfit while retaining the pose and blue studio background.

Official input image from OpenAI.

Official edited output from OpenAI.

I’d still test preservation against my own assets. A convincing example establishes the capability, not a guarantee that every product label or facial detail will survive every transformation.

Local edits should stop disturbing unrelated elements

Consider a product image containing a bottle, logo, headline, props, and shadows. Replacing the headline should not also change the bottle geometry or camera angle.

GPT-Image-2.5 improves this separation between editable and fixed content. Sunburst is the stronger candidate when a localized change has to preserve the surrounding asset closely.

For an editing product, this is more consequential than a small improvement in standalone text-to-image preference. Unrequested changes create review work and additional generation attempts.

Multi-turn consistency is the workflow upgrade

A realistic sequence might be:

1. Generate a product scene.
2. Replace the background.
3. Reposition the product.
4. Change the headline.
5. Add a promotional badge.
6. Adjust the lighting.
7. Export a transparent version.

Weaker models can gradually lose details established earlier. GPT-Image-2.5 is designed to make previous changes more persistent across turns.

I’d evaluate complete revision sequences, not just independent edits. Single-turn performance doesn’t tell me whether the final asset still matches the product and composition approved several requests earlier.

Realism and instruction following also improve

OpenAI reports more natural lighting and richer material textures. These changes are relevant to skin, fabric, glass, metal, packaging, furniture, food, and environmental photography.

The family also improves handling of complex instructions: multiple objects, relative positions, headlines, brand colors, perspective, foreground/background relationships, transparent areas, and exclusions.

That makes structured creative briefs more useful. It does not make natural-language positioning equivalent to a layout engine.

Output controls worth exposing in your application

Both models support these quality settings:

• low
• medium
• high
• xhigh
• max
• auto

The additions are xhigh and max; earlier GPT Image models topped out at high. I’d expose quality separately from model choice so the application can evaluate the latency-versus-fidelity tradeoff rather than treating “Sunburst” as a universal quality switch.

Custom dimensions have explicit limits

The image-generation documentation permits valid WIDTHxHEIGHT dimensions, with these constraints:

Property	Limit
Total output pixels	Up to 8,294,400
Individual edge	Up to 3840 pixels
Width and height alignment	Multiples of 16
Experimental resolution range	Above 2560×1440

This supports 4K-class pixel counts without restricting every request to a short list of aspect ratios.

It is useful for ad placements, thumbnails, presentation graphics, e-commerce assets, and UI components. But “supported dimensions” and “production-tested configuration” are different things. I’d test the exact high-resolution sizes my application intends to offer, especially above 2560×1440.

Transparency requires the right format

Both variants support transparent backgrounds with PNG or WebP output. The relevant settings are:

background="transparent"
output_format="png"

These are configuration values, not a complete API request. The important constraint is the format: transparent output should use PNG or WebP.

Native transparency is useful for isolated products, stickers, overlays, presentation assets, and compositing pipelines.

Read the benchmarks as evidence, not a deployment policy

There is no single image score that captures aesthetics, prompt adherence, reference fidelity, text rendering, and edit precision.

The available evidence falls into three separate buckets: human preference, latency, and safety evaluation. I wouldn’t combine them into one “best model” number.

Text-to-image preference

Arena’s text-to-image leaderboard uses blind comparisons: users see outputs from two anonymous models for the same task and choose their preference.

The preliminary September 9 snapshot reports:

Model	Text-to-image Elo	Rank	Votes
Sunburst	1421 ± 13	1	3,149
Flare	1399 ± 13	2	2,856
Image 2 (medium)	1381 ± 4	3	78,731
MAI Image 2.6	1331 ± 7	4	11,213
Grok Imagine Image 2.0 (low)	1315 ± 12	5	2,681

Both new variants rank ahead of Image 2 in this snapshot. Sunburst leads, but the vote counts and uncertainty intervals belong beside the scores, not hidden beneath them.

Single-image editing preference

The editing results show the same ordering:

Model	Single-image edit Elo	Difference versus Image 2
Sunburst	1520 ± 9	+59
Flare	1491 ± 9	+30
Image 2	1461 ± 3	Baseline
Grok Imagine Image 2.0	1439 ± 8	-22
MAI Image 2.6	1434	-27

Sunburst’s lead over Image 2 is larger in editing than in text-to-image generation. That fits its precision-oriented positioning.

For my own evaluation, I’d keep prompts, references, dimensions, and quality settings controlled, then measure edit accuracy and accepted-output rate alongside latency and token usage. A preference leaderboard is a useful starting point, but my application may care disproportionately about a specific failure mode.

Latency claims favor Flare

OpenAI says the generation reduces image-generation latency by up to 50% versus Images 2.0. For the API specifically, it positions Flare as producing higher-quality images than Image 2 with 50% lower latency.

Sunburst intentionally spends more generation time on precision.

I’d treat those as vendor measurements, not a latency guarantee for every prompt and output configuration. Complex requests can still take substantial time, so loading states, timeouts, transient-failure retries, and asynchronous batch handling remain necessary.

Safety results measure a different thing

OpenAI’s safety evaluation uses adversarial prompts designed to request policy-violating images.

Model	Safe generated	Unsafe blocked	Unsafe presented
Sunburst	77.0%	21.9%	1.09%
Flare	79.4%	19.2%	1.41%
ChatGPT Images 2.0 baseline	75.2%	23.1%	1.64%

Relative to the 1.64% baseline, unsafe outcomes fall by 0.55 percentage points for Sunburst and 0.23 percentage points for Flare.

These are safety-stress-test results. They are neither general image-quality scores nor estimates of what normal application traffic will produce.

Budget by token category, not the model’s positioning

OpenAI publishes identical unit rates for both variants:

Token category	Flare	Sunburst
Text input	$5 / 1M tokens	$5 / 1M tokens
Cached text input	$1.25 / 1M tokens	$1.25 / 1M tokens
Image input	$8 / 1M tokens	$8 / 1M tokens
Cached image input	$2 / 1M tokens	$2 / 1M tokens
Image output	$30 / 1M tokens	$30 / 1M tokens

For an uncached reference-image editing request, the calculation is:

request_cost =
    text_input_tokens  * 5  / 1_000_000
  + image_input_tokens * 8  / 1_000_000
  + image_output_tokens * 30 / 1_000_000

Cached inputs use their separate rates when applicable. There isn’t enough information in a headline token price to quote a universal per-image cost.

Flare can still improve workflow economics: less waiting, fewer long-running requests occupying infrastructure, faster iteration, and potentially fewer abandoned attempts. Those effects should be measured rather than confused with a unit-price discount.

Where a unified API fits

For teams already using a unified multi-model API, CometAPI exposes both variants through /v1/images/generations and /v1/images/edits, with shared authentication and billing; routing can switch the model field between gpt-image-2.5-flare, gpt-image-2.5-sunburst, and the previous gpt-image-2 without rebuilding the surrounding integration.

Its displayed headline pricing is the same for both new variants:

Model ID	Headline input / 1M tokens	Headline output / 1M tokens	Matching official input/output
gpt-image-2.5-flare	$4	$24	$5 / $30
gpt-image-2.5-sunburst	$4	$24	$5 / $30

That is a 20% headline discount, not a complete accounting of every token category. In particular, image input and cached inputs need separate attention when budgeting editing workloads.

I’d confirm the live catalog before deployment and use returned usage data for cost comparisons. The operational benefit of a shared integration is controlled experimentation and routing, not a reason to ignore category-specific billing.

Where I’d use each model

Flare: responsive tools and repeated exploration

Flare is my starting point for:

• Social-content generators, memes, personalized thumbnails, and profile assets.
• Consumer image applications and interactive editors.
• High-volume automated content pipelines.
• Visual-search result generation.
• Prototyping app screens, websites, packaging, interiors, and ad layouts.

These workloads often value iteration speed more than the last increment of image preference.

Sunburst: expensive-to-review final assets

I’d prioritize Sunburst for:

• Product hero images and premium product photography.
• Campaign variants that must preserve a master composition.
• Demanding reference-image edits.
• Difficult multi-step revisions.
• Final assets where unintended changes trigger substantial review work.

Product photography and campaign creative benefit particularly from preserving a product while changing lighting, backgrounds, promotional text, shadows, regional treatment, or language.

For user-uploaded-photo applications—outfit changes, interior redesign, headshot variations, background replacement, and retouching—I’d test both. Preservation may matter more than standalone generation quality, but interactive latency still affects the product.

Keep deterministic work outside the generator

The improvements don’t remove the need for quality control.

Verify generated text. Advertisements, packaging, menus, legal copy, and UI screenshots still need review. Better text rendering does not make every string reliable.

Compose pixel-critical layouts separately. “Place the logo exactly 40 pixels from the top-left corner” is not a deterministic constraint. I’d generate the visual asset, then place exact text and interface elements programmatically or in a design tool.

Check consistency across the whole sequence. Characters and branding can still drift over repeated generations. Improved multi-turn behavior is not perfect preservation.

Test experimental resolutions explicitly. The 8,294,400-pixel ceiling and 3840-pixel edge limit do not mean every high-resolution configuration behaves identically.

Build for long-running work. Even the faster model needs appropriate request handling. Batch pipelines should not depend on an optimistic synchronous happy path.

My default deployment policy

I’d ship Flare as the default, expose Sunburst for precision-sensitive generation and final edits, and retain Image 2 where an existing workflow depends on its established behavior.

Then I’d compare actual revision sequences using the same references, prompts, dimensions, and quality settings. The decision metrics would be latency, token consumption, edit accuracy, and accepted-output rate—not just which model produced the most attractive first image.

Sunburst currently leads the reported preference benchmarks. Flare offers the more practical speed profile for many applications. The useful architectural choice is to support both roles without making every request pay the latency cost of the precision tier.