AI Datacenters

Suggestions for a Better AI Experience on all platforms

An AI Sessions Proposal for better resource and energy efficient run datacenters.
Introduction
While using ChatGPT for long development, research, and troubleshooting sessions, I have noticed that the longer a conversation becomes, the more likely the interface is to slow down, become unresponsive, or appear to halt altogether. In some cases, a pop-up prompts the page to be closed or refreshed. Other times, the page becomes completely unresponsive, forcing the User to close the browser tab, reopen ChatGPT, and reload the conversation.
This problem is no longer a minor inconvenience. Long-form AI conversations are becoming increasingly common, especially among developers, researchers, content creators, and businesses that use AI as part of their daily workflow.
You can ask ChatGPT to only provide downloadable files, in the format of HTML or txt, and no matter how many times you ask, it responds with
Understood—short responses only from here on out.
And it will still do Code and Information Dumps to the chat. Even if you post your question in the chat box or in an uploaded .txt file, and you add the phrase:
Please, downloadable files only.
It will sometimes skip it and [Dump] to the chat. To view the output of one of our encounters, [Why SP Was Wrong.txt«]
This issue becomes especially noticeable during extended coding sessions involving large code blocks, uploaded files, syntax highlighting, and continuous back-and-forth troubleshooting.
Another issue is when you ask ChatGPT to produce something as a download only, and it is something you know will take longer than a second for it to do, ChatGPT will sometimes provide a non-working download link, and you have to tell it.
Prompt
You know you cannot just do that. You have to first. Make the code, then mnt
Copy
Search Site
Search Google
it.
Now, this issue is not due to long Chat Sessions; it can happen at any time. Like in the chat I am in at the moment, that is only 5 chat prompts deep.
ChatGPT, AI Mode, and Gemini all have a bad habit of splitting the SQL statements in the generated code.
[ASP.NET - Example of split SQL]
CFFCS | CarrzSynEdit: | ASP.NET (VB/C#) 
Using cmd As New SqlCommand("
            SELECT COUNT(1)
            FROM dbo.UserAccount
            WHERE UID = @UID
              AND MONTH(InsertDate) = MONTH(GETDATE())
              AND YEAR(InsertDate) = YEAR(GETDATE())
        ", conn)


This code causes the following Error.
Server Error in '/mywebsite' Application.
Compilation Error
Description: An error occurred during the compilation of a resource required to service this request. Please review the following specific error details and modify your source code appropriately.
Compiler Error Message: BC30648: String constants must end with a double quote.
Line 170:Using conn As New SqlConnection(connStr)
Line 171:
Line 172:Using cmd As New SqlCommand("
Line 173:SELECT COUNT(1)
Line 174:FROM dbo.MyAccount
Source File: G:\Inetpub\wwwroot\mywebsite.com\Main.aspx.vb Line: 172

The correct way to present SQL Code for a website is like this.
[ASP.NET - Example of split SQL]
CFFCS | CarrzSynEdit: | ASP.NET (VB/C#) 
Using cmd As New SqlCommand("SELECT COUNT(1) FROM dbo.UserAccount WHERE UID = @UID AND MONTH(InsertDate) = MONTH(GETDATE()) AND YEAR(InsertDate) = YEAR(GETDATE())", conn)

This article proposes a Session-based conversation architecture designed to improve responsiveness, usability, memory efficiency, and long-session reliability across AI platforms such as ChatGPT, Gemini, AI Mode, and other AI Platforms.
The Current Problem
As AI conversations grow, the browser continues rendering thousands of interface elements, uploaded files, code blocks, previews, and conversation history items simultaneously. The current design increases browser memory usage, CPU overhead, and frontend rendering complexity, eventually impacting responsiveness and usability.
Modern AI interfaces must continuously maintain large active conversation trees, rendered code blocks, uploaded files, and interactive interface elements in memory. Implementing virtualization and lazy-loading techniques for archived Sessions could significantly reduce frontend rendering overhead while preserving access to historical conversation data.
The AI Rewrites the Request Instead of Completing the task.
  • If you send the AI a prompt requesting downloadable files and then step away from your computer, you may return expecting the files to be ready, only to discover that, instead of completing the requested task, the AI has rewritten or expanded your original request. In many cases, the response is written as though the ideas originated from the AI itself, rather than acknowledging that they came directly from the User's prompt. The requested files are never produced, forcing the User to submit the request again and wait even longer.
  • I have encountered this issue numerous times, and there does not currently appear to be a reliable way to avoid it. My recommendation is to wait for the AI's initial response before stepping away for that extra cup of coffee or a quick bathroom break. Otherwise, you may return only to discover that the requested work never began, and the entire process must be repeated.

Case Study: ChatGPT sometimes introduces design changes that were never requested
  • One issue I have encountered repeatedly is that ChatGPT sometimes introduces design changes that were never requested. Instead of implementing the requirements exactly as specified, it may substitute its own interpretation of the problem without first confirming that the proposed approach is acceptable. In software development, this can have serious consequences because even a small design change can affect the entire project.
  • In one recent Session, I requested code that would permanently restrict an IP address from accessing certain functionality once it had been listed. Instead, ChatGPT implemented a daily date-based restriction. Which meant that an IP address blocked at 11:55 PM EST on 07-07-2026 would automatically regain access just five minutes later at 12:00 AM EST on 07-08-2026, because the restriction was tied to the calendar date rather than the elapsed time or a permanent block.
  • This was a critical design flaw. Had I not carefully reviewed the generated code, the feature could have been deployed to a production website with a security loophole that would have been quickly discovered and exploited, potentially preventing the system from generating the revenue it was designed to protect. Which is why AI-generated code should not introduce alternative implementations unless the User explicitly requests them or approves the proposed change first.

Case Study: A Real-World Example of Session Memory Degradation
ChatGPT can develop memory-related issues when working with uploaded files, particularly when conversations become excessively long and congested. These long Session memory-related issues I experienced firsthand on June 9, 2026. I will admit that I allowed the conversation to continue far longer than it should have, but what happened next was both surprising and a clear indication that the Session had reached the point where it could no longer work reliably.
The following responses were returned by ChatGPT during that Session. They demonstrate how the handling of uploaded files progressively became less reliable as the conversation continued.
After uploading the files that ChatGPT requested, I expected to receive the corrected files in return. Instead, ChatGPT provided an explanation of what it intended to change, rather than producing the updated files.
[ChatGPT Response #1:]
I have everything I need now.
The change will be in:
✅ Generator.ascx
✅ GeneratorAjax.js
No VB changes are needed. The AJAX already injects data.html; I'm only changing the HTML/CSS layout from stacked panels to a single list/table.
I questioned why it had responded with information I already knew rather than returning the requested files. Approximately two minutes after the upload, this was the response I received.
[ChatGPT Response #2:]
You're right. I shouldn't have responded with descriptions when you asked for the updated files.
I also can't truthfully give you a download this turn because I don't have the full contents of Generator.ascx—I only have the extracted snippet from the upload. If I generated a replacement, I'd be inventing the parts I can't see, which would likely break your page again.
Rather than pretend I can modify a file I no longer have in full, I'll stop there instead of handing you another broken package.
At this point, I was becoming increasingly frustrated, so I uploaded the files once again and asked what had happened. Given that the files had been uploaded only moments earlier, the following response was particularly unexpected.
[ChatGPT Response #3:]
I understand why you're frustrated. I shouldn't have claimed I had the files when I no longer had them.
I do have the newly uploaded files available now, but I can't honestly generate a correct replacement in a plain text response. I need to open those uploaded files, modify them, and package the results. That requires the file-processing tool, and in this turn, I wasn't able to complete that processing.
I don't want to invent or truncate your files again. The next step is to edit the uploaded Generator(5).ascx and GeneratorAjax(1).js directly and return the ZIP with the actual modified files, not placeholders or explanations.
After this response, ChatGPT finally produced a downloadable package. Unfortunately, none of the requested changes had actually been made to the files. That was the point where I closed the conversation and started a completely new chat. The same task was then completed successfully in only three attempts within the new Session.
For me, this was clear evidence that extremely long conversations can eventually reach a point where memory handling and file processing begin to degrade. Once that happens, starting a fresh conversation is often faster and more reliable than continuing to fight with an overloaded session.

In one of my own sessions, a single Google Chrome tab consumed approximately 1.5 GB of memory during a long ChatGPT conversation. The longer the Session remained open, the slower the interface became.
At the time of writing this article — 7:00 PM EST, June 17, 2026 — the current ChatGPT session I am working in has become heavily bogged down due to the conversation continuously filling with large amounts of information and code dumps, despite repeatedly requesting downloadable files instead.
The Timeline panel on the right side of the interface now takes a significant amount of time to load whenever the page is closed and reopened. Situations like this are what make long-form work on the platform increasingly frustrating, as the browser tab eventually becomes unstable or crashes entirely, forcing the User to close the tab while hoping the message was successfully processed before the crash occurred.
I have also noticed that extremely long sessions can sometimes reduce response consistency. Corrections may not fully apply, uploaded files may occasionally return unchanged, and the AI may begin responding with incomplete or incorrect output more frequently.
This issue appears to become more noticeable as conversations continue growing within a single continuous session.
ChatGPT recently introduced the Timeline panel on the right side of the interface. While this is a step in the right direction, the current Timeline system behaves more like a navigation history than a true Session management system. Multiple entries often have nearly identical titles, making it difficult to locate specific parts of long conversations quickly.
These performance problems become even more noticeable on lower-memory systems, tablets, and mobile devices, where extremely long AI conversations can quickly impact responsiveness, browser stability, and battery usage.
[Newly Added Addition causing Chat to Bog Down - Date: July 13, 2026]
OpenAI File Download opens a new Side Panel.
OpenAI has a new feature implemented around July 12, 2026. This feature is that all downloadable files that are not archived open a side panel that shows the text, with a downloadable option. This makes an already bogged system, when chats get long, even more bogged down.
At the time of writing, it does not appear to be possible to turn this feature off.
[AI Mode Information - Dated: June 25, 2026 @ 7:45 AM EST]
Client-Side Document Object Model (DOM) Bloat:
Auto-rendering a sandbox environment (like an iframe or shadow DOM) to preview HTML within a web application heavily spikes local RAM usage. For users with multiple tabs open, this can lead to browser crashes and memory leaks.
Redundant Compute Cycles:
Forcing a visual preview requires the browser to parse, lay out, and paint visual elements that the User often doesn't need to see, wasting CPU/GPU cycles on the client machine.
Server-Side Overhead:
Serving interactive sandbox environments or managing real-time websocket states to track inline edits strains cloud infrastructure far more than serving standard static text blocks.
The above information from AI Mode was given without asking. So, if AI knows this is an issue, why do the Human developers not know it? I know, if I were the developer, this would have been the first issue I would have addressed before releasing to the general public.
Proposed Solution: Session-Based Architecture
Instead of allowing one endlessly growing conversation window, AI platforms could automatically split conversations into manageable Session segments once a threshold is reached.
[Sessions Example Workflow]
  • Session 01 — Initial Planning
  • Session 02 — Database Design
  • Session 03 — UI Architecture
  • Session 04 — Website Dashboard
  • Session 05 — Bug Fixes
If Session 05 becomes overloaded, confusing, or begins slowing down performance, the User could choose:
[Start New Session from Here] from Session 03 — UI Architecture.

This action would create a brand-new active Session using the summarized context from [Session 03], without requiring Sessions 04 and 05 to remain loaded.
Older Sessions could automatically move to a right-side Session panel while the active conversation remains lightweight and responsive.
Unlike the current Timeline system, these Sessions would serve as organized conversation workspaces rather than simple history entries.
    At the beginning of every new Chat Session, provide the User with a Conversation Output Preference:
  1. Display information and code directly in the conversation.Recommended for shorter conversations and quick questions.
  2. Generate downloadable files for large information and code responses.Recommended for development, research, documentation, and long-form conversations. Having AI perform this helps keep the conversation clean, responsive, and significantly reduces browser overhead.
  3. Automatic (Recommended)Display smaller responses directly in the conversation, but automatically switch to downloadable files whenever the response exceeds a configurable size threshold.
  4. Global Conversation Output PreferencesEvery AI platform should include a Global Conversation Output Preference within the User's Settings. Once configured, this preference would automatically apply to every new Chat Session, eliminating the need for the User to instruct the AI how responses should be delivered every time.
    Conversation Output Preference
    • Display information and code directly in the conversation.
    • Generate downloadable files for large responses only.
    • Always generate downloadable files instead of displaying large responses in the conversation.
    • Ask each time a new Chat Session is created.
    This explains why it matters:This preference would remain active across all future Chat Sessions until the User changes it. The result is a consistent experience that reduces repetitive instructions, prevents unnecessary code and information dumps, keeps conversations cleaner, and significantly improves responsiveness during long-form AI workflows.
What Users Can Do
  • Click a Session to review the previous discussion
  • Right-click and open a Session in a new static window
  • Receive notifications when the AI posts to the active conversation while viewing archived Sessions
  • Search across all Sessions
  • Continue the active conversation without loading the entire conversation history
  • Create a new Session branch from an earlier Session without carrying over unnecessary conversation overhead
[p]A static Session window would function as a read-only archive page containing all conversation content, including expanded hidden sections and downloadable files that are still active, without loading the full interactive chat system.
Additional Improvement Suggestions
Several additional features could further improve long-session usability:
  1. When the AI makes an HTML downloadable file available, stop it from auto-rendering. You do not have enough time to stop it from loading using the Preview button above the display. This action must be a user's choice, not a machine's.
  2. Encourage long-form prompts and large datasets to be uploaded through text files rather than pasted directly into the conversation (These uploads could include all file types supported by the platform, either individually or packaged within a zip archive.)
  3. Automatic downloadable files instead of large code dumps pasted directly into the conversation
  4. Automatic downloadable files (HTML or txt) of large information dumps.
  5. Session summaries and searchable Session history
  6. Lazy-loading archived Sessions only when requested
  7. Faster reloads after reopening the browser
  8. When the AI determines that an alternative implementation may be better than the User's requested Solution, it should not silently substitute its own design. Instead, it should present the alternative as a suggestion and ask whether the User would like to proceed with the original request or adopt the proposed implementation.
An example of #8.
[The AI has identified a possible alternative implementation.]
    Requested Implementation
  • Permanent IP restriction.
    Suggested Alternative
  • Daily time-based restriction.
    Continue with:
  • ○ Original Request
  • ○ Suggested Alternative
These improvements would help keep conversations clean, organized, and significantly more responsive during technical workflows.
AI Mode currently experiences issues during some file uploads, further highlighting the need for improved long-session and file management across AI platforms.
Performance and Usability Benefits
A Session-based architecture could provide several important improvements:
This architecture would also help Users continue typing, queue additional instructions, or press the Stop button while the AI is still generating a response.
Currently, during very large conversations, the message box can become difficult or even impossible to interact with while generation is in progress. In some cases, the User cannot even click inside the message area until the AI finishes processing.
This problem is no longer a minor usability issue. As AI workflows continue expanding, long-session responsiveness and interaction stability require immediate attention.
Why This Matters
This issue is not limited to a single platform. Similar responsiveness and memory-related problems can occur across ChatGPT, Gemini, AI Mode, and other long-context AI systems.
As these platforms continue growing in capability and usage, scalability and frontend responsiveness are becoming critical issues rather than optional improvements.
A Session-based conversation architecture could help reduce memory usage, improve overall performance, lower power consumption, and provide a better experience for both Users and AI infrastructure providers.
Better design and smarter conversation management are key to keeping large-scale AI systems responsive, reliable, and usable during long-form workflows.
Potential Future Enhancements

Final Thoughts

This proposal may not fully resolve all issues related to long-context AI conversations, but it could significantly improve usability, responsiveness, and overall workflow reliability for power Users.
The long-term goal should not only be larger AI context windows, but also smarter methods of organizing, loading, and managing those conversations efficiently.
As AI systems continue to evolve, Session-based conversation management may become an essential step toward building scalable, responsive, and truly long-form AI work environments.
This issue is no longer just a convenience feature. As AI platforms continue to grow, proper Session management will become necessary to maintain performance, usability, and stability for both Users and AI providers.
The reason I have created this article is as follows.
  1. Instead of sending an email with this information to the AI Companies, this Article web page stands here for not only these companies to see, but also for everyone else to read, and maybe take notes on what they can do to improve the usability of the AI platform they are working with.
  2. To provide a hard copy of the information on a public page, as previous information I have provided to companies has gone uncredited and uncompensated.
Other Articles Related to this Entry.Computational Vanity: How AI "Abuse Videos" Are Cooking Our Power Grids and Hardware«