GLM-5.3 Flash's Overly Verbose Thinking Process? Token Costs of Reasoning Models Spark Heated Debate

GLM-5.3 Flash Sparks Community Debate

Recently, a Reddit post about Zhipu AI's new model GLM-5.3 Flash has triggered widespread discussion. The poster expressed surprise with "Wait what??!!" and pointed directly at a common pain point of reasoning models: Why is the thinking process so lengthy and verbose?

The user's core complaint was razor-sharp — "Here goes where we spend the tokens here..." This single line captures a structural problem with Chain-of-Thought (CoT) models: to improve accuracy on reasoning tasks, models generate massive amounts of intermediate thinking text, and that text consumes real token budget from users.

Chain-of-Thought (CoT) is a prompting strategy systematically introduced by a Google research team in a 2022 paper. The core idea is to have large language models show their intermediate reasoning steps before giving a final answer. This approach draws inspiration from how humans solve complex problems — we typically don't jump straight to the answer but instead reduce cognitive load through step-by-step reasoning. CoT performs particularly well in scenarios like math word problems, multi-step logical reasoning, and code debugging, sometimes boosting model accuracy by dozens of percentage points. However, the cost of CoT is equally clear: each reasoning step requires generating additional text tokens, and in the billing systems of large models, token count directly correlates with cost. This creates a classic engineering tradeoff — a tug-of-war between reasoning quality and resource consumption.

Why Do Thinking Models Generate So Much Redundant Text?

The Contradiction Between Reasoning Capability and Token Cost

Since reasoning models like OpenAI o1 and DeepSeek-R1 rose to prominence, "think first, answer later" has become virtually the standard paradigm for high-performance models. These models unfold an internal reasoning process — sometimes a remarkably lengthy one — before outputting the final answer. In theory, more thorough thinking means more reliable answers, with clear advantages on complex tasks like math, coding, and logical reasoning.

OpenAI o1, released in September 2024, is a reasoning model that uses reinforcement learning to develop a "slow thinking" capability — when facing complex problems, the model performs multi-step reasoning in a hidden thinking space before outputting the final answer. This paradigm achieved breakthrough performance on high-difficulty benchmarks like math competitions and PhD-level science problems. DeepSeek-R1 is an open-source reasoning model released by Chinese AI company DeepSeek in early 2025. It enabled the model to autonomously learn reasoning abilities through large-scale reinforcement learning (particularly the GRPO algorithm), at a training cost far lower than comparable models. The success of these two models rapidly fueled an industry-wide "reasoning model craze," with nearly all major vendors racing to release their own thinking model versions, making "think first, answer later" the dominant paradigm for large models in 2025.

However, this design also comes with significant side effects:

• Token consumption multiplied many times over: For the same question, a reasoning model may use several or even more than ten times the output tokens, directly inflating API call costs. In commercial LLM services, the token is the most fundamental billing unit. One token roughly corresponds to 4 characters in English or 1-2 Chinese characters. API services typically charge separately for input and output tokens, with output token pricing often 2-4x that of input tokens. Take reasoning models as an example: a question that would normally require only 200 output tokens to answer might have the model first generating 2,000 tokens of thinking process, meaning the user effectively pays 5-10x more than with a non-reasoning model. In high-frequency production environments like customer service systems or batch data processing, this cost amplification quickly accumulates into a significant financial burden.
• Increased response latency: Lengthy thinking chains mean longer generation times, significantly impacting the experience of interactive applications.
• Severe information redundancy: Many thinking steps contribute nothing meaningful to the final answer — it's essentially "thinking for the sake of thinking."

The poster's question — "why does the thinking model even needs to be this expressive?" — is a direct expression of developer frustration with this redundant verbosity.

GLM-5.3 Flash: The Gap Between Positioning and Reality

The "Flash" naming typically implies fast, lightweight, and low-cost — similar to the product philosophy of Google's Gemini Flash series. Google's Gemini Flash lineup (such as Gemini 1.5 Flash and Gemini 2.0 Flash) represents the industry's flagship "lightweight efficient model" product line. The Flash series' design philosophy is to dramatically reduce latency and cost while maintaining sufficient capability — typically achieved through model distillation, architecture optimization, and smaller parameter counts. For example, the API price for Gemini 2.0 Flash is only a fraction of the Pro version's, yet it achieves comparable performance on most everyday tasks. This "good enough" positioning is highly popular among developers, especially for use cases requiring high throughput and low cost.

Therefore, the user's surprise stems precisely from the gap between expectation and reality: a model marketed as "fast" and "economical" yet producing unexpectedly verbose output during its thinking phase — a contrast that's particularly hard to accept.

This exposes a deep contradiction in reasoning model design: How can you retain reasoning capability while effectively controlling the token overhead of the thinking process? If even a Flash-tier lightweight model can't compress thinking chain length, this becomes a thorny engineering problem in cost-sensitive production environments.

How the Industry Is Tackling the "Thinking Efficiency" Challenge

Controllable Reasoning Length Becomes an R&D Priority

This discussion isn't an isolated case — it's a shared challenge the entire AI industry is facing. Currently, multiple model providers are exploring solutions for controllable reasoning length:

• Thinking budget parameters: Offering a thinking budget parameter that allows users to set an upper limit on reasoning tokens, thereby controlling costs. Specifically, users can set a max_thinking_tokens parameter in API requests to cap how many tokens the model can use during its reasoning phase. For example, Anthropic's Claude models allow setting a thinking budget, and Google's Gemini 2.5 series supports similar reasoning budget controls. When the model's thinking process reaches the set limit, it's forced to produce a final answer based on its existing reasoning rather than continuing to expand indefinitely. This mechanism lets developers make granular tradeoffs between accuracy and cost — setting lower budgets for simple queries and relaxing limits for complex reasoning tasks.
• Adaptive thinking mechanisms: Letting models dynamically decide thinking depth based on problem difficulty — answering simple questions directly while deploying full reasoning only for complex ones.
• Reinforcement learning to optimize reasoning efficiency: Training models to achieve the same accuracy with fewer reasoning steps. The core idea here is introducing a "conciseness reward" during training — rewarding the model not just for correct answers but additionally for reaching correct results with fewer reasoning steps. For example, the DeepSeek team observed during R1's training that the model spontaneously learned to adjust reasoning length during RL training, gradually shortening the thinking process for simpler problems. Another approach is "reasoning distillation" — using a long-thinking large model to generate correct answers along with condensed reasoning paths, then training a smaller, more efficient model on that data. Additionally, researchers are exploring "early exit" mechanisms that let models dynamically judge during reasoning whether they have sufficient confidence to reach an answer, thereby terminating thinking early.

What Developers Really Want: Not Just Accuracy, but Cost-Effectiveness

This Reddit post makes it clear that developers and users are becoming increasingly pragmatic in their expectations. They no longer care only about "can the model get it right" — they care about "whether the cost of getting it right is reasonable."

For the vast majority of everyday use cases, users don't need to see the model's complete thinking process, and they certainly don't want to pay extra for invisible intermediate reasoning steps. This presents model providers with a clear product requirement: Thinking capability should be an on-demand feature, not something forced indiscriminately on every request. From a product design perspective, this means APIs need to offer more fine-grained control options — such as whether to enable thinking mode, whether thinking content is returned to the user, and whether thinking tokens are billed separately. Only when users have full choice can the commercialization of reasoning models truly mature.

The Future of Reasoning Models: Balancing the Value and Cost of Thinking

The discussion sparked by GLM-5.3 Flash may be brief, but it hits precisely at the core issue of the reasoning model era: How to balance the value and cost of thinking.

As more models adopt the "think first, answer later" paradigm, token efficiency, reasoning length control, and the transparency and optionality of the thinking process will all become key metrics for evaluating whether a model is truly practical. For cost-conscious developers, a model that can intelligently judge "when to think deeply and when to answer quickly" is far more attractive than one that engages in "mindless long thinking."

From a broader perspective, this debate about reasoning efficiency actually reflects an important transition the AI industry is undergoing — shifting from a "performance race" focused purely on model capability to an "efficiency race" focused on real-world deployment outcomes. Just as the chip industry once transitioned from chasing raw clock speeds to prioritizing performance-per-watt, the large model industry is also entering a more mature phase: the best model isn't the one that thinks the most, but the one that thinks just the right amount.

In the future, we'll likely see more models explicitly distinguishing between a "fast mode" and a "deep thinking mode" at the product level, truly handing the choice back to users. As an important representative of Chinese-made large models, Zhipu's GLM series and its subsequent iterations on reasoning efficiency optimization are well worth continued attention.

Note: This article is based on Reddit community discussions. For specific performance data and technical specifications of GLM-5.3 Flash, please refer to official information from Zhipu AI.