GPT-Image-2.6: Flare, Sunburst and the Complexity Dial

Posted on by
Contents show
GPT-Image-2.6

Image generation has crossed from novelty into infrastructure. OpenAI now counts more than 4 billion images created per week across ChatGPT, Codex and the API, over half a billion per day, up from 3 billion per week just eight weeks earlier. At that volume, the interesting questions stop being what a model can draw and start being how fast, how controllably, and at what price per unit of control. GPT-Image-2.6 is the newest entry in that utility race, and the most instructive to take apart.

Images 2.6, shipping now in ChatGPT, Codex and the API, is GPT-Image-2.6's answer, and it reads less like a model release than an operations manual. The API release splits into two models, GPT-Image-2.6 Flare for fast iteration and GPT-Image-2.6 Sunburst for detailed compositions and edit consistency, and GPT-Image-2.6's pricing keeps them identical per token. Generation is 50 percent faster than before. New output formats arrive, animated GIF and SVG. And a new complexity parameter lets developers dial how much the model plans before it renders.

This article unpacks the two models, the new controls, the token pricing that hides behind a missing per-image table, and where this release sits against Google's and Black Forest Labs' current offerings.

Worth stating up front: OpenAI publishes no quality benchmarks for 2.6 and no per-image cost table, so this article leans on the documented mechanics of the release, the token pricing that is published, and the competitive tables that rivals do publish. Everything verifiable is verified; everything else is labeled as a claim.

What GPT-Image-2.6 is

GPT-Image-2.6 is OpenAI's image generation and editing model family for the API, accepting text and image inputs and returning images. Weights are closed, serving is OpenAI-hosted, and billing is per token rather than per image.

The family splits by intent. GPT-Image-2.6 Flare is built for fast iteration and interactive workflows, the mode where a human or an agent is cycling through options and latency dominates the experience. GPT-Image-2.6 Sunburst is built for detailed compositions and editing, the mode where output consistency across successive edits is the requirement. Both accept the same inputs, share the same pricing, and expose the same new controls; the difference is where each one spends its effort.

Two models, two jobs

The split reflects two different workloads that image APIs serve, and OpenAI has made the choice explicit rather than leaving it in a quality slider.

Flare is the iteration model. It is built for interactive workflows where latency is the cost that compounds: a designer cycling through poster layouts, a product team exploring packaging, an agent generating variations in a pipeline. At low quality, Flare can return a GPT-Image-2.6 image in as little as six seconds. It also improves layout quality for posters and product imagery, which addresses the common complaint that fast models produce fast garbage.

Sunburst is the GPT-Image-2.6 finishing model. It targets higher quality and, more distinctively, stronger consistency across edits, the property that determines whether an edited character, product or brand detail survives from one revision to the next. For workflows where a base image gets refined through many rounds, consistency is the difference between an editor and a slot machine.

The GPT-Image-2.6 pairing is a familiar shape from other domains: a fast model for search and a precise model for scoring, a draft tier and a final tier. What is notable is OpenAI exposing the choice as named models rather than folding it into a quality parameter, which makes pipeline architecture clearer. Route cheap edits to Flare, route finishing to Sunburst.

The complexity dial, explained properly

The most interesting new GPT-Image-2.6 control is the complexity field, because it separates two things that previous image APIs conflated.

Quality controls rendering detail and fidelity: how crisp, how resolved. Complexity controls how much the model plans before it renders: how hard it works on the scene's structure before drawing. The guide lists three levels, low, medium and high, with high as the default for both GPT-Image-2.6 models.

The distinction has practical teeth for GPT-Image-2.6 users. A focused edit, swap the background, change the text on a sign, is a low-complexity task regardless of output resolution, and OpenAI recommends low complexity for faster edits in most editing cases. Dense text, complex layouts and many interrelated objects are high-complexity GPT-Image-2.6 tasks, where under-planning shows up as garbled signage and physically confused scenes. Adjusting complexity carries no separate fee, which makes it a free experiment, though higher complexity adds latency and, as OpenAI warns, can introduce unwanted changes as the model works harder on the scene.

Complexity is also the honest admission underneath the speed headline. A 50 percent faster generation at low quality is a low-complexity generation. Teams benchmarking the release should hold the complexity level fixed when comparing against the previous version or against competitors, or they will mostly be measuring planning depth, not architecture.

GIF, SVG and the pipeline they eliminate

Two GPT-Image-2.6 output formats arrive in the API, and each one deletes a step from a real production pipeline.

Animated GIF output means a prompt or photo can become a looping animation natively in GPT-Image-2.6: a brand mascot animated for a campaign, reaction content for social, or animated storyboards used to explore character motion before committing to video production. The demos OpenAI shows, sprite-sheet style six-frame loops generated from a single prompt, and a hand-drawn owl sketch animated directly, point at the low end of video production being absorbed by the GPT-Image-2.6 tier. Social and product teams no longer need a separate animation pass for simple loops.

SVG export matters for a different reason: scalability without blur. Icons, diagrams and UI assets generated as raster images have always needed a manual vectorization pass before reaching a design system, and GPT-Image-2.6 removes that pass. Native SVG output moves generated assets from the marketing bin into the engineering bin, which is where reuse happens. For teams generating UI elements or documentation diagrams programmatically, this is the feature that makes generated images auditable and versionable in the same way as code.

Image markup, already available in ChatGPT, comes to GPT-Image-2.6 in the API: mark the exact region to change rather than describing its location in prose. That is the difference between “change the logo in the top right” and drawing a box around it, and it removes an entire genre of edit failure where the model edits the right-looking wrong thing.

A production workflow, wired end to end

The two models make sense as a pipeline, so consider a product team shipping a seasonal campaign, which exercises every new feature in sequence.

Concepting runs on Flare at low complexity. The team generates twenty poster layouts in minutes, discards seventeen, and iterates on three. Latency is the experience here; six seconds per image at low quality is close enough to interactive that the model becomes a sketchpad rather than a submission form.

The chosen layout moves to Sunburst for production. Complexity goes to high because the poster carries dense text, brand marks and product shots with spatial relationships that must hold. The team then runs the revision loop, and this is where markup earns its cost: a reviewer drags a box around the wrong product color and writes the correction, instead of describing its location and hoping the model finds the right region. Sunburst's edit consistency keeps the mascot, the typography and the palette stable across revisions, which is what makes ten rounds of review possible without the design drifting.

Delivery splits by channel. The web banner exports as SVG so it scales cleanly into the design system. The social cut becomes an animated GIF natively: the mascot reacts, the loop closes, no animation vendor involved. Every artifact in the campaign was generated, edited and exported inside one API.

What that workflow demonstrates is that the features are not a list, they are a stack. Speed for exploration, planning depth for production, spatial precision for revision, and output formats for delivery. A team adopting only the headline, faster generation, captures a fraction of the value.

Pricing: token-based, and what it hides

GPT-Image-2.6 pricing is token-based and identical for both models: $5.00 per million text input tokens, $8.00 per million image input tokens, $30.00 per million image output tokens, with cache discounts on inputs. The same structure as GPT-Image-2.5, which is part of the per-image opacity discussed below.

Token pricing for images is convenient for OpenAI and opaque for buyers. The number a team actually budgets against is cost per image, and that depends on how many tokens a typical image and its input prompt consume, which the release does not publish. Competitors do publish it: Google's Nano Banana 2.1 starts at $0.0336 per 1,000 images, Black Forest Labs' FLUX 3 Image at $0.048, reaching $0.113 and $0.607 respectively at 4K. Without a conversion from tokens to images, comparing GPT-Image-2.6 against those tables requires running your own workload and measuring, which is a real barrier and an obvious one.

The comparison table sharpens the trade. Nano Banana 2.1 discloses up to 14 reference images and 4K output. FLUX 3 Image offers bounding-box control in the prompt and an open-weight sibling, FLUX 3 Image Klein, that runs on consumer GPUs down to an RTX 3090, which is a meaningful option for teams with data-residency needs or high volumes. OpenAI's stated edge is native GIF and SVG output plus edit consistency, and its gap is transparency on per-image cost and quality benchmarks. There are no published quality scores for 2.6 at all, so the 50 percent speed claim and the consistency claims stand on OpenAI's word.

The ChatGPT side: references and memory

The API gets the developer features, but the ChatGPT changes reveal where OpenAI thinks consumer image workflows are heading, and one of them matters for developers too.

Users can now save and tag reference images of people, pets and characters in GPT-Image-2.6 and reuse those references later without re-uploading. That is persistent identity across sessions: a character created once can appear in next month's campaign without the team re-describing it and hoping the model reconstructs it. Anyone who has tried to keep a generated mascot consistent across a month of prompts understands exactly how much friction this removes.

It also previews an API capability that seems inevitable. Reference libraries for people, products and brand assets, served server-side with consent managed properly, would solve the consistency problem for teams that generate at volume, and the ChatGPT feature reads as a trial of exactly that UX. The GIF controls in ChatGPT, animation speed and per-frame editing, similarly preview the parameter surface that API users can expect to see formalized.

The strategic reading is that consumer features are becoming API roadmaps. Teams building on the API should watch what ChatGPT ships, because the pattern across recent releases is that ChatGPT experiments graduate into developer controls, and planning for those controls early is cheaper than retrofitting pipelines later.

Consistency is the metric that matters for editing

The specification distinction worth dwelling on is edit consistency, because it is the property that determines whether image APIs can graduate from one-shot generation into production editing.

Editing an image iteratively is an exercise in holding state: the character must stay the same character, the product the same product, the layout the same layout, across every revision. Models that regenerate rather than edit tend to drift, changing the logo slightly, reinterpreting the background, shifting proportions. Teams have compensated with ever-longer prompts describing what must not change, which is expensive and unreliable.

Sunburst's stated strength is exactly that consistency at medium and high quality, and markup complements it by scoping edits spatially. Together they form an editing contract: change this region, keep everything else, keep the subject recognizable. If the contract holds across many rounds, image APIs become usable for asset maintenance, not just asset creation, and that is a larger market than creation.

What is missing is the measurement. OpenAI claims stronger consistency across edits but publishes no consistency benchmark, no edit-distance metrics, no reference-maintenance scores. Teams evaluating Sunburst for exactly this use should build a small holdout: one base image, twenty sequential edits, and an automated check that the invariant elements survive. That test costs an hour and answers the question the launch materials leave open.

Reading the competitive table carefully

The comparison against Nano Banana 2.1 and FLUX 3 Image rewards close reading, because the columns reveal different philosophies of disclosure and control.

Google's Nano Banana 2.1 discloses the most operational detail: 14 reference images, 4K output, and per-image pricing from $0.0336 per 1,000 images to $0.113 at 4K, none of which GPT-Image-2.6 materials currently match. Black Forest Labs discloses parameter counts for its open sibling, supports bounding-box control in prompts, and offers FLUX 3 Image Klein under a community license that runs on consumer GPUs. OpenAI discloses neither parameters nor reference-image limits nor maximum output resolution, and publishes no quality benchmarks.

Three vendors, three answers to the same question: what does a buyer need to plan a pipeline? Google bets on published unit prices, BFL bets on open weights and spatial control, OpenAI bets on workflow integration and edit consistency. The buyer's evaluation should mirror the vendor's strength: teams with steady volume and known formats can price Google and BFL exactly; teams whose workloads are edit-heavy and ChatGPT-adjacent get features from OpenAI that the others do not list.

The open-weight option deserves specific attention because it changes the cost curve completely. Klein running on an RTX 3090 moves marginal image cost toward electricity, and for teams generating at the hundreds-of-thousands range, that is not a rounding error but a strategy. The hosted APIs remain the right choice for spiky workloads and zero-ops requirements, which is most teams most of the time.

The usage number is the strategic signal

The most consequential figure in the release is not a feature. It is 4 billion images per week and climbing by a billion every two months.

At that scale, image generation is a utility, and utilities compete on latency, controllability and unit economics rather than on demo quality. That is exactly the shape of the GPT-Image-2.6 release: a latency-focused model, a quality-focused model, a planning dial, markup precision, and pipeline-native output formats. Nothing here is about making prettier pictures. Everything is about making generated images an industrial input, the way text generation became one when APIs stopped competing on eloquence and started competing on cost per call.

It also explains the missing per-image pricing. As volumes grow, token billing shifts the optimization burden to the buyer: prompt shorter, request fewer variants, cache aggressively. Teams that instrument their GPT-Image-2.6 usage will find real savings in prompt hygiene; teams that do not will pay the opaque sticker price. The teams that measure GPT-Image-2.6 cost per delivered asset, the pattern this site has recommended since the model routing analysis, will handle the transition cleanly, and the same discipline applies to the serving choices in our AI gateway comparison, and the asset-generation angle pairs with the document-intelligence uses covered in our Baidu OCR analysis.

For developers building on GPT-Image-2.6 and its rivals, the practical guidance is concrete. Use Flare at low complexity for iteration and editing, Sunburst at medium or high for finals and consistency-sensitive edits, markup for spatial edits wherever possible, and benchmark cost per image on your own workload before committing, since that number is now deliberately absent from the vendor's own materials.

Sources
Subscription Form