ChatGPT stopping mid-sentence is different from ChatGPT being stuck or rate-limited. Cut-off means tokens streamed fine, then the model just stopped — sometimes mid-word, sometimes at a clean paragraph break. The fastest unblocker is almost always the same: type continue (or better, continue from "<last full line it wrote>") and hit send. But knowing why it stopped lets you stop it from happening on the next long task.
In rough order of frequency: the model chose a stop token early → the response length budget ran out → the stream dropped → a safety filter cut it mid-response. With GPT-5.5 Instant (the default since April 2026), the most common cause is now the first one — the model decides it is “done” before it actually is — because the in-app response budget is large enough that you rarely hit a hard token wall on normal prose.
Symptoms
- Output ends mid-word, mid-code block, or mid-list item
- Long answers (code, translations, table dumps) reliably stop around the same length
- “Stop generating” never appeared and you didn’t click anything
- The model says “I’ll continue in the next message” then doesn’t
- A code block opens with
```but never closes
Which bucket are you in?
| What you see | Most likely cause | First move |
|---|---|---|
| Stops at a “natural” break (end of a list/function) but you asked for more | Model chose a stop token early | Type continue |
| Always stops near the same huge length, mid-token | Response length budget exhausted | Pre-split the task |
| Stopped right after you switched tabs / VPN flipped / laptop slept | Stream dropped | Re-send last turn, stabilize network |
| Orange/red “may violate our policies” banner above the message | Safety filter | Rephrase the trigger |
| Happens only inside one Custom GPT | Its system prompt caps length | Test in a default chat |
Common causes
1. The model chose a stop token early (most common)
The model emits an end-of-message token when it judges the answer “complete enough.” GPT-5.5 Instant was specifically tuned in 2026 to be more concise — tighter, less over-formatted — so on long structured outputs (tables, numbered lists, multi-file code) it now truncates a list or stops after a few files more readily than older models did. This is a completion-quality choice, not a hard limit.
How to verify: the output ends at what looks like a natural break (last item of a list, end of a function) but the prompt asked for more. Asking “did you finish? continue if not” almost always gets the rest.
2. The response length budget ran out
Every response is also bounded by a token budget. In the API, GPT-5.5 caps a single response at 128K output tokens (as of June 2026) inside its ~1M-token context window. In the ChatGPT app the practical ceiling is smaller and tied to your plan’s working context — roughly 16K for Free, 32K for Plus, and 128K for Pro on GPT-5.5 Instant (Thinking modes get larger windows). When generation hits that ceiling it stops — no error, just silence. On normal prose you rarely reach it; it bites on giant code dumps, full-book translations, or massive table exports.
How to verify: count the output. If a code dump or translation reliably stops near the same large length every time and ends mid-token (not at a natural break), the budget is the wall. A rough yardstick: 1K tokens ≈ 750 English words ≈ 4 KB ≈ 1,000–1,500 Chinese characters.
3. Network stream dropped mid-response
The browser holds a Server-Sent Events stream open while tokens arrive. On a flaky connection, VPN handoff, or sleeping laptop, the SSE connection drops; the UI shows whatever already streamed and stops. The server-side generation may even have completed — you just stopped receiving the tail.
How to verify: open DevTools → Network → filter for the conversation request (it shows as an eventstream/SSE type). If it closed early or you see net::ERR_NETWORK_CHANGED / net::ERR_INCOMPLETE_CHUNKED_ENCODING, the stream dropped. Reloading the page often reveals the full answer the server already finished.
4. Safety filter triggered mid-response
Less common, but real: the model started a response, generated content that tripped a post-filter, and the response was cut. The UI usually shows a “this content may violate our policies” banner — but on mobile the banner is easy to miss.
How to verify: scroll back. If there’s an orange/red warning above the truncated response, this was the cause.
5. Browser tab backgrounded or throttled
Some browsers throttle JavaScript timers in background tabs. The SSE connection survives but rendering pauses, and on some builds the connection closes after a long pause. Comes back when the tab is focused — but anything that wasn’t rendered is gone.
How to verify: did the cut-off happen after you switched away from the tab? Same prompt with the tab in focus completes normally.
6. Custom GPT system prompt forced an early stop
If you’re inside a Custom GPT whose instructions include things like “keep responses under 300 words” or “always end with the next-step question,” the GPT may stop earlier than a vanilla chat would.
How to verify: try the same prompt in a regular ChatGPT chat (no Custom GPT). Full output = the GPT’s system prompt was the cap.
Shortest path to fix
Step 1: Type continue and send
The single most reliable fix. ChatGPT picks up where it stopped — usually finishing the next paragraph, code block, or list. Works for every cause except the safety filter (case 4).
Bare continue sometimes makes it restart the current block or skip a few lines. Anchoring beats it: paste the last full line it wrote and say continue from "<that line>". For code: continue from where you stopped, do not repeat any lines, keep the same code block. For long tables: continue the table from row N, headers omitted.
Step 2: For long outputs, split before you start
Don’t ask for “the entire 30-file refactor in one response.” Ask for files 1–3 first, then 4–6. Pre-splitting:
- Avoids the output cap entirely
- Gives you a recovery point if any chunk fails
- Reduces per-call prefill time too
For translations: split per chapter or per 2,000 source words. For tables: ask for 30 rows at a time.
Step 3: Switch off Custom GPT if you’re in one
Custom GPT context shows above the input box. Click “New chat” → leave it as default ChatGPT. Same prompt now uses the full output budget without the GPT’s instructions trimming it.
Step 4: Check for the safety-filter banner
Scroll up to the truncated message. If there’s an orange/red policy warning, rephrase to remove the trigger (often a specific name, a piece of code labeled “exploit,” or a phrasing that pattern-matches sensitive content) before retrying.
Step 5: Stabilize network for long generations
- Plug into ethernet instead of Wi-Fi for 20-minute generations
- Disable VPN auto-reconnect during the request
- Keep the tab focused — don’t switch desktops or sleep the laptop
- On mobile, prevent the screen from locking
Step 6: Match the mode to the job
ChatGPT’s mode picker sits in the message composer: Instant / Thinking / Pro (Pro on paid plans). Thinking and Pro spend time and tokens on hidden reasoning before the visible answer, which on a tight turn can leave less room for the output itself. If the task is “write a lot,” not “reason hard,” select Instant — its full budget goes to visible output, and the 2026 tuning makes it both faster and longer-capable for bulk generation. Save Thinking/Pro for problems that genuinely need the reasoning.
How to confirm it’s fixed
- Count it. Paste the output into any word counter. If you asked for ~4,000 words and got the full ~4,000 (or all 30 rows / all 6 files), it completed.
- Check the tail. A finished answer ends with a closed code fence (
```), the last requested item, or a clear sign-off — not mid-token. - Re-run once. If the same prompt completes cleanly a second time after you split it or switched to Instant, the original cut-off was the budget or the mode, not a fluke.
Easy to misdiagnose as
- Rate limit / message cap — that one shows a banner (“You’ve reached your limit”). Cut-off shows no banner. See ChatGPT message cap.
- Stuck loading — stuck means no tokens ever came out. Cut-off means tokens streamed fine, then stopped. See ChatGPT stuck on loading.
- Slow response — slow means it’s still going. Cut-off means it definitely stopped. See ChatGPT slow response.
Prevention
- For any output you expect to run past roughly 3,000 words, plan a 2–3 message split up front
- Long code dumps: ask for one file at a time, not a whole project
- Run long generations on a stable network — ethernet beats hotel Wi-Fi
- Don’t background the tab for the entire generation
- If you keep hitting cut-offs in the same Custom GPT, edit its instructions to remove length caps
- For bulk writing, stay on Instant; reserve Thinking/Pro for tasks that genuinely need reasoning
FAQ
Does typing continue lose context or quality?
No. The conversation history is still in context, so continue resumes the same answer. The only rough edge is code: bare continue can re-open or slightly repeat the current block, which is why anchoring with continue from "<last line>", do not repeat is cleaner.
Why does it always cut off at the same spot? That points to the response length budget, not a random drop. In the app the ceiling tracks your plan (roughly 16K context for Free, 32K for Plus, 128K for Pro on GPT-5.5 Instant, as of June 2026). Split the task so each turn stays well under that, and the cut-off disappears.
Is upgrading to Plus or Pro going to fix it?
Only for the budget cause. A bigger plan raises the working context window, so giant single outputs run longer. It does nothing for an early stop token (use continue / split) or a dropped stream (fix the network).
My code block opened with ``` and never closed — is my code corrupted?
No, generation just stopped before the closing fence. Send continue from where you stopped, do not repeat any lines, keep the same code block. Then check the tail for a closing ```.
The response vanished after I switched tabs — is it gone? Often not. The server may have finished while your tab was throttled. Reload the conversation; the full answer frequently reappears because it was saved server-side even though your stream stopped rendering.
Related
- ChatGPT message cap
- ChatGPT stuck on loading
- ChatGPT slow response
- ChatGPT network error
- ChatGPT large document incomplete analysis
Tags: #ChatGPT #Debug #Troubleshooting