Here’s a summary of the intriguing specifications for the ChatGPT Model: Code Interpreter.

The number of messages that can be sent with ChatGPT has quietly increased to 50 per 3 hours.

(I think it used to be 25 messages per 3 hours, probably.)

Since the timing was right, I asked ChatGPT directly about the specifications that interested me, and I have compiled the information here.

Please note that the information might not always be accurate, and it is as of July 22, 2023. Also, the investigations were conducted using Model: Code Interpreter.

Message Count

The message count includes messages from both the user and the AI.

Thus, if there is a limit of 50 messages that can be sent in 3 hours, the number of questions (or instructions) that a user can send is up to 25, and the remaining 25 are used for AI responses. The length of the message does not affect the count.

“Continue generating” Button

This appears when the response provided by the AI exceeds a certain length.

The responses generated by the AI are limited in length, and if this limit is exceeded, the AI’s response is automatically truncated. At this point, the “Continue generating” button is displayed, and by clicking this button, the user can have the AI generate the continuation.

However, whether or not the “Continue generating” button appears depends not only on whether the AI’s response exceeds a certain length, but also on whether the response ends at a natural break (such as the end of a sentence). If the AI’s response ends at a natural break, the “Continue generating” button will not be displayed.

When you click the “Continue generating” button, the AI generates a new message to continue the conversation while maintaining the current context. This newly generated message is included in the message count.

Memory Limit

The memory limit for each AI session is 6GB.

This refers to the maximum amount of memory that the AI can use during a single session. This memory is used for all tasks, including loading, processing, and analyzing data, running programs, and the operation of the AI itself.

If you are dealing with large data sets or running programs that consume a lot of memory, you need to be aware of this limit. For example, loading a 1GB CSV file as a Pandas DataFrame consumes between 2GB and 5GB of memory just to hold it in memory. Therefore, there is limited room for additional processing on that data within the 6GB memory limit.

Also, the memory limit affects the complexity of the programs that the AI can run. Tasks such as large matrix computations or the training of complex machine learning models can require a lot of memory. When running these tasks, you need to consider the amount of available memory and how much it will affect the execution of the task.

When the memory limit is reached, a memory error occurs and the program execution is stopped. Therefore, when dealing with large data or running programs that may consume a lot of memory, it is important to carefully monitor memory usage.

Data Processing and Program Analysis

This refers to various data processing and program analysis tasks performed during an AI session. These tasks are constrained by memory limits (6GB) and computational capabilities.

For example, it is possible to load large datasets (e.g., 1GB of video or CSV files) and analyze them. However, the size of the data and the computational requirements for its analysis are heavily dependent on available memory and computational capabilities. Loading 1GB of data consumes a large amount of memory just to hold that data in memory. Additional computations for analyzing that data (such as statistical analysis or training machine learning models) also consume memory and computational capabilities.

These tasks are performed by the user using programming languages such as Python, not directly by the AI. The AI assists in the creation and execution of the program and provides interpretation of the results. The AI can also detect program errors and suggest possible corrections.

This means that when a user uses AI to perform advanced data analysis or program analysis, they need to consider the balance between available resources (memory and computational capabilities) and task requirements (data size and complexity of analysis).

Program Errors and Corrections

The AI can detect errors in the programs created by the user and suggest possible corrections. This feature helps users debug their programs and is also useful for learning programming.

If the AI notices a program error in a single message, fixes it, and reports the results after the correction, it is counted as one message. In this case, the detection of the error, its correction, and the reporting of the results all occur within the same message, so the message count increases by only one.

However, if the AI sends a new message to report the results after the correction, that new message is counted as a separate message. In other words, if the error correction and its result reporting are done in separate messages, the message count increases by two.

Note that the AI rarely automatically corrects program errors, and its main role is to detect and report them. Error corrections are usually made based on user instructions.

CSV Files

When loading a CSV file as a DataFrame, it uses about 2 to 5 times the memory of the file size. So, loading a 1GB CSV file can potentially use about 2GB to 5GB of memory.

Image Files

The memory usage of images depends on their resolution (number of pixels) and color depth (amount of color information per pixel). Color depth indicates how much information each pixel holds and is usually expressed in bits. For example, a color depth of 8 bits can represent 256 (2^8) different colors per pixel.

The RGB color space refers to a color space where each pixel has three color components: red (R), green (G), and blue (B). Since one color component is usually represented by 8 bits, the color depth of the RGB color space is 24 bits (8 bits x 3). This means that one pixel can represent about 16.77 million colors (2^24).

Therefore, a 1000×1000 pixel image in the RGB color space (color depth 8 bits x 3) uses about 3MB (1000x1000x3 bytes) of memory. This is because each pixel uses 3 bytes of memory (24 bits ÷ 8), and the total number of them is 1000×1000.

Loading 1000 such images uses a total of about 3GB (3MBx1000) of memory. This is equivalent to half of the memory limit (6GB). Therefore, if you load more than 1000 such images or perform additional computations to analyze these images, you may exceed the memory limit.

Please note that the image format (JPEG, PNG, etc.) and compression rate also affect memory usage. Compressed image files occupy less space on disk, but they are held in memory at full size based on resolution and color depth.


The memory usage of a program depends on its content. For example, a program that performs calculations on large matrices or trains complex machine learning models may consume a lot of memory.

Consider, for example, dealing with large matrices using the NumPy library in Python. The memory usage of a matrix depends on the number of elements in the matrix and the data type (number of bits) of each element.

For instance, a 1000×1000 matrix with elements of 64-bit (8 bytes) floating-point numbers uses about 8MB (1000x1000x8 bytes) of memory. This is because each element of the matrix uses 8 bytes of memory, and the total number of them is 1000×1000.

If you create a larger 10000×10000 matrix with the same data type, its memory usage is about 800MB. This is because each element of the matrix uses 8 bytes of memory, and the total number of them is 10000×10000.

As these examples show, the memory usage of a program largely depends on what it does. When running a program that handles large amounts of data or performs computations that could potentially consume a lot of memory, you need to manage your memory usage carefully.

Memory Usage of Messages

The memory usage of messages depends on their length, but it is generally negligible. To understand the memory usage of messages, consider how text data is stored in memory.

In general, one character uses one byte of memory (however, this depends on the encoding of the character). Therefore, 1MB of text corresponds to about 1 million characters. This is far more than the length of a typical message. For example, even this message itself probably uses less than 1KB (about 1000 characters) of memory.

Therefore, the memory usage of messages is a very small part of the total memory usage and can generally be ignored compared to other factors (such as the loaded data or running programs).