Did OpenAI Nerf GPT-5.6 Sol? Understanding the “Juice Value” Controversy

Introduction

Soon after GPT-5.6 Sol became broadly available, some Codex users began reporting an unexpected change: the model felt faster, but less willing to investigate difficult problems in depth.

The debate intensified when community screenshots appeared to show a large change in an internal setting described as a “juice value.” Users interpreted the number as a hidden reasoning budget and connected it to a perceived decline in Sol Max performance. OpenAI rejected the idea that the model itself had been deliberately weakened, but acknowledged that it had temporarily changed reasoning-effort settings while investigating unusually high usage.

This distinction matters. A model’s underlying weights can remain unchanged while its runtime configuration, available context, tool access, reasoning effort, or multi-agent behavior changes. From a user’s perspective, those operational settings can still make the same named model behave differently from one day to the next.

This article separates the verified facts from community observations and explains how developers can test model behavior more reliably.

What GPT-5.6 Sol Introduced

OpenAI first previewed GPT-5.6 Sol on June 26, 2026, describing it as the flagship member of a family that also includes Terra and Luna. The broader GPT-5.6 launch followed on July 9, 2026.

A major part of the release was a wider range of reasoning settings. In Codex, Sol can be used with several reasoning levels:

1. Low
2. Medium
3. High
4. Extra High
5. Max
6. Ultra

OpenAI describes Max as the setting that gives Sol the most time for deep reasoning. Ultra goes further by using subagents, allowing a complex task to be divided and handled through parallel work.

Higher reasoning effort is not free. It normally takes more time and consumes more tokens, but it can help with tasks that require planning, repeated testing, error recovery, or comparison between several possible solutions.

Why Users Thought Sol Max Had Been Nerfed

One of the most widely shared complaints came from a Japanese market-research team using Codex Sol Max with a custom command-line tool.

According to the team’s Reddit post, Sol Max had previously spent more than ten minutes on demanding prompts, repeatedly testing ideas and using tools until it reached a strong result. The team said that its performance then dropped suddenly, with every member noticing shallower reasoning during the same workday.

That report is meaningful as a real user experience, but it is not a controlled benchmark. Several factors can affect an agentic coding run:

• The selected reasoning level
• The available context window
• Tool permissions and sandbox settings
• Repository state
• Prompt wording
• Service-side routing or configuration
• Multi-agent behavior
• Rate limits and usage accounting
• Random variation between runs

A sudden difference noticed by an experienced team deserves investigation. It does not, by itself, prove that OpenAI changed the model weights or permanently reduced Sol’s capabilities.

What Is a “Juice Value”?

The phrase “juice value” became central to the controversy after it appeared in a public update from Thibault Sottiaux, who works on Codex and ChatGPT Work.

In that update, Sottiaux said OpenAI had run experiments in which reasoning efforts were changed and that these settings were referred to internally as “juice values.” He also said the experiment had been reverted.

The simplest interpretation is that a juice value is an internal control related to how much reasoning work a model is allowed to perform during a task. It should not automatically be treated as a direct intelligence score.

A lower reasoning allocation could affect behavior such as:

• How many approaches the model explores
• How long it continues before producing an answer
• Whether generated code is tested automatically
• How often failed changes are revised or rolled back
• Whether the model asks subagents to handle parts of the task
• How much effort is spent checking edge cases

However, OpenAI has not published an official numerical mapping between user-facing reasoning levels and specific juice values.

The Reported Change From 960 to 128

Community posts and screenshots claimed that Sol Max had previously used a juice value near 960 and later showed a value of 128. That would represent a reduction of roughly 87 percent.

These figures should be treated as unverified community observations. They were not published in the GPT-5.6 model documentation, and a value extracted through a hidden prompt or “model fingerprinting” technique may not reliably represent the actual server-side compute allocation.

The confirmed part is narrower: OpenAI acknowledged that reasoning-effort experiments took place and said those changes were reverted.

OpenAI’s Response

Sottiaux’s update rejected the claim that GPT-5.6 Sol had been intentionally nerfed. It described several operational issues and changes instead.

1. Inference Optimizations

OpenAI said it had deployed inference optimizations and would pass the savings to subscribers. The company expected this improvement alone to provide roughly 10 percent more usage.

An efficiency improvement can make a model faster or cheaper without reducing quality. Still, users may notice changes if an optimization is introduced alongside other configuration experiments.

2. Context-Limit Adjustment

OpenAI had raised the usable context limit for GPT-5.6 Sol from the 272k level associated with GPT-5.5 to approximately 372k.

The larger context caused usage to be deducted more heavily than expected. OpenAI temporarily returned the limit to 272k and said it planned to roll 372k out again after correcting the accounting behavior.

This helps explain why two issues were discussed at the same time:

• Users saw their allowances disappear faster.
• Some users saw a smaller usable context window.

A context-window adjustment is separate from a model-weight change, but it can still affect long repository tasks and document-heavy workflows.

3. Reasoning-Effort Experiments

OpenAI said it changed reasoning efforts while tracing the source of higher-than-expected usage. Those internal settings were described as juice values.

The company said it had reverted the experiment. This is the clearest confirmation that users may have encountered temporary runtime differences even though OpenAI did not characterize the change as a model downgrade.

4. Multi-Agent and Auto-Review Usage

OpenAI also reported slightly higher multi-agent usage than intended in High and Extra High modes. It said it was correcting that behavior and improving the efficiency of auto-review.

This matters because agent delegation can consume substantial resources. A run that launches more subagents or performs extra review work may use a subscription allowance much faster than a single-agent run.

Does a Smaller Reasoning Budget Make a Model Less Intelligent?

Not necessarily, but it can make the model appear less capable on difficult tasks.

It is useful to separate three layers:

Model Capability

This comes primarily from the trained model itself: its weights, architecture, learned knowledge, and core problem-solving ability.

Runtime Reasoning Allocation

This determines how much time or computation the system allows the model to spend on a particular request.

Agent Environment

This includes tools, context, memory, permissions, subagents, test runners, file access, and retry policies.

A strong model with a limited reasoning allocation may still answer easy questions correctly while performing worse on long-horizon coding tasks. It may stop after finding the first plausible solution instead of testing alternatives or recovering from an initially wrong approach.

That does not mean the model’s underlying capability vanished. It means less of that capability may be expressed during a particular run.

Why Perceived Performance Can Change Without New Model Weights

Production AI systems are not static files served in exactly the same way forever. A provider can change many operational parameters without renaming the model.

For example, users may experience differences when the platform changes:

• Maximum reasoning duration
• Token or compute budgets
• Context limits
• Tool-call limits
• Retry behavior
• Parallel-agent rules
• Caching
• Safety checks
• Load balancing
• Subscription quotas

This is why a model name alone may not guarantee identical behavior across dates, products, plans, or reasoning settings.

For enterprise use, the important question is not only “Which model is selected?” It is also “Which runtime guarantees are attached to that model?”

How to Test Whether Codex Performance Changed

A useful test needs to control as many variables as possible. Running one prompt before and after a suspected change is not enough.

Step 1: Freeze the Task

Use the same repository commit, input files, dependencies, environment variables, and test suite.

Create a Git checkpoint before every run so the starting state is identical.

Step 2: Record the Configuration

In Codex CLI, check the active model and session configuration:

/status

Use the model selector when necessary:

/model

You can also start Codex with a specific model:

codex --model gpt-5.6

For a repeatable non-interactive task:

codex exec -m gpt-5.6 "Review the current changes"

Record the reasoning level, permissions, context usage, Codex version, and any enabled tools or plugins.

Step 3: Use Objective Success Criteria

Define the result before starting. Useful metrics include:

• Tests passed
• Bugs fixed
• Benchmark score
• Correct files changed
• Regression count
• Number of human corrections required
• Time to a passing solution
• Tool calls and retries
• Total usage consumed

Avoid scoring only by how “smart” the response feels.

Step 4: Repeat Each Condition

Run the same condition several times. Reasoning models and agents can vary between attempts, so a single run may be misleading.

Compare medians and failure rates rather than selecting the best or worst example.

Step 5: Change One Variable at a Time

Compare Medium against Max while keeping everything else fixed. Then compare dates, versions, or context limits separately.

If several variables change at once, you will not know which one caused the result.

Step 6: Preserve Logs

Save prompts, terminal output, diffs, test results, elapsed time, and usage data. Clear records make it easier to report a regression and allow other users to reproduce the test.

Practical Guidance for Codex Users

For everyday tasks, OpenAI recommends starting with the default reasoning setting and moving higher only when the work requires deeper planning or analysis.

A few practices can make difficult runs more reliable:

1. State the acceptance criteria explicitly.
2. Ask Codex to inspect the repository before editing.
3. Require it to run the relevant tests.
4. Tell it to report unresolved failures rather than hiding them.
5. Use Git checkpoints before and after major changes.
6. Review the active model and reasoning level before expensive tasks.
7. Keep a repeatable benchmark for work that is important to your team.

For especially difficult projects, Max or Ultra may be appropriate. Ultra is useful when a problem can be divided among subagents, but it can also consume more resources.

What the Controversy Reveals About “Fixed Intelligence”

The larger issue is not whether one disputed internal number was exactly 960 or 128. The deeper concern is that users often assume a model name represents a fixed and stable level of behavior.

In practice, the user experience depends on both the model and the service configuration around it. A provider may optimize inference, change context limits, adjust reasoning allocation, or modify agent orchestration while leaving the model name unchanged.

That flexibility is useful for operating a large service, but it also creates a transparency problem. Developers building critical workflows need to know which characteristics are guaranteed and which may change dynamically.

Clearer documentation could include:

• Stable definitions for reasoning levels
• Context-window guarantees
• Change logs for meaningful runtime adjustments
• Usage-accounting rules
• Notices when experimental configurations are deployed
• Reproducible evaluation guidance

Without that information, users are left to infer system changes from response speed, token usage, and subjective output quality.

常见问题

Was GPT-5.6 Sol officially nerfed?

OpenAI said there was no deliberate nerf to the model. It did acknowledge temporary experiments that changed reasoning-effort settings, along with context, multi-agent, and usage-accounting adjustments.

What does “juice value” mean in GPT-5.6 Sol?

OpenAI used the term for an internal setting related to reasoning effort. It appears to control or represent reasoning resources, but the company has not published a complete technical definition or official numeric scale.

Did the Sol Max juice value really fall from 960 to 128?

That claim came from community screenshots and hidden-prompt experiments. OpenAI has not officially confirmed those two numbers, so they should not be treated as verified model specifications.

Why would Sol feel faster but less thorough?

A lower reasoning allocation can lead a model to explore fewer approaches, run fewer checks, or stop earlier. Other factors, including context limits, tool behavior, server configuration, and random variation, can produce a similar effect.

What happened to the 372k Codex context window?

OpenAI said GPT-5.6 Sol’s context limit had been increased from 272k to 372k, but the change caused usage to be deducted faster than intended. The limit was temporarily returned to 272k while the company prepared to roll out 372k again.

Should developers always use Max reasoning?

No. Higher reasoning settings take longer and generally use more resources. Start with the default setting and increase it when a task genuinely requires deeper planning, testing, or error recovery.

How can a team verify a suspected model regression?

Use the same repository, prompt, tools, permissions, reasoning level, and tests across repeated runs. Track objective metrics such as passing tests, error rate, completion time, tool calls, and usage consumption.

相关工具

• OpenAI Codex: OpenAI’s agentic coding environment for working with repositories and development tasks.
• Codex CLI: The official command-line interface for running Codex in local projects and automated workflows.
• Codex GitHub Repository: The official open-source repository for the Codex CLI.
• ChatGPT: The web interface where supported GPT-5.6 models and reasoning settings can be used.
• Terminal-Bench: A benchmark for testing AI agents on command-line tasks involving planning and tool use.

Related Links

• GPT-5.6 Launch Announcement: OpenAI’s general-availability announcement and benchmark overview for the GPT-5.6 family.
• GPT-5.6 Sol Preview: The official preview introducing Max reasoning and Ultra multi-agent mode.
• Codex Model Guide: Official guidance on Sol, Terra, Luna, and the available reasoning levels.
• Codex CLI Documentation: Installation, configuration, and workflow instructions for the Codex command-line tool.
• OpenAI Runtime Update on X: The public update discussing inference optimization, context limits, juice-value experiments, and multi-agent usage.
• Community Sol Max Report: The Reddit report that helped trigger the wider performance discussion.

Summary

The GPT-5.6 Sol controversy began with genuine user reports that Max reasoning had become faster and less thorough. Community screenshots connected that experience to a reported change in an internal “juice value,” but the specific 960-to-128 claim remains unverified.

OpenAI denied intentionally nerfing the model while confirming that it had experimented with reasoning-effort settings, temporarily adjusted the context limit, and found unexpected usage in multi-agent and auto-review workflows. Those changes were operational rather than a confirmed replacement of the underlying model weights, but operational changes can still affect real-world performance.

For teams relying on Codex, the best response is to maintain repeatable benchmarks, record runtime settings, and measure results with tests rather than intuition alone.

The key lesson is that a model name does not fully describe the behavior users receive; reasoning allocation, context, tools, and service configuration matter too.