I Ran GLM 5.3 at MAX Locally for 200+ Hours... Forget GPT-6 & Fable 🤯

Technological concepts & problem being addressed

• GLM 5.3 open-weight model: Presented as a leading open model, but with a major limitation—thinking mode cannot be cleanly disabled.
• Thinking token “spooling” issue: Even when attempting low thinking mode, generations can expand to extremely large internal outputs (reported up to ~70,000 tokens, and max thinking mode can reach ~90,000 tokens or more).
• Practical performance impact: On a Mac, large thinking runs can take tens of minutes to hours (example: 23,000 seconds ≈ 6 hours for a very large, code-heavy generation).

Core method: “minmax thinking mode”

The creator proposes minmax thinking mode with the goal of:

• Maximizing intelligence while minimizing thinking tokens.

Mechanism (as described):

• Allow the model to generate up to a maximum when needed.
• Exit thinking early once enough understanding is reached.

Claimed outcome:

• Large reductions in token usage compared to high/max thinking, while keeping responses credible and more usable.

Comparative results (key examples with token counts)

1) 3D solar system / aurory-style WebGL demos

• Low thinking: ~3,000 tokens → basic/less polished output, but with interactive elements (e.g., hover/click).
• High thinking: ~60,000 tokens → much more refined visuals/UI.
• Max thinking: ~90,000 tokens → further improvement (sometimes better UI/detail), but slower.
• Minmax thinking: ~14,000 tokens → noticeably better than low thinking and closer to high quality, at far lower cost.

2) “Windows/WinRT durable vs subscription” coding/Q&A

• Low thinking: ~1,000 tokens → wrong answer (“subscription” vs “durable”).
• Max thinking: ~22,000 tokens → correct answer, but expensive.
• Minmax thinking: ~1,000 tokens → correct answer with far less thinking than max.

3) IMO-style math

• Low thinking: correct answer at ~1,700 tokens.
• Max thinking: runs long (reported ~11,000 tokens with no completed response shown yet).
• Minmax thinking: correct answer at ~2,000 tokens.

4) Nuclear bomb / mushroom cloud 3D simulation

• Low thinking: ~50,000 tokens (still huge despite “low”) → can work; visually decent.
• Max thinking: ~77,900 tokens → best-looking results, but slow.
• Minmax thinking: ~10,000 tokens → faster and still good, but not always as strong as max.

Related idea discussed: limit thinking threshold (stop thinking after N tokens), trading quality vs cost.

Handling failure modes: looping & “thinking leakage”

Response looping

• In max thinking, the model can get stuck generating/looping in extremely long code outputs.
• Example: a face / procedural WebGL generation took:
  • ~174,000 tokens
  • 23,000 seconds (~6 hours)
  • then hit a loop and failed.

“Think detection” feature

• Monitors the reasoning stage and forces the model out of loops.
• Example: a theme park scenario reduced from ~142,000 tokens (still huge) to around ~55,000 tokens after fixes, attributed to runtime error handling and loop exit.

Reasoning leakage

• Naively turning off thinking can fail because the model may continue “thinking” outside the intended tags/controls.
• The creator argues that minmax/threshold-based strategic stopping reduces this issue versus manual naive disabling.

“Limit thinking” threshold (alternative control)

Besides minmax’s early-exit approach, the creator also uses a thinking cap.

• Example: setting a 1,000-token threshold produced a better/baked nuclear explosion than strict minmax.
• However, it used more tokens than minmax minimum.

Framing:

• More predictable cost control than minmax alone.
• Quality depends on the chosen threshold.

Additional testing notes / operational details

• Quantized GLM 5.3 variants are repeatedly used.
• Runtime errors can occur even with fixes.
• Large context windows: some demos mention context sizes around ~112,000 tokens, with challenges scaling sharply as context size increases.
• Measuring code understanding: the creator often asks for full code output (not incremental diffs) to evaluate true code understanding.
• Tooling alternatives (e.g., write/read/pen-file workflows) are discussed as potential token savers, but were not used in strict benchmark-style tests.

Product-feature-like outcomes (what viewers get)

A practical, demo-driven guide for configuring GLM 5.3 to:

• Use minmax thinking for large token savings.
• Use think detection to avoid reasoning loops.
• Use limit thinking threshold as a tunable quality/cost knob.
• Generate interactive WebGL / code-heavy apps (solar systems, games, simulations) in a way that becomes closer to consumer-feasible runtime—though not fully guaranteed.

Main speakers / sources

• Single primary speaker/creator: The narrator running local GLM 5.3 experiments (no other named speaker or external source is cited in the subtitles).