Video summary

This is absolute chaos...

Main summary

Key takeaways

Technology

Summary of technological concepts, product behavior, and guidance

1) Model usage limits are “burning” much faster with GPT-56 (Soul) than expected

  • The speaker reports that GPT-56 (Soul) drains rate limits/quotas far faster than GPT-55, especially under medium/high “reasoning” settings.
  • Even after lowering settings (e.g., from high to medium, “not fast mode”), they still hit limits repeatedly.
  • Reported comparison:
    • With GPT-55 on a $100 plan, they could barely consume quota.
    • With GPT-56 (Soul), a “small PR” can consume about half of a 5-hour limit (based on their experience).
  • Emphasis: this is not only a “quality vs cost” issue, but a throughput/limit-management issue that makes long sessions and long-running workflows impractical.

2) Community backlash + causes attributed to both configuration and platform behavior

  • The speaker suggests some OpenAI/Codex product behaviors may encourage inefficient usage (e.g., code/tooling behaviors and “bad advice” that doesn’t hold up).
  • They frame part of the overuse as OpenAI’s fault, while still offering practical mitigation steps.

3) Practical advice to reduce limit burn (Codex usage optimization)

A. Temporarily removed 5-hour limits (operational change)

The speaker cites an update indicating that for the last ~48 hours:

  1. The 5-hour usage limit was temporarily removed for Plus/Business/Pro plans.
  2. The weekly limit remains and is the main risk.
  3. OpenAI is rolling out changes intended to make GPT-56 more efficient (reducing token usage).

Additional detail on prior behavior:

  • The previous 5-hour limit reset based on when you sent messages, enabling “cron tricks.”
  • With the 5-hour window gone temporarily, those tactics are less relevant.

B. Turn off Fast mode

  • The speaker argues Fast mode helped with GPT-55 because GPT-55 would stop more often and require user prompting.
  • With GPT-56, which can run longer autonomously, Fast mode increases consumption rate enough that a single run can burn a large fraction of quota.
  • They claim speed differences matter less because GPT-56 time is dominated by tool calls/tests/other workflow steps, not raw inference latency.

C. Avoid “Ultra” (at least until a follow-up)

  • They say a feature called “Ultra” caused immediate limit hits during testing.
  • Recommendation: avoid Ultra (they plan a separate deeper follow-up).

D. Reasoning level guidance: default to High, avoid extremes

  • The speaker notes reasoning levels were rebranded, but historically correspond to:
    • low, medium, high, x high, max (with “Ultra” as a separate option).
  • Guidance:
    • Default to High reasoning for most coding tasks.
    • Low/Medium can be alternatives if High runs too long.
    • X high and Max are much more expensive for small quality gains.

Benchmark examples (Deepsw SWE):

  • Low: 45%
  • Medium: 61%
  • High: 69%
  • X high: slight increase (~71%) but much higher cost
  • Max: small score increase (~73%) but cost is disproportionately higher

Claim:

  • “High is the efficient knee” where cost/benefit is reasonable; beyond that, costs rise steeply.

E. Avoid sub-agents unless explicitly requested

  • Behavioral issue: GPT-56/Soul may be too eager to spawn sub-agents.
  • The speaker describes multiple Codex sub-agent implementations (V1/V2) and calls them “not good” / inefficient.
  • Mitigation:
    • Update agent configuration (e.g., agents.md) with wording like:

      “Only use sub agents if the user explicitly requests them.”

Additional notes:

  • Other tools (e.g., Claude Code, Cursor) allegedly have better sub-agent implementations; they suggest experimenting or waiting for Codex fixes.

F. Model selection: avoid certain models for coding

  • Recommendation against using “Luna” for coding (they say it’s more suited for programmatic/API filtering).
  • “Terra” might be a middle ground, but they argue Soul (low/medium/high) is often the most efficient for coding.

4) The biggest “fundamental” lever: prompting the model’s stop point

  • They argue GPT-56/Soul is eager to continue until it has a clear reason to stop.
  • Instead of relying only on tooling/config to stop, they recommend explicit prompt-based termination criteria, such as:
    • “Write a plan; when finished, stop and ask for feedback.”
    • “Build the feature, test it, open a PR, babysit the first review; stop after the first set of review comments.”

Expected benefits:

  • Controls quota burn
  • Limits how long the model “runs” autonomously
  • Helps avoid quality degradation by stopping “just far enough”

5) Critique of “context window compaction hacks”

  • They advise against manually limiting the context window or forcing compaction aggressively in configuration.
  • Reasoning:
    • The model is trained on specific compaction behavior; manual interference may make it “dumber.”
    • It can increase compaction cost rather than reduce it.
  • They cite OpenAI/“TBO” claims that usage tracking and context-size tuning have had issues (e.g., product changes affecting billing/usage charges).

6) Platform update notes affecting usage tracking/efficiency

They report “moving target” changes from OpenAI:

  • Inference optimizations rolling out for ~10% savings.
  • Context size limit changes:
    • Increased to 372K, reportedly causing more usage charged than intended
    • OpenAI reverted temporarily to 272K, planning to roll forward later
  • Mentions “leaks” about “juice values” changes that were reverted.
  • Multi-agent usage was occurring more than intended at higher reasoning efforts; OpenAI plans fixes.
  • Auto-review efficiency improvements may also be underway.

7) External endorsement about reasoning defaults

  • They mention “Open Code” users/promoters mainly favor GPT-56.
  • Anecdote: Open Code misconfigured reasoning levels for a month due to a JSON key mismatch, causing them to effectively use medium.
  • The OpenAI team observed this and still concluded the model remained their favorite—leading the speaker to infer Medium might be a strong default for many users.

Key takeaways (condensed)

  • GPT-56/Soul burns limits faster than GPT-55; long sessions can become impractical unless you change behavior.
  • Disable Fast mode, avoid Ultra, and generally stick to High reasoning (with Medium as a strong alternative).
  • Control spending by:
    • adding explicit stop conditions in prompts,
    • preventing unnecessary sub-agent spawning (“only if user explicitly requests”),
    • and avoiding risky config hacks around context compaction.
  • OpenAI is actively changing limit/efficiency/usage tracking; advice remains broadly valid but platform behavior may shift.

Main speakers / sources

  • Main speaker: A single creator (referenced indirectly; mentions collaborating with “TBO” and being part of an “Open Code”/benchmarking context).
  • Sources cited:
    • TBO / OpenAI team updates (usage limit changes, efficiency optimizations, context-size reverts, multi-agent fixes).
    • Open Code team (reasoning-level endorsement story).
    • Work OS sponsor (included as a sponsored-segment source, not central to model tech).

Original video