Latest / AI Fire Daily / #130 Robin: ChatGPT Images 2.6 Can Now Make GIFs, Reuse Characters, and Edit Frames

Transcript

#130 Robin: ChatGPT Images 2.6 Can Now Make GIFs, Reuse Characters, and Edit Frames · AI Fire Daily

• 0:00
  Whoa. Imagine generating four billion images
• 0:03
  a week. It is completely staggering to even think
• 0:06
  about. It really is. That scale is just, well,
• 0:09
  it is difficult to comprehend. We're talking
• 0:11
  about a volume of visual creation that dwarfs
• 0:13
  the entire history of human art. Oh, easily.
• 0:16
  And it is happening every single week. And the
• 0:19
  wild part is, you know, we are moving well beyond
• 0:22
  just static pictures now. Right. The standard
• 0:25
  has shifted basically overnight. It really has.
• 0:28
  We are talking about instantly animated GIFs
• 0:30
  now generated from a mere sketch and doing that
• 0:33
  at that exact same mind -bending scale. It is
• 0:36
  incredible. Well, welcome to the deep dive. We
• 0:39
  are acting as your guides today to unpack this
• 0:41
  massive shift in how we create media. Yeah, there
• 0:44
  is a lot of ground to cover. Today, we are exploring
• 0:46
  the November 4, 2026 release of Chat GPT Images
• 0:50
  2 .6. And our mission is highly practical for
• 0:53
  you. We want to make this actionable. Exactly.
• 0:55
  We're going to break down how to actually use
• 0:57
  its new features, things like GIF creation, precise
• 1:00
  image markup, and SVG exports. Which, I mean,
• 1:03
  they all sound great on paper. They do. But if
• 1:06
  you aren't careful, those shiny new features
• 1:07
  will just train your budget so fast. That is
• 1:10
  the big catch. We want you to navigate these
• 1:12
  tools without falling into the default traps
• 1:14
  that waste both your API credits and your time.
• 1:16
  Because it really requires a total shift in how
• 1:19
  you approach the platform now. It does. You can't
• 1:22
  just throw prompts at it blindly anymore, can
• 1:23
  you? Not at all. The underlying architecture
• 1:26
  has fundamentally changed. So I think the best
• 1:29
  place to start is that core engine update. Yeah,
• 1:31
  that makes sense. Because understanding this
• 1:33
  new dual model approach is really the key to
• 1:35
  unlocking everything else. It really is the foundation
• 1:37
  of the whole 2 .6 update. Right. So images 2
• 1:41
  .6 builds on version 2 .5 with a rather massive
• 1:44
  promise. 50 % faster generation. Which, you know,
• 1:49
  sounds impossible if you are just piling more
• 1:51
  features onto the same old system. Right. Usually
• 1:53
  more features means a slower system. Exactly.
• 1:56
  But they achieve this speed by splitting the
• 1:58
  workload entirely. Instead of one massive neural
• 2:01
  net trying to guess whether you want speed or
• 2:03
  quality, OpenAI actually gave us two distinct
• 2:07
  models. OK, two models? Yeah, you have Flare
• 2:10
  and you have Sunburst. I find that division fascinating.
• 2:14
  By splitting the workload, they basically don't
• 2:16
  force the system to compromise anymore. Precisely.
• 2:20
  Flare is essentially designed for quick drafts.
• 2:22
  How quick are we talking? It can spit out a low
• 2:25
  quality image in just six seconds. Wow, six seconds.
• 2:28
  Yeah, it works incredibly well for things like
• 2:30
  event posters or basic product visuals where
• 2:33
  you just need the gist of an idea. Six seconds
• 2:36
  is barely enough time to even type out your next
• 2:38
  prompt. It really isn't. Flare basically bypasses
• 2:41
  all the heavy, multi -step refinement loops that
• 2:44
  usually bog down AI image generation. Though
• 2:47
  it sacrifices the polish for pure speed. Exactly.
• 2:51
  It skips the deep polish to give you immediate
• 2:53
  visual feedback. It is your rapid prototyping
• 2:56
  tool. That feels... Very familiar when you put
• 2:59
  it in everyday terms. How so? Well, choosing
• 3:01
  between flair and sunburst is kind of like choosing
• 3:03
  a drive -thru for a quick snack versus sitting
• 3:06
  down for a meticulously prepared dinner. Oh,
• 3:09
  that is a great way to look at it. You're hungry
• 3:11
  either way, but your expectations for the outcome
• 3:13
  are completely different. Yeah, and to push that
• 3:16
  drive -thru analogy just a bit further, if you
• 3:18
  order flair, you get your food in six seconds.
• 3:22
  But you can't be mad if the burger looks a little
• 3:24
  sloppy. Right. You are explicitly paying for
• 3:27
  the speed. Exactly. Sunburst, on the other hand,
• 3:30
  is the fine dining option. It takes its time.
• 3:33
  It is built for high detail and ensuring absolute
• 3:35
  brand consistency across multiple edits. So Sunburst
• 3:39
  is doing all that invisible heavy lifting behind
• 3:42
  the scenes. It is. It is analyzing the prompt
• 3:45
  much, much more deeply. And you really need to
• 3:48
  know which one of these you are ordering before
• 3:50
  you hit generate. Especially when you start looking
• 3:52
  at the baseline pricing structure for API users.
• 3:55
  That is where it gets real. Let's dig into those
• 3:58
  token rates because I think they reveal a lot
• 4:00
  about how the system operates. They definitely
• 4:03
  do. The base API token rates are actually entirely
• 4:06
  unchanged from version 2 .5. Right, the numbers
• 4:09
  themselves haven't moved. It remains $5 per 1
• 4:12
  million text input tokens. It is $8 per 1 million
• 4:16
  image input tokens and $30 per 1 million output
• 4:19
  tokens. The baseline math basically holds steady.
• 4:23
  And that pricing applies everywhere too. Yeah,
• 4:25
  web, desktop, all of it. Yeah. We have desktop
• 4:27
  and mobile across all the subscription tiers.
• 4:30
  Okay, but if token rates are identical to 2 .5,
• 4:33
  why are developers seeing different final bills?
• 4:35
  Well, it comes down to how users manage the new
• 4:37
  quality and complexity settings. Ah, so it is
• 4:40
  the settings, not the base rates. Exactly. These
• 4:43
  settings dictate the actual computing load under
• 4:45
  the hood. You might request the exact same image
• 4:48
  subject in both versions, right? Right. But heavier
• 4:51
  settings in 2 .6 forced the model to do more
• 4:53
  invisible labor. It runs more diffusion steps.
• 4:56
  It calculates finer pixels. And all that extra
• 4:59
  computational processing power costs money. So
• 5:01
  same base rates, but heavier settings drive up
• 5:05
  the final cost. You nailed it. You are paying
• 5:07
  for the computational depth, not just the raw
• 5:09
  token count anymore. That brings us to a really
• 5:12
  crucial point for anyone building a workflow.
• 5:14
  The settings matter more than ever. Because if
• 5:16
  those settings control both your cost and your
• 5:19
  quality, we really need to understand them. We
• 5:22
  have to know exactly which levers to pull before
• 5:25
  we generate a single image. Right. Setting up
• 5:27
  your environment correctly is basically half
• 5:29
  the battle now. Oh, absolutely. Now, if you are
• 5:32
  just creating content in plain English, just
• 5:33
  chatting back and forth, you should... Honestly,
• 5:35
  just use the chat GPT interface. Because it is
• 5:38
  straightforward and conversational. Yeah, it
• 5:39
  hides all the complicated math from you, which
• 5:42
  is perfect for casual users. But if you are building
• 5:44
  automated workflows for a business, you have
• 5:47
  to switch to the API. You do. And the API is
• 5:50
  also strictly required if you want to output
• 5:52
  SVG files, which we will get into. Now, once
• 5:55
  you are in the API, you have two master controls
• 5:57
  at your disposal. We have quality and we have
• 6:00
  complexity. And people often conflate those two
• 6:02
  words. They sound similar, but they perform very
• 6:05
  different mechanical functions. Let's separate
• 6:07
  them. Quality basically dictates how polished
• 6:10
  the final image looks. Yes. Like the textures,
• 6:13
  the lighting, the sheer pixel resolution. Exactly.
• 6:16
  Quality is the surface finish of the image. Complexity
• 6:19
  is much deeper than that. How so? Well, it controls
• 6:23
  how much cognitive planning the model does before
• 6:25
  it even starts drawing. Oh, interesting. It determines
• 6:28
  how hard it works to follow your specific, nuanced
• 6:31
  instructions. It is sort of like giving a task
• 6:33
  to an intern versus a senior engineer. The rule
• 6:37
  of thumb here seems surprisingly straightforward,
• 6:39
  actually. It is, once you get the hang of it.
• 6:41
  Low complexity is great for simple, straightforward
• 6:43
  edits, like if you are just swapping out a background
• 6:46
  color on a product shot. Right. You don't need
• 6:49
  a senior engineer for that. But high complexity
• 6:52
  is needed for highly detailed infographics. Things
• 6:55
  that involve rigid charts and strict layout rules.
• 6:58
  Exactly. Things where the structural relationship
• 7:01
  matters. I have to admit something here, though.
• 7:03
  Uh -oh. What's that? I still wrestle with prompt
• 7:06
  drift myself. Oh, we all do. It is an incredibly
• 7:10
  tempting trap to fall into. You just want to
• 7:12
  overcomplicate the instructions. You sit there
• 7:14
  thinking that adding more words, you know, more
• 7:16
  adjectives will somehow guarantee a better outcome.
• 7:20
  Yeah. We think more is always better. when in
• 7:22
  reality a simple low -complexity prompt would
• 7:26
  actually work better and it would generate much
• 7:28
  faster. It is a very hard habit to break. We
• 7:31
  are just so used to over -explaining things to
• 7:33
  older AI models because honestly they used to
• 7:36
  be so dense. Which naturally makes me wonder,
• 7:40
  if high -complexity makes it smarter, shouldn't
• 7:42
  we just leave it maxed out? It seems perfectly
• 7:45
  logical, but no. OpenAI actually recommends starting
• 7:49
  on the lowest setting. Really? The lowest. Yeah,
• 7:53
  because unnecessary high complexity slows down
• 7:56
  your generation significantly. And worse, it
• 7:59
  frequently introduces weird, unwanted visual
• 8:01
  artifacts. Like, what kind of artifacts? It essentially
• 8:05
  overthinks the problem. It starts seeing patterns
• 8:07
  that just aren't there, and it tries to add details
• 8:10
  you never asked for. Got it. Max complexity slows
• 8:14
  things down and adds unwanted visual noise. Right.
• 8:18
  You are basically forcing the AI to... hallucinate
• 8:22
  extra details. Keep it simple unless the task
• 8:25
  explicitly demands it. So if keeping complexity
• 8:28
  low saves us from visual noise in static images,
• 8:32
  I have to imagine that rule becomes 10 times
• 8:34
  more important when we start talking about the
• 8:36
  new GIF generation. Oh, absolutely. This is where
• 8:40
  things get really fascinating, but also incredibly
• 8:43
  technically demanding. Let's talk about the GIFs.
• 8:46
  When you ask it to turn a prompt or an image
• 8:48
  into a looping GIF, the model uses something
• 8:51
  called a sprite sheet to make it happen. We should
• 8:54
  probably clarify what that means for anyone who
• 8:56
  hasn't built a video game before. Yeah, good
• 8:57
  idea. A sprite sheet is just a single image file
• 9:01
  containing multiple smaller frames of animation.
• 9:03
  Perfect definition. Yes, the AI generates that
• 9:06
  one massive sheet first, then mathematically
• 9:09
  slices it up and stitches those individual frames
• 9:11
  together into a sequence. And that becomes your
• 9:13
  looping GIF. Exactly. But there are strict best
• 9:16
  practices here if you actually want it to look
• 9:18
  good. You must keep the movement simple, right?
• 9:20
  Very simple. And you must keep the camera completely
• 9:23
  fixed in place. Yeah, no wild panning shots.
• 9:26
  And the sweet spot for a smooth loop seems to
• 9:28
  be a six frame animation. Six frames is the magic
• 9:31
  number. It is. Imagine you prompt for a cute
• 9:33
  3D fox waving its hand. In a six frame sequence,
• 9:37
  the AI has enough space to raise the hand. wave
• 9:39
  it, and return naturally to frame one without
• 9:42
  losing track of the fox's face. If you are using
• 9:45
  the API to do this, there are some very specific
• 9:47
  constraints to be aware of. Yeah, the API is
• 9:50
  strict about formatting. You must explicitly
• 9:52
  set the output format to GIF, and the system
• 9:56
  supports anywhere between 2 and 64 frames. And
• 9:59
  you get control over the playback speed, too.
• 10:01
  You can set the timing anywhere between 20 and
• 10:04
  2 ,000 milliseconds per frame. The defaults are
• 10:07
  set to 9 frames and 200 milliseconds. But there
• 10:11
  are major traps hiding here, aren't there? Huge
• 10:13
  traps. These loops are not always perfect. Far
• 10:16
  from it. Yeah. The physics of the animation can
• 10:18
  break down very quickly. They can get really
• 10:20
  weird really fast. In one of the hands -on tests
• 10:24
  mentioned in our sources, a developer tried generating
• 10:27
  a 10 -frame GIF. OK. So just slightly above the
• 10:30
  default. Right. And it resulted in very uneven
• 10:33
  movement. There was this highly noticeable jerky
• 10:35
  jump between the last frame and the first frame.
• 10:38
  Which completely breaks the illusion of a continuous
• 10:40
  loop. It totally ruins the effect. There is also
• 10:43
  a major limitation to note here. The API image
• 10:46
  -edit endpoint cannot output GIFs at all. Yeah.
• 10:50
  It is for generation only right now. And a quick
• 10:53
  troubleshooting tip. If your GIF generation fails
• 10:56
  entirely, just Drop your resolution. Try forcing
• 10:59
  it to 512 by 512 pixels. That usually clears
• 11:02
  up the memory error. But I'm curious about the
• 11:04
  physics breaking down. Why did that 10 frame
• 11:07
  test fail to loop smoothly? Because every additional
• 11:10
  frame gives the model more opportunities to lose
• 11:13
  track of the subject. It just forgets. It literally
• 11:16
  forgets the initial starting state of the animation
• 11:18
  as it renders further down the sprite sheet.
• 11:20
  So by frame 10, the fox's ear might be slightly
• 11:23
  shorter. So when it loops back to frame one,
• 11:25
  you see a visual jump. Right. More frames just
• 11:28
  multiply the chances of a glitch. Exactly. Keeping
• 11:31
  the frame count brief forces the model to stay
• 11:33
  sharply focused on the mechanics of the loop.
• 11:35
  We are going to pause here for just a moment
• 11:38
  to hear from our sponsor. We will be right back.
• 11:41
  Sponsor placeholder. And we are back. So we have
• 11:44
  established that complex animations can get glitchy
• 11:47
  because the AI basically forgets what the subject
• 11:50
  looks like. It gets amnesia down the sprite sheet.
• 11:53
  So how do we force the AI to keep our characters
• 11:55
  or our products visually consistent, whether
• 11:58
  we're animating them or just putting them in
• 12:01
  a new static scene? This is genuinely the holy
• 12:04
  grail of reusability right here. It has been
• 12:07
  a problem for a long time. For years, text -only
• 12:09
  prompts have been notoriously bad at this. You
• 12:12
  ask for your mascot in a new pose and it randomly
• 12:14
  changes their facial features. Or product handles
• 12:18
  suddenly disappear. Brand badges swap colors
• 12:20
  for no reason. Yeah, it was maddening. But the
• 12:23
  solution they have introduced is saved reference
• 12:25
  images. How's that work in practice? OK, you
• 12:28
  take an approved image of a person, a pet, or
• 12:31
  a character, you save it once, then you reuse
• 12:34
  that exact image across your future chats as
• 12:36
  a strict baseline. So it gives the model a visual
• 12:39
  anchor. Exactly. It's a source of truth to follow,
• 12:42
  rather than relying on its hazy memory of your
• 12:45
  text description. It completely changes the game
• 12:48
  for brand consistency. It is massive. And building
• 12:51
  on that, you can do highly precise editing now.
• 12:53
  You can mark up an image directly to alter specific
• 12:56
  parts while protecting the rest. This is probably
• 12:59
  the most practically useful feature for power
• 13:01
  users. You literally just circle an area. Say
• 13:04
  you have a mascot wearing a red scarf. You just
• 13:07
  circle the scarf. And then? You tell the model
• 13:09
  to change it to blue. The AI isolates that area
• 13:13
  and keeps everything else in the image entirely
• 13:15
  untouched. But API users need to be very careful
• 13:18
  here. The web interface makes it look incredibly
• 13:20
  easy, but the backend requirements for this are
• 13:23
  strict. Yes, there is a technical hurdle. For
• 13:26
  API users, that markup process requires providing
• 13:29
  a transparent PNG. And it must match the original
• 13:32
  image's exact dimensions pixel for pixel. Right.
• 13:35
  Plus, you cannot use a traditional mask file.
• 13:38
  So it just requires a bit more technical setup
• 13:40
  and image prep on your end before you make the
• 13:42
  actual API call. And then there is the addition
• 13:45
  of SVGs. This is massive for designers. Oh, absolutely
• 13:49
  huge. SVGs are perfect for scalable logos and
• 13:53
  website icons. We should probably quickly refresh
• 13:56
  what that actually means too. Good call. An SVG
• 13:59
  is an image file that resizes infinitely without
• 14:02
  ever getting blurry. Because it uses mathematical
• 14:04
  formulas to draw the lines and shapes instead
• 14:07
  of just a grid of colored pixels. Right. No pixels
• 14:10
  to get stretched out. But you have to remember,
• 14:12
  SVGs are strictly static files. They are generated
• 14:15
  one at a time, and they are currently not supported
• 14:18
  by the edit endpoint. You can only generate them
• 14:21
  fresh. Yes. This all leads to what we can call
• 14:24
  the golden workflow for brand builders. Let's
• 14:27
  lay it out. You start by generating an approved
• 14:29
  mascot. You save it as a reference image. You
• 14:32
  mark up any specific targeted edits you need.
• 14:36
  You create your animated GIF from that base.
• 14:38
  And finally, you generate a scalable SVG icon
• 14:42
  of that character for your web layout. It is
• 14:44
  a powerful, repeatable pipeline. Once you set
• 14:47
  it up, you can churn out assets that actually
• 14:49
  look like they belong to the exact same company.
• 14:52
  It is brilliant. But I do have a question. If
• 14:55
  the markup feature is so precise, why do I still
• 14:58
  need to check the background? Because that markup
• 15:01
  circle only acts as a guide for the edit. Not
• 15:04
  a strict rule. Right. The underlying model is
• 15:06
  still a neural network. It can still hallucinate
• 15:08
  unexpected changes elsewhere in the frame, even
• 15:10
  outside the circle you drew. It isn't a perfect
• 15:13
  mechanical crop. Ah, it is a suggestion, not
• 15:16
  an absolute boundary fence. Exactly. You are
• 15:19
  pointing at what you want changed, but you aren't
• 15:21
  building an impenetrable wall around it. OK,
• 15:24
  so we have built the perfect brand workflow.
• 15:27
  The quality is there. The consistency is there.
• 15:30
  Yep. The tools are working. But doing this blindly?
• 15:33
  is going to severely burn through your API credits.
• 15:36
  It will roast your budget. We need to look at
• 15:39
  the actual math. We need to talk about the ROI
• 15:41
  trap. The cost breakdown here is very revealing,
• 15:44
  and it shows exactly why defaults are so dangerous.
• 15:47
  Let's look at generating a standard 1024 by 1024
• 15:50
  image. On low quality, it costs about 2 .5 cents
• 15:54
  per image. Which is very reasonable for rapid
• 15:57
  testing. High quality doubles that. And it sits
• 15:59
  at about 5 .3 cents. It's still not terrible,
• 16:03
  but if you flip the switch to max quality, it
• 16:06
  jumps all the way to roughly 21 cents per image.
• 16:08
  That is a massive premium. If you are running
• 16:11
  an automated script generating hundreds of images
• 16:13
  an hour, that difference adds up incredibly fast.
• 16:16
  You will blow your monthly budget in a single
• 16:19
  afternoon. Easily. We really need to highlight
• 16:22
  an anomaly from our sources to prove this point.
• 16:25
  A developer named Kingi did a hands -on test
• 16:27
  using the detailed sunburst model. Okay, let's
• 16:30
  hear the numbers. They generated three images
• 16:33
  on GPT image -2 .6. The total cost was roughly
• 16:38
  12 .5 cents, and the generation process took
• 16:41
  48 .7 seconds. Which, you know, doesn't sound
• 16:44
  too bad until you look at the baseline comparison.
• 16:48
  Right. They ran the exact same test requesting
• 16:51
  the same images on the older version 2 .5. And
• 16:54
  what happened? That older version cost only 4
• 16:57
  .5 cents, and it only took 39 .8 seconds to finish.
• 17:01
  That is nearly a three times cost increase, and
• 17:04
  it actually took longer. This massive jump wasn't
• 17:08
  a bug. It was entirely due to mismatched default
• 17:10
  complexity settings in the new version. The system
• 17:13
  was basically over -processing a simple request
• 17:16
  because it was told to. It completely proves
• 17:18
  that relying on default settings can be dangerous
• 17:21
  for your margins. It really does. There is also
• 17:24
  an important API compatibility warning you need
• 17:26
  to be aware of before you switch over. What's
• 17:28
  that? Version 2 .6 fully supports the generation
• 17:32
  and editing endpoints, but it does not currently
• 17:35
  support responses, chat completions, or batch
• 17:39
  APIs. So if your current software relies on batch
• 17:42
  APIs for bulk processing, you are going to break
• 17:45
  your system if you force the upgrade today. Yeah,
• 17:48
  you really need a strict pre -publishing checklist.
• 17:51
  Always check your text's filling and your pricing
• 17:54
  numbers in the images. Verify that logos and
• 17:57
  product details haven't drifted. Ensure you have
• 17:59
  smooth frame transitions if you are making GIFs.
• 18:02
  And honestly, test version 2 .5 side by side
• 18:06
  with 2 .6 before fully migrating your production
• 18:08
  environment. But wait, they promised 50 % faster,
• 18:12
  but the test took longer. Because that faster
• 18:15
  claim only applies if you deliberately optimize
• 18:18
  the complexity settings to match your specific
• 18:20
  prompt. Oh, I see. If you leave the sliders on
• 18:22
  their highest defaults, the system will punish
• 18:24
  you by running deep, unnecessary computations
• 18:27
  that slow everything down. So lazy default settings
• 18:30
  will tax both your wallet and the clock. Active,
• 18:33
  deliberate management is absolutely required
• 18:36
  if you want to see those speed and cost benefits.
• 18:38
  I think we can synthesize this entire journey
• 18:41
  pretty clearly. Chat GPT Images 2 .6 is undoubtedly
• 18:45
  an incredible leap forward in capabilities. It
• 18:48
  really is a milestone. It brings serious speed.
• 18:50
  if you utilize the flare model properly. It brings
• 18:54
  massive new creative control with the introduction
• 18:57
  of GIFs and scalable SVGs. And it solves a major
• 19:00
  headache by bringing consistent branding through
• 19:03
  those sunburst reference images. But the crucial
• 19:05
  takeaway is that it demands active piloting from
• 19:08
  you. You have to be an engaged operator. You
• 19:11
  can't just fall asleep at the wheel. You must
• 19:13
  keep your complexity settings low by default.
• 19:16
  You must keep your GIF frames limited. to avoid
• 19:18
  glitches. And you must keep a sharp, skeptical
• 19:21
  eye on those default API settings to protect
• 19:24
  your budget. It is an incredibly powerful engine,
• 19:26
  but you have to steer it. It won't drive itself
• 19:28
  efficiently. Definitely not. Here's a challenge
• 19:31
  for you to try this week. Pick one mascot or
• 19:35
  one flagship product from your work. Run it through
• 19:38
  the entire golden workflow we discussed. Start
• 19:40
  with an approved reference image. Edit a specific
• 19:43
  detail using the precise markup tool. Animate
• 19:46
  it into a short six -frame GIF, and finally,
• 19:49
  export a scalable SVG version. Find out firsthand
• 19:53
  which of these features actually hold up for
• 19:55
  your specific real -world needs. I highly recommend
• 19:58
  doing that. It is truly the best way to learn
• 20:01
  the quirks of the system before you build a business
• 20:03
  logic around it. Yeah, get your hands dirty first.
• 20:06
  I want to leave you with a lingering thought
• 20:08
  as we wrap up today. Let's hear it. If an AI
• 20:11
  can perfectly maintain a character's visual consistency,
• 20:14
  and animate it smoothly from a standing start
• 20:17
  in just six seconds. What happens to the baseline
• 20:20
  value of basic stock photography and entry -level
• 20:23
  animation studios over the next two years? It
• 20:26
  is something to think about.