GPT-5.5 Stopped Reasoning at 516 Tokens. OpenAI Won’t Say Why.

A developer running a production workload through the Codex API noticed in late June that GPT-5.5 was returning wrong answers on tasks it had handled correctly weeks earlier. The degradation felt random—the same prompt would succeed on some attempts and fail on others, with no apparent connection to prompt length, task type, or anything else on the user side. When they pulled the token-level metadata from their session logs and ran the numbers across 390,195 API responses spanning February through June 2026, the randomness resolved into something specific.

GPT-5.5 is terminating its reasoning at exactly 516 tokens in 44% of all cases where it uses 516 or more reasoning tokens. In February, that rate was 0.11%. In March it climbed to 2.45%. In April, 4.25%. In May it peaked at 53.3%—the majority of GPT-5.5 responses requiring substantial reasoning were hitting an exact ceiling. June showed 35.84%, still more than a third. Other models using the same API over the same period—gpt-5.4, gpt-5.2, the older gpt-5.3-codex variants—show the same metric at between 0.0% and 19.8%. GPT-5.5 accounts for 19.3% of responses in the dataset but 82% of the exact-516 events.

That is not a natural distribution. Natural reasoning distributions taper—they have modes and tails and variation. What shows up in this dataset at 516 is a spike. A hard stop that a meaningful fraction of GPT-5.5’s reasoning runs into and does not pass through.

The Shape of a Hidden Threshold

Reasoning tokens are OpenAI’s term for the internal tokens reasoning models use to think before producing visible output. They do not appear in the response text, but they do appear in the API metadata, specifically in usage.output_tokens_details.reasoning_tokens. This is how the analysis was possible at all—OpenAI built the instrumentation that made their own behavior visible. According to OpenAI’s reasoning documentation, these tokens are also billed as output tokens at the model’s standard output rate. GPT-5.5 charges $30 per million output tokens. Every reasoning token the model uses, whether or not the resulting answer is correct, appears on the invoice.

The 516 figure does not appear in isolation in the data. Secondary clustering spikes appear at 1034 and 1552—values spaced approximately 518 apart. That spacing is consistent with a 512-token block size plus fixed overhead: sequence framing, padding bytes, or inference-engine headers that systems handling batched computation at power-of-2 block sizes typically add around logical computation units. Inference infrastructure at scale almost always batches requests together to maximize GPU utilization, and batch alignment at 512 tokens is a well-established tradeoff. If each reasoning block is allocated 512 tokens of actual compute with a few bytes of overhead, the first natural stopping point lands at 516. The second lands at around 1034. The third at 1552. The pattern fits.

What makes the pattern diagnostic rather than merely technical is the concurrent collapse in average reasoning depth. In February, GPT-5.5 was spending a mean of 268 reasoning tokens per response, with the 90th-percentile case reaching 772 tokens. By May—the same month the 516 clustering peaked at 53%—mean reasoning had fallen to 107 tokens, with the 90th percentile at 344. The model isn’t just hitting the threshold more often. It’s also using less reasoning even when it isn’t hitting the threshold. Both trends moved together, in the same direction, across the same three-month window. That’s not a coincidence in the data. That’s a deployment.

The API offers a reasoning.effort parameter—values of none, minimal, low, medium, high, and xhigh—that is supposed to give callers control over how deeply the model thinks. GPT-5.5 defaults to medium. None of the users who reported and replicated this issue had modified their effort settings. The 516 cap appears to be enforced server-side, beneath the layer that user parameters control, and is not exposed in the API response as a truncation signal—the response does not return an incomplete status or a max_output_tokens reason when this happens. The reasoning just stops, the model produces a final answer, and the token count ends at 516.

Wrong Answers on the Same Prompt

Issue #29353 in the Codex repository made the quality consequence concrete. A user ran a combinatorics problem—how many ways to draw a particular combination of candies from a bag—and observed that GPT-5.5’s responses fell into two distinct groups. Every run that returned the correct answer of 21 used between 3,904 and 7,766 reasoning tokens, with visible intermediate reasoning steps visible in the structured output. Every run that returned the wrong answer of 29 terminated at exactly 516 reasoning tokens and showed a specific behavioral signature: no intermediate commentary phases, a direct jump to a final answer, and completion times noticeably shorter than the successful runs. The wrong responses weren’t lower-quality reasoning that happened to fail. They were reasoning that stopped before it reached the point where reasoning becomes useful.

The same effect appeared in independent testing on Hacker News. One developer ran the identical prompt ten times: four out of ten attempts hit exactly 516 reasoning tokens and returned wrong answers; the other six used 6,000 to 8,000 reasoning tokens and returned correct results. The prompt did not change between runs. The task complexity did not change. What changed, apparently, was which server path the request was routed to.

The natural counter-argument is that this is legitimate inference optimization. Batch-size alignment at 512 tokens with a few bytes of overhead is a real engineering choice, not an unusual one, and OpenAI’s infrastructure certainly batches inference for cost and throughput reasons. This would mean the 516 cap is an artifact of how requests are grouped and processed, not a deliberate throttle on reasoning quality. But that explanation has a problem: batch alignment by complexity would route requests consistently based on some property of the request itself. What the data shows is random routing on the same prompt—the same query receives full reasoning most of the time and truncated reasoning some of the time, with no user-controllable factor predicting which outcome you get. A batch-optimization story explains the threshold. It doesn’t explain the randomness.

Closed as Not Planned

OpenAI saw issue #29353. The report included a specific task, specific wrong answers, specific token counts, and a clear reproduction methodology. It was closed as not planned. That designation in GitHub issue trackers has a specific meaning: the maintainers reviewed the report, understood what was being described, and decided it does not represent a problem they intend to fix. The issue is not open. It is not labeled as a known limitation awaiting investigation. It is closed.

The aggregate statistical analysis filed as issue #30364—covering 390,000 responses, six months, and five model variants—was submitted in late June. As of July 5, 2026, it has no response from anyone at OpenAI.

The timeline is what makes the non-response meaningful. February’s 0.11% rate is essentially noise—a near-zero baseline. March’s 2.45% is a visible signal. April’s 4.25% is confirmation that the signal is growing. May’s 53.3% is an operational majority. June’s 35.84% suggests either partial correction or seasonal variation. This arc does not describe a bug that appeared and stabilized. It describes a controlled rollout. Something was incrementally deployed across a three-month window, progressively affecting a larger share of GPT-5.5 responses, until a user with session-level instrumentation ran the numbers and filed a report that was subsequently closed without explanation.

Whether the intent was cost management, throughput optimization, or something else is not publicly known. The data does not answer the intent question—it answers the behavior question. The behavior is documented. The issue is closed. And the reasoning tokens spent during those 516-token truncations are still on the invoice.

The Trust Problem

GPT-5.5 is marketed as a new class of intelligence for coding and professional work, priced at $5 per million input tokens and $30 per million output tokens. The reasoning capability—the model thinking through problems before answering—is the primary differentiator from cheaper, non-reasoning alternatives. It is what the premium buys. And the API was designed to let you verify how much of it you received: the reasoning_tokens count is right there in the usage metadata.

What the API does not tell you is whether the reasoning it reports was the reasoning the task required. A response that terminates at exactly 516 reasoning tokens, produces a wrong answer, and completes in anomalously short time reports its token count accurately. The reasoning tokens it shows you are real. But they may represent a path that was cut off before it arrived anywhere useful, billed at the full $30-per-million rate, with no signal in the response that anything went wrong. The response status is not incomplete. The model has no way to flag that it would have benefited from more thinking—once reasoning stops, the model produces whatever answer fits at that point.

This is the specific problem with black-box inference changes in reasoning models. A context-length limit or rate cap is visible and documentable. A server-side reasoning threshold is neither—until someone builds the instrumentation to detect it. One developer did. The pattern they found had been growing for five months. The bug report is closed. If you are building production systems on GPT-5.5’s reasoning capacity, that is exactly the information OpenAI has chosen not to provide.

AI-generated editorial illustration · TemperatureZero · July 7, 2026