OpenClaw Makes GPT-5 Million-Token Context an Explicit Cost Opt-In

OpenClaw has merged a safer default for GPT-5.5 and GPT-5.6 context on main: the provider’s 1,050,000-token window remains known to the model catalog, but ordinary runtime sessions default to a 272,000-token budget. Operators who genuinely need long context can explicitly opt into a derived 922,000-token input budget.

The reason is cost, not a claim that large contexts do not work. Upstream’s pull request says OpenAI requests above 272,000 input tokens enter materially higher long-context pricing.

The operator decision

• Most API-key and Codex users: keep the 272,000-token default and rely on compaction unless a measured workload needs more.
• Long-document or repository workloads: estimate the cost of representative full sessions, then enable long context only for the agents or routes that justify it.
• Fleet operators: pin and audit the effective context policy. Catalog capacity and active runtime budget are now deliberately different values.
• Source-build users: confirm the exact revision includes PR #112916. Packaged users should confirm release notes rather than assuming the merge is in their installed version.

Advertised capacity is not the active budget

The merged OpenAI plugin retains the native provider window as metadata. That lets OpenClaw understand what the provider can support without automatically spending into the expensive tier.

At runtime, GPT-5.5 and GPT-5.6 default to 272,000 tokens across API-key and ChatGPT/Codex routes. The explicit long-context mode derives a 922,000-token input budget and uses a conservative 700,000-token compaction target, leaving room for an incoming turn and provider guardrails.

Interpretation: “the model supports one million tokens” is no longer equivalent to “this session may consume one million tokens by default.” That is a good separation of capability from spending authority.

Dashboards, /status output and capacity planning should use the effective runtime budget where available. Reading only model catalog metadata can now overstate how much context a session will retain before compaction.

Why bigger context can produce a nonlinear bill

Long context changes more than the maximum size of one request. Agent sessions repeatedly send accumulated prompt state, tool results and summaries. A session operating hundreds of thousands of tokens above the normal threshold can pay the higher tier across multiple turns, retries or compaction checkpoints.

Before opting in:

1. measure input tokens over a complete representative task, not one opening prompt;
2. include tool output, retries, summaries and resumed turns;
3. verify the exact OpenAI route and current pricing contract;
4. place an external spend alert or budget around the test;
5. compare completion quality against the default budget with compaction; and
6. document why this agent is allowed to use the larger window.

Do not copy cost figures from an old article into a production forecast. OpenAI pricing and model contracts can change; use the live official pricing page linked above.

Codex override testing was fixed too

PR #112916 also corrects a validation problem in OpenClaw’s native Codex harness. Context overrides were placed before the app-server subcommand, so the harness could silently ignore them.

The corrected harness places configuration flags in the effective argument position, projects native context-window and prompt-token usage, and separates automatic-compaction tests from full-context checkpoint stress tests.

That matters because a successful “long-context test” is meaningless if the tested process never accepted the override. Operators validating their own deployment should inspect effective status or token telemetry rather than inferring configuration from a command that exited successfully.

What upstream tested

The pull request reports:

• 154 focused tests across OpenAI plugin and Codex usage surfaces;
• full source build and documentation checks;
• an embedded GPT-5.6 run at the 922,000-token budget with two automatic compactions;
• a native Codex run reporting an 875,900-token effective window and prompt usage above 272,000;
• restart and continued-turn checks; and
• a reduced-threshold Control UI proof with repeated compaction.

Those are upstream results. OpenClaw Academy reviewed the official merged record but did not send a paid million-token request or independently validate OpenAI billing.

Safe rollout pattern

Treat long context as a named capability:

• keep it disabled in the base agent profile;
• enable it for a small, identified workload;
• cap tool output so logs and generated files do not consume the window accidentally;
• retain compaction even in the larger mode;
• monitor actual input-token usage and spend; and
• remove the opt-in if quality does not improve enough to justify cost.

A larger context window is not a substitute for retrieval, clean tool output or good session boundaries. Feeding an agent nearly a million tokens of irrelevant state is expensive confusion.

Bottom line

OpenClaw’s new default is the right one: advertise the model’s real capacity, but do not silently authorize the expensive tier.

Keep GPT-5.5 and GPT-5.6 on the 272,000-token runtime budget unless evidence says a specific workload benefits from more. If you opt into 922,000 tokens, verify the effective setting, preserve compaction and treat the resulting spend as an explicit operational decision.