July 24, 2026
In one reported Codex-view case, ChatGPT performance collapsed inside a heavy visual thread. The title figures are two observations from one staged, confounded Windows reproduction inside the ChatGPT desktop app. A window containing two images opened in 21.7 seconds, while a different window containing 40+ images opened in 313.7 seconds.
What the ChatGPT performance restore test actually showed# A staged Windows reproduction measured the ChatGPT desktop app's Codex view. Its first window held two images and opened in 21.7 seconds. The fifth held 40+ images and opened in 313.7 seconds.
Both the measurement and the later rollout mechanism come from issue reports about that Codex view. The reports do not establish whether Chat and Work behave the same way. They cannot establish a ChatGPT-wide mechanism.
Across the five stages, model, search usage, session profile, record count, and opening order changed. A short window with zero images still took 67.4 seconds. Treat the result as a bounded case study.
Read the chart in test order. Restore times ranged from 17.9 to 313.7 seconds across five different windows. The variation is real inside this reproduction, while the changing stages prevent an image-count rule.
A ChatGPT restore time becomes actionable when the delay blocks work. If one thread freezes, scrolls badly, or reconnects while a fresh text chat stays responsive, use that contrast as a low-risk diagnostic. Move the work without claiming the issue report proves the cause.
Note:The May 2026 report describes one Windows setup and changing test stages. It supplies observations. Current product guarantees and safe limits remain outside its scope.
Is the Thread Heavy, or Is ChatGPT Simply Answering Slowly?# The phrase “ChatGPT desktop app slow” hides three different problems. Restore work happens when the app selects and rebuilds a conversation. Answer latency happens after you send a prompt.
- Thread restore: one known conversation freezes on selection, stutters while scrolling, or reconnects repeatedly.
- Answer latency: several chats open normally, but replies take longer to begin or finish.
- System pressure: ChatGPT and unrelated apps both become sluggish while CPU, RAM, or disk activity stays busy.
Run the cheapest isolation test first. Check OpenAI service status through the official troubleshooting flow, restart the desktop app, then open a brand-new chat. Send one ordinary text prompt without attaching an image.
When the fresh chat works and the old visual thread fails, the thread becomes the useful working hypothesis. High CPU or RAM during its restore is a supporting symptom. Skip process-priority tweaks, memory assignments, and arbitrary Task Manager percentages.
Use the operating system's resource view for a simple comparison. Watch ChatGPT while it sits idle and again when you select the suspect thread. Use a fresh text chat as the control. Fresh chats failing too widens the diagnosis. Restart the machine if other apps are struggling, test another supported surface, and follow OpenAI's response-latency checks. That path separates a ChatGPT slow conversation from an account, service, network, or machine-wide problem.
TL;DR:If one old thread fails while fresh text chats work, hand off the work. Failures across fresh chats call for broader troubleshooting.
One reported multiplier: inline image payloads# Visible thread length is a poor proxy for retained size. One issue reporter measured a 747 MB rollout containing 2,164 records. Replacing only embedded image payloads with placeholders reduced it to 2.3 MB while preserving the records and metadata.
In that 747 MB to 2.3 MB case, inline image data dominated the affected record's size. The report retained its text records and metadata during the measurement.
How a few visual turns can leave a large retained record
The diagram stays inside that reported Codex rollout. A few visual turns can retain large inline payloads, making the local record far larger than the visible conversation suggests. The report does not establish whether Chat and Work behave the same way.
For this reported ChatGPT image storage case, the practical lesson is modest. Control what you carry forward. Hidden-file edits remain risky and unsupported. Pasting the full text transcript defeats context compression and can lengthen the replacement chat's context. Reattaching historical screenshots recreates visual payload. They carry different costs, and a compact handoff reduces both.
Practical warning signs beat magic limits# You will find tempting numbers in issue reports. Resist turning them into rules. Different builds, operating systems, models, thread shapes, and failure modes produced different results.
One Windows report described a crash neighborhood around 512 MB on two affected builds. That observation does not define a ChatGPT conversation limit.
My decision rule is behavioral. After one normal restart attempt, move when a reproducible thread-specific failure materially blocks work while a fresh text chat remains responsive. Restarting comes from OpenAI's troubleshooting guidance, and the evidence supplies no restart-count threshold.
- Selecting the thread takes long enough to interrupt your working rhythm.
- Scrolling or typing inside that thread freezes while a fresh chat remains smooth.
- The app cycles through reconnect attempts only after the heavy thread opens.
- CPU, RAM, or disk activity jumps with that restore and settles after you leave it.
- A second attempt reproduces the same thread-specific failure.
This approach costs nothing and avoids fake precision. It also adapts when a future app build changes storage or renderer behavior.
Move when the thread is no longer usable, regardless of whether it reaches 40+ images or a 313.7-second restore.
Test the old thread once after the normal restart. Repeated reopening adds restore work and risks another freeze. The fresh text chat already gives you a diagnostic control and a recovery surface.
Archiving organizes the sidebar. No source here shows it repairs performance. OpenAI's archive and delete guidance says an archived chat remains in your account, while deletion is irreversible.
Move the Work Without Losing the Useful Context# A disciplined handoff can make a fresh chat useful without replaying the old thread. Preserve the decisions. Leave the chronology behind.
If the old thread has become inaccessible, reconstruct the handoff from memory and current files. Perfect context is less valuable than a responsive workspace. Avoid reopening an unusable thread in search of one missing detail. Build the handoff as a short text packet with these fields.
- Goal: [one-sentence outcome]
- Accepted decisions: [choice plus reason]
- Rejected options: [option plus reason]
- Current state: [finished, broken, most recent change]
- Constraints: [requirements, tools, deadlines, forbidden approaches]
- Asset locations: [your own filename or location reference]
- Open questions: [decisions still unresolved]
- Next action: [the first task for ChatGPT]
Keep each field to a few lines. If a decision needs a page of history, compress it into the decision, the reason, and the evidence that could reverse it. This structure gives the new chat enough state to act without inheriting the visual backlog.
A filename or location in the handoff is for your own reference. Attach the smallest current set when the next step requires visual inspection.
Tip:A useful handoff sounds like this: “Goal: fix the mobile header. Accepted: keep the current type scale. Current defect: the menu overlaps at 390 pixels. Asset: latest screenshot named mobile-header-current. Next action: compare that screenshot with the stated spacing rules.”
Then move in four steps.
- Open a fresh chat and paste the text handoff before adding media.
- Ask ChatGPT to restate the goal, constraints, and first action in a compact reply.
- Correct any missing context in text. Leave the old transcript behind.
- Attach the smallest set of images needed for the next decision.
That final constraint matters for ChatGPT image-heavy threads. Supply the current screenshot, the expected result, and a sentence naming the regression. Add an older frame only when the comparison can change the next decision.
Preserve the rest of the visual history in your own project folder, photo library, or version history. The replacement chat receives the evidence needed now. Your external archive keeps earlier drafts available without them into every session.
Keep the old thread as a reference if it still opens. If preservation matters more than immediate access, ChatGPT data export can include chat history, but delivery can take up to seven days. Export serves as a backup path and cannot speed up the current thread.
Keep the Next Visual Thread Light# The free optimization lives in your working habit. No hidden setting is required. Use one thread for the current visual decision, then write a text checkpoint when the decision lands.
For image generation, keep the accepted image and describe why rejected versions failed. For visual QA, carry the latest screenshot plus the expected behavior. Save historical drafts externally and retrieve one when its comparison matters.
- Attach the smallest set of current images that can change the next decision.
- Write stable asset names or locations for your own reference.
- Give ChatGPT the asset itself when the next task requires visual inspection.
- Keep stable filenames or locations with archived assets for your own reference.
- After a visual milestone, record the accepted result and remaining defect in text.
- When symptoms return, hand off early. Skip invented image limits.
This workflow leaves model inference and service incidents unchanged. It reduces the retained visual history a replacement thread must carry. More important, it gives you a repeatable escape hatch when ChatGPT performance drops inside one conversation.
I would start with a fresh text chat and test responsiveness before touching caches, priorities, or hidden files.
OpenAI's supported, zero-cost step is a fresh chat. My handoff carries the decisions and the smallest current image set, which gets the work moving without betting on cache tricks or guessed limits.