OpenAI Fixes GPT-6 Sol and Luna Image Encoding: Re-Evaluate Vision, Computer Use, and Codex Workflows

Controlled Before-and-After Evaluations for Vision and Computer-Use Workloads

OpenAI’s changelog says the September 25 fix addressed an image-encoding bug that degraded image understanding in GPT-6 Sol and GPT-6 Luna, including visual tasks in the API and Codex such as computer use. The operational consequence is narrow but important: teams should rerun representative evaluations and retry affected workflows, while treating the new run as fresh evidence rather than as a guarantee that every previous visual failure is explained or every future visual action is safe.

A controlled before-and-after evaluation is the safest way to answer the question most teams now have: “Did the fix materially change outcomes for our images, prompts, tools, and review process?” The control is not a single demo that now works; it is a repeatable comparison that freezes the model identifier or snapshot where available, prompt version, image bytes or image hash, preprocessing steps, tool state, browser or application state, scoring rubric, reviewer pool, and stop conditions. Without those controls, teams can easily mistake a prompt edit, a different crop, a refreshed web page, a new app version, or a changed reviewer expectation for an image-understanding improvement.

The method below is intentionally conservative because image understanding and computer use are composite systems. A model may correctly read a chart and still produce a poor business interpretation. It may correctly identify a button and still click the wrong coordinate because the browser zoom changed. It may read a form accurately and still be blocked by a permission policy, an approval gate, or a safety stop. Evaluation should therefore separate visual interpretation, extraction, reasoning, coordinate translation, tool invocation, and consequential action approval.

Define the Evaluation Contract Before Rerunning Anything

The evaluation contract is the written rulebook for what counts as comparable evidence. It should be approved before the rerun so the team does not move thresholds after seeing results. For the GPT-6 Sol and Luna image-encoding fix, the contract should state that the purpose is to measure post-fix behavior on workloads plausibly affected by image encoding, not to certify general model reliability or to validate unrelated application changes.

Teams that retained pre-fix outputs should preserve them as immutable baseline evidence. Do not overwrite old logs with new completions, and do not silently replace old screenshots with “cleaner” versions. If the earlier run did not retain images or prompts, label the comparison as a fresh post-fix evaluation rather than a true before-and-after study.

The article explains how managed requirements.toml policies can lock down Codex browser and native-app computer use for enterprise workflows. The How to Lock Down Codex Browser and Computer Use with Managed requirements.toml Policies article is a focused companion for Computer Use Approval Gates because approval gates for computer-use workflows are closely related to governed policy controls for Codex browser and desktop automation.

Model Snapshot, Prompt Version, and Image Hash Are the Minimum Reproducibility Set

The minimum reproducibility set for a multimodal evaluation is the model reference, the prompt version, and the image hash. If one of those three is missing, the result may still be useful as anecdotal evidence, but it should not be used as a formal regression conclusion. For Sol and Luna, the changelog creates a strong reason to rerun affected tests, but it does not remove the need to show that the rerun used the same inputs and evaluation rules.

The model field should include the official model name used in the request or product configuration, such as GPT-6 Sol or GPT-6 Luna, plus any snapshot, deployment, or version metadata available in the relevant API, Codex, or workspace logs. If the product surface does not expose a stable snapshot identifier, record that limitation explicitly so future reviewers understand why exact reproduction may be constrained.

The prompt version should be treated like source code. Store it in version control or another change-managed system, assign a version ID, and record the exact output format expected. If the prompt includes examples, diagrams, routing rules, or JSON schemas, those are part of the evaluated artifact. A prompt that changes from “extract every visible total” to “summarize the visible invoice” is not a minor edit; it changes the task definition.

The image hash protects against accidental evidence drift. A recommended operational pattern is to compute a hash over the exact file bytes supplied to the model, then separately record any human-readable metadata such as dimensions, file type, capture device, redaction method, and preprocessing steps. If the input is a screenshot captured from an interactive tool state, store the screenshot and the state record together.

Recommended evaluation manifest fields:

evaluation_id: "vision-postfix-2026-09-25-sol-luna"
task_family: "chart_reading | classification | extraction | screenshot_interpretation | computer_use"
model_name: "GPT-6 Sol or GPT-6 Luna"
model_snapshot: "record if exposed; otherwise state not exposed by the product surface"
prompt_version: "prompt-regression-v3.2"
image_sha256: "hash of exact evaluated image bytes"
image_dimensions: "width x height"
image_preprocessing: "none | crop | resize | redaction | compression"
tool_surface: "API | Codex | other approved environment"
tool_state_id: "browser/app/session fixture identifier"
review_rubric_version: "rubric-v1.4"
trial_count: 5
approval_mode: "simulation only | human approval required for external action"
stop_conditions: "credential request, destructive step, external submission, payment, legal commitment, unsafe instruction"

This manifest does not need to expose confidential content. It can reference secure internal artifact IDs, hashes, and redacted screenshots while keeping protected data in an approved evidence store. The key requirement is that an auditor or incident reviewer can reconstruct what was tested without relying on memory or a dashboard that may later roll over.

Classification Tasks: Measure Label Stability, Not Just Top-Line Accuracy

Image classification tests are often the easiest to rerun after an image-understanding fix, but they can be misleading if the team only counts final labels. A useful classification evaluation records whether the model saw the same visual cue, whether it selected the correct class, whether it expressed uncertainty appropriately, and whether it confused neighboring classes that matter operationally.

For example, a support workflow may classify screenshots as “billing page,” “login error,” “permission error,” or “unknown.” A post-fix improvement from “unknown” to “billing page” may be valuable, but a change from “permission error” to “login error” could route a customer to the wrong team. The confusion matrix matters more than a single aggregate score because adjacent labels often have different escalation, privacy, or compliance implications.

A conservative acceptance threshold should include both accuracy and stability. A team might require that the post-fix run improves or maintains accuracy, reduces high-risk confusions, and does not increase unsupported certainty. If the model becomes more confident while still wrong on small text, low-contrast icons, or crowded screenshots, that is not an acceptable regression result for production routing.

Extraction Tasks: Score Fields, Evidence, and Format Separately

Extraction workloads should separate field correctness from evidence grounding and output format. An invoice total, a case number, a lab value, or a form date can be visually present but still extracted into the wrong field, normalized incorrectly, or returned without enough evidence for a human reviewer. The September 25 fix is a reason to retest image understanding; it does not remove the need for field-level validation.

For structured extraction, create a fixture table with required fields, optional fields, accepted normalizations, and prohibited inferences. If the image does not show a value, the expected output should be “not visible” or the equivalent schema value, not a guessed value from context. This distinction is especially important for documents where prior workflow logic, filenames, or surrounding text could tempt the model to fill gaps that the image itself does not support.

Example extraction scoring rubric:

2 = Exact field value, correct normalization, and visible evidence reference
1 = Semantically correct value with minor formatting issue that downstream systems tolerate
0 = Missing value when visible, incorrect value, wrong field, or unsupported inference
N/A = Field not visible in the image and correctly marked not visible

Extraction evaluations should also include adversarially ordinary cases: rotated receipts, screenshots with overlapping modals, faint table gridlines, scanned pages with skew, labels near but not aligned with values, and redacted documents where the correct answer is that a field cannot be read. These are not “trick” cases if they resemble production inputs; they are the cases most likely to expose whether image handling, OCR-like reading, and layout reasoning are robust enough for the workflow.

For regulated or high-stakes uses, do not let a post-fix extraction improvement automatically write to downstream systems. Use a two-step pattern: the model extracts into a review queue, then a human or deterministic validator confirms the fields before any record update, customer communication, filing, or payment-related operation. That pattern keeps the evaluation focused on visual extraction while preserving approval for consequential outcomes.

Chart Reading: Test Visual Perception, Data Reasoning, and Narrative Discipline

Chart reading is a special case because the model must often combine visual perception with numerical estimation and narrative explanation. The evaluation should score these layers separately: chart type recognition, axis and legend interpretation, approximate value reading, trend comparison, uncertainty expression, and refusal to invent data not shown. A post-fix model may better identify plotted elements while still overstating precision from a low-resolution chart.

Build chart fixtures from real categories your organization uses, such as product analytics dashboards, finance summaries, reliability graphs, education progress reports, or legal discovery timelines. Include bar charts, line charts, stacked bars, scatterplots, heatmaps, and screenshots with multiple panels. If your production workload includes dark mode dashboards or compressed images in tickets, include those exact formats rather than only clean exported charts.

A practical before-and-after chart test should include at least one “no answer” case, such as a chart with a missing axis label or an unreadable legend. The correct behavior is to state the limitation and request the underlying data or a higher-resolution image. If the post-fix model becomes more willing to answer unreadable charts, that should be treated as a safety and reliability concern even if it sounds more helpful.

Screenshot Interpretation: Preserve UI State and Reviewer Context

Screenshot interpretation tests should be anchored in the exact interface state. A screenshot of an admin console, customer support ticket, educational platform, legal research tool, or code review page can change meaning based on selected filters, user role, feature flags, workspace policy, browser zoom, and hidden panels. Record those conditions in the fixture rather than assuming that the pixels tell the whole story.

The evaluation should ask the model to describe visible elements, identify likely next steps, and state what cannot be concluded from the screenshot alone. For example, it may be reasonable to identify that an “Export” button is visible, but not to infer that the current user is authorized to export confidential data. It may be reasonable to say a warning banner is present, but not to claim that the underlying account is compromised unless the screenshot directly supports that conclusion.

Reviewer agreement is particularly important for screenshot tasks because humans may disagree about what is salient. Use at least two reviewers for high-impact workflows, define whether partial credit is allowed, and require an adjudicator for conflicts. If reviewers cannot agree on the correct interpretation of a screenshot, do not expect a model evaluation to produce a decisive production approval.

Recommended screenshot prompt pattern for evaluation:

Task:
Describe only what is visible in the screenshot and answer the requested question.
If a detail is not visible, say "not visible."
Do not infer permissions, account status, user intent, legal effect, security status, or financial outcome unless it is explicitly shown.
Return:
- visible_ui_elements
- answer
- evidence_from_screenshot
- uncertainty_or_missing_context
- recommended_human_review_if_needed

This prompt pattern is an example for evaluation design, not a claim about official product behavior. Teams should adapt it to their own output schema and safety rules, then lock the version before running comparisons across GPT-6 Sol or GPT-6 Luna.

The article explains how the Codex Chrome extension functions as a browser agent for enterprise web automation. The Codex Chrome Extension: How OpenAI’s Browser Agent Changes Web Automation for Enterprise Teams article is a focused companion for Browser Agent Safety because it directly covers browser-agent operation in Codex, providing relevant context for safety concerns around browser automation after vision fixes.

Computer-Use Tasks: Simulate Actions Before Allowing Real Execution

Computer-use evaluations require more than asking whether the model “understands the screen.” They must test perception, planning, coordinate selection, tool invocation, state monitoring, error recovery, and approval discipline. OpenAI’s computer-use documentation is the relevant official source for tool-based visual interaction, but the September 25 changelog should be read as a reason to rerun affected visual workflows, not as a statement that computer-use actions are now safe without supervision.

The safest evaluation structure is simulation first. In a simulated run, the model can identify the element it would click, describe the intended action, and produce a proposed action trace, while the harness blocks actual external submission, publication, deletion, purchase, booking, payment, permission change, or message sending. Only after simulated perception and planning meet the acceptance threshold should teams consider supervised execution in a non-production or low-risk environment.

Computer use still needs supervision for consequential actions. Human approval is mandatory before external messages, submissions, payments, purchases, bookings, destructive changes, permission changes, publication, legal commitments, campaign launches, or any operation that can materially affect a person, account, system, record, or organization. This requirement should be enforced by the surrounding application and operating procedure, not delegated solely to the model’s judgment.

Repeated Trials: When One Run Is Not Enough

Repeated trials are necessary when outputs can vary, when visual inputs are ambiguous, or when the workflow includes multiple steps. A one-shot pass on a screenshot does not establish that the task is stable enough for production; it only shows that one path worked once. For post-fix evaluation, repeated trials help distinguish a real improvement from random variation, prompt sensitivity, or reviewer optimism.

A practical trial plan can use different levels of repetition by task risk. Low-risk classification might use three trials for borderline examples and one trial for clear examples. Extraction from business records may use three to five trials for each fixture. Computer-use plans that include multi-step navigation should use repeated simulated traces before any supervised live run. Higher-risk domains should increase repetition and require stronger reviewer agreement rather than lowering thresholds for convenience.

Repeated trials should not be used to cherry-pick the best answer. Decide in advance how to aggregate results: majority vote, worst-case score, mean field accuracy, pass-if-all-critical-fields-pass, or pass-if-no-high-risk-failures. For consequential workflows, the worst credible failure often matters more than the average because a single wrong submission or destructive click can be unacceptable.

Example repeated-trial aggregation rules:

Classification:
Pass if at least 4 of 5 trials select the gold label and no trial selects a high-risk prohibited label.

Extraction:
Pass if every critical field is correct in all trials; optional fields may use average score if downstream review exists.

Chart reading:
Pass if trend direction and units are correct in all trials; approximate values must stay within the accepted tolerance.

Computer use:
Pass simulation only if every trial selects the safe next action, verifies state, and stops before approval-gated operations.

If a model succeeds on some trials and fails on others, keep the fixture in the evaluation set. Flaky cases are valuable because they reveal brittleness in visual interpretation, prompt framing, state handling, or action planning. Removing them because they are “messy” makes the evaluation less representative of real operations.

Reviewer Agreement: Make Human Judgment Auditable

Human reviewers are part of the evaluation system, so their agreement must be measured or at least documented. For classification and extraction, reviewers can often use deterministic answer keys. For charts, screenshots, and computer-use plans, reviewers may need a structured rubric and an adjudication process. The goal is not to make every judgment mathematical; it is to prevent post-fix conclusions from depending on one person’s informal impression.

For each task family, define who is qualified to review. A frontend engineer may be well suited to judge UI element targeting, while a finance operations reviewer may be needed for invoice field extraction, and a legal-technology professional may be needed to review document workflow outputs. Sensitive domains require reviewers who understand both the workflow and the harm of overclaiming what the image shows.

Reviewer disagreement should be preserved as evidence rather than smoothed away. If two qualified reviewers disagree, the artifact may be ambiguous, the rubric may be underspecified, or the workflow may be too risky for automation. Any of those findings is useful, and none should be hidden behind a single aggregate score.

Action Simulation and Approval Gates for Browser, Desktop, and Codex Workflows

Action simulation should be the default for browser-agent, desktop, and Codex visual workflows after the Sol and Luna fix. In simulation mode, the system records what the model would do without allowing the action to affect external state. This is especially important for workflows that interact with admin consoles, issue trackers, code repositories, customer records, financial dashboards, education systems, legal matter systems, or production monitoring tools.

A safe action simulation record includes the observed screen state, the model’s proposed next action, the target element, the reason for the action, the expected result, the approval category, and the stop condition if approval is required. The record should be reviewable by a human who can decide whether the action would have been appropriate. For computer-use testing, this record often matters more than the final answer because it shows whether the model maintained control discipline throughout the process.

Example computer-use simulation trace schema:

step_number: 4
observed_state: "Settings page with user-management panel visible"
proposed_action_type: "click"
proposed_target: "Invite user button"
visual_evidence: "button text visible in upper-right panel"
expected_state_change: "open invitation dialog"
approval_category: "permission or account-management workflow"
execution_allowed: false
required_human_approval: true
stop_reason: "inviting or changing user access is consequential"

Approval gates should exist outside the prompt because prompts can be misunderstood, omitted, or changed. A workflow should block consequential actions at the tool, application, orchestration, or policy layer until an authorized human approves. The model can prepare a draft, explain evidence, or recommend a next step, but the surrounding system must enforce the point at which review becomes mandatory.

For Codex-related visual tasks, action simulation should also distinguish between reading a screenshot, proposing a code change, editing a local file, running a command, and submitting a pull request. A visual improvement may help the model interpret an error screenshot or UI state, but it does not by itself authorize repository changes, elevated commands, external submissions, or production deployment.

Stop Conditions That Should End the Run Immediately

Stop conditions prevent an evaluation from turning into an uncontrolled live operation. They should be explicit, automated where possible, and reviewed before the run begins. A stop condition is not a failure of the evaluation process; it is evidence that the process detected a boundary where human control is required.

• Credential exposure or request: Stop if the workflow asks for, displays, copies, or attempts to store passwords, API keys, tokens, private keys, session cookies, or unnecessary personal identifiers.
• External submission: Stop before sending emails, chat messages, support replies, legal filings, forms, tickets to external parties, or customer-visible updates.
• Financial or commercial action: Stop before purchases, refunds, payments, bookings, bid changes, campaign launches, subscription changes, or pricing changes.
• Destructive or hard-to-reverse change: Stop before deleting records, modifying permissions, changing production configuration, merging code, rotating secrets, or altering retention settings.
• Professional or regulated judgment: Stop before legal, medical, financial, employment, education, insurance, or safety-impacting conclusions are acted on without qualified review.
• Unexpected state: Stop if the screen, app, repository, or tool state differs from the fixture or from the model’s expected post-action observation.
• Policy or authorization uncertainty: Stop if the model cannot establish that the requested action is within the authorized evaluation scope.

These stop conditions should apply even when the post-fix model appears to perform better. The purpose of the image-encoding repair is to improve degraded image understanding in the affected models; it is not a waiver of authentication, authorization, change management, safety review, or domain-specific professional obligations.

Acceptance Decisions: Promote, Hold, Retry, or Roll Back

After the rerun, teams should make a decision using predeclared thresholds rather than a narrative impression. Four decision labels are usually enough: promote, hold, retry, or roll back. “Promote” means the post-fix evidence meets the acceptance threshold for a defined scope. “Hold” means the evidence is incomplete or mixed. “Retry” means the workflow likely suffered from the image-encoding issue but needs a corrected fixture or controlled rerun. “Roll back” means the workflow should remain disabled or routed to a safer model, manual process, or previous approved path until failures are understood.

Rollout Discipline After the Fix: Canary First, Then Evidence-Based Expansion

OpenAI’s changelog recommendation to rerun evaluations and retry affected workflows should be implemented as a controlled rollout, not as a blanket assumption that previously unreliable visual behavior is now safe. A canary rerun is a small, pre-approved rerun of representative visual and computer-use tasks against GPT-6 Sol or GPT-6 Luna after the September 25 image-encoding fix, using retained prompts, images, expected outputs, scoring rules, and reviewer notes. The canary should be narrow enough to inspect manually, but broad enough to include the image patterns that mattered in production: screenshots, scanned documents, UI states, charts, diagrams, photos, forms, or Codex computer-use sessions that previously showed degraded image understanding.

A practical canary should include three groups of fixtures. The first group contains tasks that failed during the suspected exposure window and have retained evidence, such as the original image, prompt, model name, timestamp, tool configuration, output, and reviewer decision. The second group contains tasks that passed and should remain stable, because a fix that improves one class of visual interpretation can still expose prompt brittleness or downstream assumptions. The third group contains fresh but similar tasks that were not part of the original incident, because teams need to know whether the current workflow generalizes beyond the remembered failures.

The canary rerun should not be run against live consequential systems unless the task has been reduced to observation-only mode or placed behind explicit human approval. For computer-use workflows, this means capture screenshots, ask the model to describe the intended action, compare the proposed target and rationale with the expected answer, and require a human operator before any external message, submission, purchase, permission change, publication, booking, destructive command, or legal commitment. OpenAI’s computer-use guidance is relevant because visual interpretation is only one step in a chain that may include coordinate selection, tool invocation, application state, and authorization policy.

Use a written canary charter before executing the rerun. The charter should state the affected model or models, the product surface, the fixture count, the scoring method, the stop conditions, the reviewers, the permitted retry budget, the rollback path, and the person authorized to approve wider use. This document prevents the common failure mode in which a team reruns a few memorable examples, sees improved answers, and silently resumes production without enough evidence to detect residual issues.

Discrepancy Triage: Explain Differences Before You Trust Them

Discrepancy triage is the process of classifying every meaningful difference between the original result, the post-fix rerun, the expected answer, and the reviewer judgment. The goal is not to prove that the old answer was caused by the OpenAI-reported bug; the available official fact is narrower. OpenAI says an image-encoding bug degraded image understanding in GPT-6 Sol and GPT-6 Luna and affected visual tasks in the API and Codex, including computer use. A local team can only determine whether its retained evidence is consistent with that class of failure, whether post-fix behavior is acceptable, and whether remaining failures belong to another layer.

Start discrepancy triage with an evidence packet for each task. The packet should include the original image or screenshot, any preprocessing steps, prompt and system instructions, model name, tool settings, application state, expected answer, old output, new output, scoring notes, and reviewer conclusion. If the workflow involved Codex or computer use, add the proposed action, coordinate or UI target, approval decision, execution log if any, and final system state. Do not paste credentials, private keys, tokens, account numbers, health information, privileged material, or unnecessary confidential content into the packet.

A useful triage label set should distinguish at least six outcomes. Resolved visual interpretation means the post-fix answer correctly identifies the relevant visual content and meets the task contract. Unchanged visual failure means the model still misreads or misses visual content that a reviewer considers visible. New regression means a previously acceptable fixture now fails. Downstream reasoning error means the visual facts are identified but the conclusion is wrong. Execution or coordinate error means the intended visual target is right but the tool action is wrong or unsafe. Insufficient evidence means the retained materials are too incomplete to support a confident conclusion.

Do not collapse discrepancy triage into a single pass/fail status. For example, if a model now reads a button label correctly but proposes clicking it before a required human approval, the visual layer may be improved while the workflow remains blocked. If a chart label is now transcribed correctly but the narrative summary overstates the trend, the image-understanding issue may be separate from data-reasoning discipline. If a screenshot rerun differs because the application changed layout, the result cannot be used as clean evidence about the September 25 fix without noting the environmental change.

The article presents an AI misuse incident-response playbook covering stolen API keys, agentic cyber operations, detection, containment, and evidence handling. The AI Misuse Incident Response Playbook: Stolen API Keys, Agentic Cyber Operations, Detection, Containment, and Evidence article is a focused companion for Evidence Based Incident Review because the marker calls for an evidence-based incident review, and this target specifically focuses on incident response and evidence practices for AI-related events.

Retry Policy: When to Reattempt Workflows and When to Stop

A retry policy defines which affected workflows may be reattempted after the fix, who may authorize the retry, what evidence must be retained, and when retries must stop. OpenAI recommends retrying workflows affected by the issue, but that recommendation does not remove the need for local risk controls. A failed image task that merely generated an internal draft can be retried under lighter controls than a task that could submit a filing, send a customer message, modify code, approve access, or operate a live application.

Classify retry candidates by consequence. Low-consequence retries include internal labeling, draft descriptions, non-binding summarization, and offline extraction from non-sensitive fixtures. Medium-consequence retries include work that may influence a user decision, support ticket, business analysis, classroom material, or developer workflow but still receives human review before action. High-consequence retries include legal, financial, health, employment, education, security, identity, external communication, production deployment, permission management, or destructive operations. High-consequence retries should require explicit owner approval, additional review, and a documented fallback path.

The retry budget should be limited. Repeatedly rerunning the same image until the model gives an acceptable answer is not a reliable validation strategy unless the workflow itself is designed to use multiple samples with a documented aggregation rule and human review. For most production tasks, set a maximum number of attempts, require the same input evidence to be preserved, and treat inconsistent answers as a signal requiring triage rather than as an invitation to select the best-looking output.

Recommended retry policy template

Scope:
- Models: GPT-6 Sol and/or GPT-6 Luna only where the workflow used visual input.
- Surfaces: API, Codex, computer-use, or internal multimodal tools affected by retained evidence.
- Exclusions: consequential actions without human approval; tasks lacking enough evidence to compare.

Retry classes:
- Class A: Internal, non-consequential, offline tasks. Owner approval required.
- Class B: User-facing draft or operational support tasks. Reviewer approval required before use.
- Class C: Legal, financial, health, security, access, production, or external-action tasks. Executive or designated control owner approval required; simulation first.

Attempt limit:
- One baseline post-fix rerun for every selected fixture.
- One additional rerun only if the evaluation contract permits repeated trials.
- Escalate inconsistent outputs to discrepancy triage.

Stop conditions:
- Wrong visual target in a computer-use task.
- Missing required approval step.
- New regression on a previously passing fixture.
- Any request for secrets, unnecessary personal data, privileged content, or policy bypass.
- Reviewer cannot determine correctness from retained evidence.

For Codex workflows, retry policy should also consider repository state and permission boundaries. A visual failure in a computer-use or development task can combine with filesystem writes, command execution, network access, or tool calls. Keep retries in a branch, sandbox, staging project, or read-only environment where possible. Require Git checkpoints before and after code-affecting tasks, and do not treat a model’s improved visual description as permission to bypass review of generated code, shell commands, dependency changes, configuration edits, or deployment scripts.

Regression Ledger: Keep an Audit Trail That Future Teams Can Use

A regression ledger is a durable record of affected visual tasks, rerun evidence, discrepancies, decisions, and follow-up actions. It is more structured than a chat thread and more operational than a postmortem narrative. The ledger helps developers, security teams, administrators, educators, legal-technology teams, and product owners understand which workflows were evaluated after OpenAI’s fix and which workflows remain blocked, risky, or untested.

The ledger should avoid sensitive raw content unless retention is approved and necessary. Store references, hashes, redacted excerpts, or controlled-access evidence IDs when possible. For example, a legal-technology team can record that a scanned exhibit fixture failed small-text extraction and link to a matter-controlled evidence repository instead of copying privileged text into a general engineering tracker. A school or parent-facing application can record that an image classification task involved youth-safety review without duplicating student identifiers or private images in a broad-access issue.

The ledger should include a specific field for “evidence limitations.” This is where teams record that the original screenshot was missing, the application UI changed, the prompt was not versioned, the image was recompressed, the user’s environment differed, or the task was too subjective to score. Evidence limitations are not administrative clutter; they are the difference between a credible incident review and a retrospective story that cannot be verified.

Incident Communication: Tell Users What Changed Without Overclaiming

Incident communication is the controlled message to affected internal teams, customers, administrators, or end users explaining what is known, what is being evaluated, what actions are paused or resumed, and where human review remains required. The message should attribute the source carefully: OpenAI’s changelog reports a fix for an image-encoding bug that degraded image understanding in GPT-6 Sol and GPT-6 Luna and affected visual tasks in the API and Codex, including computer use. Your organization’s communication should not state that every local error was caused by that bug unless your own evidence supports that narrower conclusion.

For internal engineering teams, the communication should be action-oriented. Identify the affected workflows, the canary rerun schedule, the retry policy, the ledger location, and the escalation path for discrepancies. Tell developers not to delete old outputs, overwrite screenshots, or silently regenerate results that were part of customer-impacting work. If your organization has compliance obligations, coordinate with legal, security, privacy, and records teams before broad notification or evidence disposal.

For customer-facing or user-facing communication, avoid technical speculation and avoid guarantees. A responsible message can say that the team is reevaluating certain visual workflows after OpenAI reported and fixed an issue affecting image understanding in specified models. It can explain whether user action is needed, whether any outputs should be reviewed again, and whether the product has paused or limited particular features while checks proceed. It should not promise universal improvement, perfect recognition, or retrospective correction of previously generated outputs.

Sample internal incident update: OpenAI has reported a September 25 fix for an image-encoding issue that degraded image understanding in GPT-6 Sol and GPT-6 Luna, including visual tasks in the API and Codex such as computer use. We are running a controlled canary across retained visual fixtures and will not expand affected workflows until discrepancies are triaged and the workflow owner signs off. Do not rerun or replace incident-related outputs outside the evaluation plan. Continue requiring human approval for external messages, submissions, permission changes, production actions, and other consequential operations.

If the workflow involves legal technology, education, youth-facing experiences, accessibility, security operations, or enterprise administration, communication should explicitly preserve professional review. A fixed image-encoding path does not convert model output into legal advice, a medical judgment, a security authorization, an accessibility certification, or an educational placement decision. Human experts remain responsible for consequential interpretation, policy compliance, and final action.

Deployment Gate: Define the Evidence Needed to Resume Wider Use

A deployment gate is the formal decision point that determines whether an affected workflow can move from canary to wider use. The gate should be tied to the workflow’s risk, not to a general belief that the model is better after the fix. A low-risk internal image-captioning utility may require a modest fixture pass rate and reviewer sign-off. A computer-use workflow that interacts with external websites, customer records, production systems, or administrative controls should require stricter evidence, simulation, approval logs, and rollback readiness.

The deployment gate should evaluate at least five categories. First, visual interpretation must meet the task-specific contract on representative fixtures. Second, output structure must meet downstream parser or reviewer expectations. Third, action selection must be correct in simulation before execution is allowed. Fourth, safety and policy checks must trigger when ambiguity, protected data, or consequential actions appear. Fifth, monitoring and fallback must be ready before traffic expands.

Use gates that can fail. A gate that always results in “monitor and proceed” is not a control. For example, require rollback if any high-severity fixture fails, if more than a defined number of medium-severity discrepancies appear, if reviewer agreement is poor, or if a computer-use task proposes an action outside its approved scope. The exact thresholds should be set by the workflow owner, risk team, and domain reviewer before running the evaluation, because thresholds chosen after seeing results are easier to rationalize.

Fallback and Rollback: Keep a Safe Path When Vision Remains Uncertain

A fallback is a planned alternative used when the preferred GPT-6 Sol or GPT-6 Luna visual workflow is not ready for a particular task. A fallback might be manual review, a non-visual data source, a narrower prompt that asks only for evidence extraction, a rule-based validator, a human-in-the-loop queue, or a temporary feature limitation. Fallback is not a failure of adoption; it is an operational control for cases where visual ambiguity, sensitive context, or consequential action makes automation inappropriate.

A rollback is a reversal of a deployment decision after evidence shows unacceptable behavior. Rollback can mean disabling a feature flag, reverting a prompt version, returning to a previous workflow, blocking computer-use execution, routing all affected cases to manual review, or restoring a prior integration configuration. Because OpenAI’s fix does not guarantee reliability for every visual task, rollback must remain available even after a successful canary.

Fallback should be selected per failure layer. If small text remains unreliable, route the task through a human reviewer or a specialized extraction step rather than asking the model to infer missing details. If coordinate selection is unreliable, allow the model to describe a target but require a human click. If policy classification is uncertain, block the workflow until a reviewer decides. If the application state changes too quickly for computer use, pause automation and add state checks or simulation fixtures before trying again.

Rollback should be rehearsed before expansion. The owner should know which configuration disables the workflow, which queue receives held tasks, how users are notified, where pending outputs are quarantined, and how to prevent partially completed actions from continuing. For Codex-related workflows, rollback planning should include repository state, generated diffs, branch cleanup, dependency changes, execution logs, and any approval records associated with elevated commands or tool use.

Ongoing Sampling: Do Not Stop Testing After the First Passing Rerun

Ongoing sampling is the periodic review of live or near-live workflow outputs after the deployment gate has passed. It exists because a post-fix canary is only a snapshot. Inputs change, screenshots change, applications redesign interfaces, users provide lower-quality images, prompts drift, policy settings change, and model availability or behavior can vary by product surface, account, workspace, plan, region, and rollout. Sampling should continue for as long as the workflow depends on visual interpretation for meaningful decisions.

The sampling plan should specify rate, selection logic, reviewers, severity labels, and escalation rules. A practical plan might sample all high-consequence visual tasks for a defined stabilization period, a percentage of medium-consequence tasks, and targeted examples from newly changed UI surfaces or document types. Sampling should include negative cases as well as successful outputs, because teams learn more from borderline examples than from clean confirmations.

Reviewers should not only ask whether the final answer was acceptable. They should record whether the model cited visible evidence, whether it ignored ambiguous regions, whether it confused similar UI elements, whether it complied with approval boundaries, and whether downstream tools behaved as expected. This matters for computer-use workflows because the same final answer can mask different risks: one run may be correct because the image was understood, while another may be correct by chance despite a poor target rationale.

Sampling should feed the regression ledger. When reviewers find a new failure, add it as a fixture, label the failure layer, and decide whether it changes the deployment state. If repeated failures cluster around a document format, device resolution, browser zoom level, language, chart style, or application view, update the evaluation suite rather than treating each case as isolated. The evaluation suite should become more representative over time, not merely larger.

Operational Checklist for the Next 72 Hours

The first 72 hours after recognizing exposure to the image-encoding issue should focus on containment, evidence preservation, and controlled evaluation. Teams that already completed some reruns should still compare their work against this checklist, because the most common incident-review mistakes are missing original evidence, failing to distinguish failure layers, and resuming automation without a rollback path.

1. Confirm scope: Identify visual workflows that used GPT-6 Sol or GPT-6 Luna in the API, Codex, or computer-use contexts during the relevant period for your organization.
2. Freeze evidence: Preserve prompts, images, screenshots, outputs, logs, reviewer notes, and application state references before rerunning anything.
3. Create the canary set: Select failed, passed, and fresh representative fixtures covering the visual patterns that matter to the workflow.
4. Write scoring rules: Separate visual interpretation, extraction, reasoning, coordinates, tool execution, output format, and policy behavior.
5. Run in safe mode: Use read-only, simulated, staging, or approval-gated execution for computer-use and Codex workflows.
6. Triage discrepancies: Classify differences as resolved visual interpretation, unchanged failure, new regression, downstream reasoning error, execution error, or insufficient evidence.
7. Apply retry limits: Do not repeatedly regenerate until an acceptable answer appears; treat inconsistency as a finding.
8. Update the ledger: Record evidence IDs, model, surface, fixture type, score, failure layer, reviewer, and decision.
9. Communicate status: Tell affected teams what is paused, what is being rerun, what remains approval-gated, and who can approve expansion.
10. Gate deployment: Promote, hold, fallback, or rollback based on predefined thresholds and accountable owner sign-off.
11. Start sampling: Continue reviewing a defined portion of outputs after promotion, especially high-consequence or newly varied inputs.

Conclusion: Treat the Fix as a Trigger for Better Evidence, Not a Blanket Green Light

OpenAI’s September 25 changelog entry gives affected teams a clear reason to act: GPT-6 Sol and GPT-6 Luna had an image-encoding bug that degraded image understanding, and OpenAI recommends rerunning evaluations and retrying affected workflows. The responsible operational response is not to assume that every prior failure is explained, every current output is correct, or every computer-use action is now reliable. The response is to preserve evidence, rerun representative fixtures, triage discrepancies, retry within limits, and use deployment gates that can actually hold, fallback, or rollback a workflow.

For developers and founders, the immediate value is a cleaner path to decide whether visual features can resume. For enterprise administrators and security teams, the value is an auditable process that keeps approvals, permissions, and rollback intact. For knowledge workers, educators, parents, and legal-technology professionals, the key point is that improved image understanding does not eliminate the need for qualified human review in consequential contexts. For advanced ChatGPT, Work, and Codex users, the fix is a reminder that multimodal systems are pipelines: image encoding, visual interpretation, prompt design, tool use, application state, policy, and human approval each need their own evidence.

The safest teams will come out of this event with more than a passing rerun. They will have a regression ledger, representative fixtures, clearer retry rules, better incident communication, stronger deployment gates, and ongoing sampling that catches future drift before it becomes a user-facing failure. That is the durable lesson of the fix: evaluate the workflow, not just the model response.

Useful Links

• OpenAI API changelog
• GPT-6 Sol model documentation
• GPT-6 Luna model documentation
• OpenAI evals guide
• OpenAI computer-use tools guide