Zhihu Frontier
@ZhihuFrontier
🚀Bringing China's AI & tech trends, voices and perspectives to the global stage.
⚡️Powered by 知乎/ China's leading knowledge community.
192 Following 12.3K Followers
How Tencent Packed a 770B-Parameter Model into 214 GiB
Shrinking Hy4 preview's weights from roughly 1.5TB to 214 GiB is one challenge. Preserving useful capabilities and practical inference speed is another. How did @TencentHunyuan tackle both?
Zhihu contributor yghstill, a member of Tencent Hunyuan's quantization team, explains the engineering behind it. The parameter count remains 770B; the compression changes how those weights are represented.
Four weights, five bits
Sherry is the quantization algorithm, STQ1_0 the storage format, and MIX-STQ1_0 the mixed-precision allocation scheme.
Each group of four weights takes values from {-d, 0, +d}, with exactly one zero. Four zero positions multiplied by eight sign combinations gives 32 possible patterns, requiring five bits.
That is 1.25 bits per weight for the codes alone. Including a shared FP16 scale for every 256 weights brings STQ1_0 to 1.3125 bits per weight. The complete mixed-precision model averages about 2.38 bits per weight.
Allocate precision to specific weights, not whole layers
Hy4 preview has 77 MoE layers, each with 256 routed experts. The team concentrates aggressive compression on expert weights while selectively protecting other components.
For the experts' gate/up projections, MIX-STQ1_0 uses IQ2_XXS on 48 sensitive layers and STQ1_0 on 29 less sensitive layers.
The author reports that mixing lower and higher precision produces less error at the same average bit budget than uniformly choosing the intermediate IQ1_M format.
Layer sensitivity needs more than diagonal statistics
The author describes using the full Hessian, H = XXᵀ, to measure quantization sensitivity. Its off-diagonal terms capture correlations that diagonal-only imatrix scoring misses.
In the team's comparison, the two sensitivity rankings had a Spearman correlation of -0.115. The chosen layers did not follow a simple “deeper means more important” rule: precision was allocated greedily by error reduction per additional byte.
Fit the scale and choose the zero together
This is post-training quantization, without retraining. The encoder alternates between two decisions: fitting d with weighted least squares and choosing the zero position using imatrix-weighted error.
Zeroing the smallest-magnitude weight is not always the best choice. What matters is the additional weighted error introduced by making it zero.
Across 1,200 rows of real expert weights, three alternating rounds reduced weighted reconstruction error by roughly 90% compared with the original ternary encoder. This measures local weight reconstruction, not end-to-end model accuracy.
Compression must survive the runtime
The team implemented STQ1_0 CUDA kernels in a patched llama.cpp build. In its operator comparison, STQ1_0 ran roughly as fast as IQ1_M despite the lower bit width.
The author reports nearly unchanged MRCR retrieval performance and a small decline in math. Against UD-IQ1_M at a similar bit budget, the mixed-precision model led across the reported evaluations, including a gain of more than five points on MRCR.
The result comes from combining compact encoding, calibrated quantization, selective precision and usable inference kernels.
Show more
Beyond the Model: Training a 397B Agent with SkyRL | Charlie Ruan (阮世麟)
What does it take to make RL work at 397B scale—beyond training the model itself?
Join Charlie Ruan (@charlie_ruan) for a deep dive into SkyRL and the hard-won lessons of training a 397B office-work agent—from fixing environment and harness bugs to system tuning and the final hero run.
Hosted by @qingke_ai and simulcast on Zhihu Frontier.
📅 Sept 19 · 10 AM Beijing / 2 AM UTC
📺 Watch live:
Show more
📺 Xiaomi Is Livestreaming a Production RL Run — Burn Rate Included
@XiaomiMiMo is training its MiMo-V2.6 in public — not a demo, a live post-training dashboard where every step's reward, loss and benchmark movement is watchable in real time. One day in, the meter reads roughly $1.2M spent and 60B tokens consumed. As Zhihu contributor Kitt在进化 puts it: this isn't a training site, it's a money-burning site — about ¥4,000 a minute.
His bigger point: this is rare, valuable data. Almost nobody publishes what frontier-scale RL actually costs.
1️⃣ What the dashboard actually shows
Every training step exposes the internals most labs keep private. His reading guide:
🔹 Loss family: training loss, entropy (are answers diversifying or collapsing into one mode), gradient norm, and train/inference KL divergence.
🔹 Reward: a mix of test-case scoring and rubric-based reward.
🔹 dynsam (dynamic sampling): avg@n performance over repeated tries, plus pass-rate buckets — including samples never solved and always solved.
🔹 DeepSWE v1.1 as the headline probe (mini-swe-agent, avg@3): Pro at 63.7, Flash at 60.7 at the time of writing.
2️⃣ The cost ledger, out in the open
From the dashboard he extracts the numbers the industry usually guesses at:
🔹 MiMo-V2.6 Pro: roughly $36 per million tokens of training.
🔹 MiMo-V2.6 Flash: roughly $8 per million tokens.
🔹 His rule of thumb: equivalent inference runs 30-50x cheaper than these training figures.
3️⃣ What's actually being trained
The sample distribution is also public: about 1,500 prompts per step, ~70% of them coding tasks. The remaining third is split across general, visual, cybersecurity and chat tasks — which makes this, in effect, an agentic-coding-centric RL run with side dishes.
4️⃣ Why it's worth watching
He notes a university lab livestreamed a training run days earlier, but at nowhere near this scale or frontier relevance. For anyone who wants to learn how production RL behaves — rewards, entropy, dynamic sampling, benchmarks moving step by step — this is a rare open classroom.
His only complaint, half-joking: a livestream this good deserves a comment section.
🔗 Full Reading:
#Xiaomi# #MiMo# #ReinforcementLearning# #PostTraining# #LLM# #OpenScience# #AI#
Show more
🌱 Seed-2.1-Pro Review: Better Post-Training Can't Hide an Aging Base
@ByteDanceSeed_ Seed-2.1-Pro 0915 earns higher reasoning scores with fewer tokens, and its agent ability has climbed from nearly unusable to passable. But in the three months since the last version, rivals iterated roughly a generation and a half — and the old base model is running out of tricks.
That is the verdict from Zhihu contributor toyama nao, who runs a long-running monthly logic benchmark and put the 0915 build through his full evaluation suite.
1️⃣ Coding and agent work: from unusable to passable
The jump over the predecessor is large. Deliverable completeness now beats DeepSeek V4.1 Flash, though first-pass success still trails top-tier models — a model caught in the middle.
🔹 Frontend: some aesthetic sense, but unstable. Constrained stacks like iOS system components look decent; open stacks like web or raw canvas expose visible flaws in proportion and color.
🔹 Task adaptability: every task now at least completes. In a HarmonyOS-flavored project it barely knew, the model read docs and iterated its way to usable — a good sign.
🔹 Delivery efficiency: roughly tied with DeepSeek V4.1 Flash and GLM-5.3-Flash, splitting steps evenly between writing and verifying. All three sit below the current Chinese SOTA.
2️⃣ Multi-step reasoning: the biggest gain
This is where 0915 improved most — and where it leads its tier, with a small token-efficiency edge. On problems where GLM-5.3 falls into exhaustive enumeration, 0915 repeatedly finds higher-scoring answers with fewer tokens, showing what the author calls real "big-model intuition."
The caveat: multi-turn reasoning, which demands in-context learning and reflection, remains mediocre — on par with Chinese peers.
3️⃣ Where 0915 still stumbles
Hallucination runs high, and context confusion appears regardless of prompt length — especially when source details are tangled.
The agent symptom is subtler than dropping requirements: 0915 keeps every requirement but misreads semi-ambiguous ones — arguably the more dangerous failure mode.
4️⃣ The contrarian bet: a true non-thinking mode
Seed is one of the few teams still maintaining a genuinely non-thinking mode, and this version quietly got good: average output dropped from 8K tokens back to ~1K, with no measurable capability regression, a slight gain in complex reasoning, and readable prose intact.
For latency-sensitive scenarios that still need some reasoning, the author considers it a legitimate option.
5️⃣ The long march
His closing frames 0915 as a rest stop, not a destination: the predecessor's lukewarm market reception forced ByteDance's team into a forced march of biweekly iterations, and better post-training is now visibly paying off in cost per task.
But the base is old, and the competition has moved. His last line is worth keeping: sometimes the long way around is the real shortcut.
🔗 Full Reading:
🔗 Key links:
Author's monthly logic benchmark (Aug 2026):
#ByteDance# #Seed# #LLM# #AIAgents# #LLMBenchmark# #ReasoningModels# #AI#
Show more
The livestream is live now! If you're into LLM training, distillation, or RL / OPD, come check it out! ⬇️
Most “Self-Evolving AI” Is Not Recursive Self-Improvement Yet
AI may generate its own data, rewards, skills, and code. But if humans still define what counts as better and approve deployment, the loop is not closed.
Zhihu contributor 一口鸟 (@alsaceym) argues that RSI’s hardest bottleneck is reliable verification.
1️⃣ Moving humans out of the loop
RSI progresses through three stages:
🔹 Human in the loop: AI proposes changes; people approve them.
🔹 Human on the loop: data, rewards, and verifiers are automated; people supervise deployment.
🔹 Closed loop: the system generates, verifies, and applies improvements itself.
Most “self-evolving” systems remain in the second stage.
2️⃣ What actually improves?
Self-refine changes the current answer. Test-time training writes experience into weights.
Agent evolution modifies prompts, tools, memory, skills, workflows, or Agent code across tasks.
output → weights → the Agent itself
Training-time RSI follows another ladder:
🔹 Zero-label: AI generates supervision.
🔹 Zero-data: AI also generates problems and curricula.
🔹 Auto research: AI chooses hypotheses, training recipes, and experiments.
The system gradually takes over how to learn, what to learn, and finally how to improve learning itself.
3️⃣ Self-improvement can amplify mistakes
A generator and verifier may share the same biases. Wrong outputs can produce biased evaluations, biased learning signals, and stronger errors.
Even correct rewards do not guarantee stability: training can improve and later collapse.
Self-play may also lose diversity or favor problems that are easy to reward rather than genuinely useful.
Automation makes grounding more important, not less.
4️⃣ Verification is the real bottleneck
Math and code are RSI-friendly because proofs, unit tests, and execution feedback provide clear signals.
Open-ended Agent work is harder. A verifier must judge not only correctness, but novelty, usefulness, importance, and research taste.
The next step may be evolving the verifier itself. But if the policy and evaluator change together, what keeps both aligned with reality?
✅ The boundary of true RSI
The loop is expanding:
answer → experience → learning signal → problem and curriculum → verifier
True RSI requires improvement across every layer without losing contact with real objectives.
Until evolving verifiers remain reliable without constant human grounding, recursive self-improvement is still an aspiration rather than an achieved capability.
🔗 Full analysis:
#RecursiveSelfImprovement# #RSI# #SelfEvolvingAI# #AIAgents# #ReinforcementLearning# #AISafety#
Show more
DeepSeek V4.1 Gives Prefill and Decode Different Compute Paths
Prompt tokens mostly traverse 20 layers; generated tokens traverse all 40. This Causal Encoder-Decoder design nearly halves long-input prefill while preserving autoregressive generation.
Zhihu contributor 潜龙勿用, Changxin Ke(柯昌鑫), a graduate researcher at ICT, CAS, explains how its architecture and post-training were designed together.
1️⃣ A causal encoder, not T5
The 40-layer backbone is split into a 20-layer causal encoder and a 20-layer decoder. Both remain causal.
The encoder processes the prompt and supplies the decoder’s global KV. Most prompt tokens avoid the decoder stack, while generated tokens still run through all 40 layers.
That means 8B active parameters per prefill token versus 16B per decode token.
2️⃣ Most layers share global memory
CSA2 uses three modes: Full creates global KV and an index; Reindex shares the KV but selects new positions; Reuse shares both.
Only four layers create independent global KV, four reindex it, and 30 reuse both KV and the latest index. Each layer retains its own query and local SWA state.
The first Full layer builds up to 16,384 candidates. Later layers search this pool for their Top-512.
From 4K to 1M context, decode FLOPs per token rise only about 25%.
3️⃣ Serving approximations enter training
Exact reconstruction of decoder SWA states would replay 2,560 prompt tokens.
V4.1 replays only the final 128 encoder outputs and trains the model to tolerate the approximation.
With FP4 global KV, cache falls to 890 bytes per token, persistent cache to roughly one eighth of V4-Flash, and prefill compute close to half.
Bounded replay and constrained retrieval are not last-minute serving tricks. The model experiences them during post-training.
4️⃣ Post-training is an evolving Agent system
Each RL task combines a problem, environment, and verifier.
New trajectories can reveal shortcuts, broken environments, or verifier errors and send the task back for repair.
V4.1 trains across multiple harnesses, merges checkpoints between RL runs, and finishes with on-policy distillation from more than 40 teachers.
Raising reasoning effort from 25 to 100 increases output length about 2.5×, while average Pass@1 across eight benchmarks rises from 67.1% to 76.3%.
✅ The real design choice
V4.1 aligns model structure, cache policy, retrieval limits, training environments, and inference around long-running Agents.
The model learns under the same constraints the deployed system will actually impose.
🔗 Full analysis:
#DeepSeek# #DeepSeekV41# #LLMArchitecture# #AIAgents# #LongContext# #AIInfra#
Show more
📘 Introducing the Zhihu AI Cookbook (CN)
Saved dozens of AI articles but still not sure where to begin? We’ve organized some of Zhihu’s best technical discussions into clear, structured learning paths.
Over the past few years, Zhihu has become home to a wealth of in-depth AI writing from researchers, engineers and practitioners. The Zhihu AI Cookbook brings together some of the most useful and enduring pieces in one place.
The first edition brings together 80+ selected posts from 68 contributors across three tracks:
🖥️ AI Infra
🧠 Reinforcement Learning for LLMs
🤖 Embodied AI
It’s not another textbook. Think of it as a map connecting explainers, source-code walkthroughs, project retrospectives, interview insights and open-source tutorials.
🧭 How to use it:
1️⃣ Start with the introductory guide to understand the key concepts and prerequisites.
2️⃣ Choose the chapter that matches what you need right now.
3️⃣ Read each selection with a guiding question, then use the self-check prompts to test your understanding.
4️⃣ Follow the links to the original Zhihu posts for full derivations, implementation details and community discussions.
5️⃣ Put the ideas into practice with hands-on projects and open-source tutorials.
Whether you’re exploring a new research direction, working through a project or preparing for technical interviews, the Zhihu AI Cookbook can help you find the right place to start and build a more complete understanding.
🤝 With open-source tutorials contributed by our content partner, @datawhale2018.
🌏 This edition is currently available in Chinese. An English version is coming soon.
🚀This is only the first edition. More topics and learning paths are on the way…
🔗 Explore the Zhihu AI Cookbook (CN):
💻 View it on GitHub:
If you find it useful, give the repo a star and let us know what topic we should cover next. 🌟
#AI# #LLM# #EmbodiedAI# #AIInfrastructure# #ReinforcementLearning# #MachineLearning#
Show more
Rethinking OPD: One Query, Hundreds of Steps |Bingxiang He
Why can a single query keep improving a model for hundreds of training steps?
Join Bingxiang He (@HBX_hbx) for a deep dive into Rethinking OPD and One-Shot OPD, hosted by @qingke_ai and simulcast on Zhihu Frontier.
📅 Sept 17 · 8 PM Beijing / 12 PM UTC
📺 Watch live:
Show more
DeepSeek V4.1 Flash Is an Architecture Reset, Not Just a Cheaper Model
Despite having more total and active parameters than its predecessor, V4.1 Flash cuts working KV cache to one quarter and persistent cache storage to one eighth.
Zhihu contributor Exhalation explains how it does this by deleting old modules, sharing KV states, and recomputing local context.
1️⃣ DeepSeek removed its own previous ideas
🔹 MTP: external draft models such as DSpark weakened its speculative-decoding value, while the auxiliary loss no longer justified its memory cost.
🔹 Heavily Compressed Attention: its global-summary role was ambiguous and difficult to combine with FP4 storage.
🔹 Dense warmup: V4.1 trains sparse attention from scratch rather than starting with one trillion dense-attention tokens.
2️⃣ Store less, reuse more
Non-SWA KV cache moves from FP8 to FP4, while the more sensitive SWA portion remains FP8.
DeepSeek no longer persists SWA cache. When a conversation forks from an earlier point, the system rebuilds only a small local window. Post-training simulated this process to limit numerical drift.
A modified YOCO design provides the other major saving. Upper layers reuse the same lower-layer source representation, adding only a layer-specific projection.
The result is roughly half the KV storage and close to 50% less historical prefill computation in the idealized case.
3️⃣ Sparse attention reuses its search
Sparse attention lowers attention cost from O(n²) to O(kn), but finding the top-k tokens can still retain an O(n²) component.
V4.1 Flash either reuses an earlier layer’s top-k result or selects a smaller candidate-block pool before re-indexing.
This prevents token selection from becoming the bottleneck at long context lengths.
4️⃣ Engram and mHC were streamlined
Engram replaces an expensive second-order optimizer state with a Sinkhorn-style update, removes causal convolution, and extends matching from 3-grams to 4-grams.
mHC reorders residual mixing across layers, reducing estimated I/O from (4n+4)d to (3n+2)d.
✅ The larger pattern
DeepSeek is not merely compressing an existing model. It is willing to discard its own previous components when a cheaper system-level design emerges.
V4.1 Flash is less a smaller V4 than a new answer to one question: how much intelligence can be delivered per byte of memory and unit of inference cost?
🔗 Full analysis:
#DeepSeek# #DeepSeekV41# #LLMArchitecture# #AIInfra# #KVCache# #SparseAttention#
Show more
When AI Automates the Craft You Loved
DeepSeek engineer Liu Shengyu’s viral article, "I Had to Bury My Talent in Yesterday", is not simply about losing a job.
It captures something more personal: AI may preserve an expert’s value while taking away the part of the work that gave it meaning.
Zhihu contributor BBuf sees a warning about craftsmanship, how expertise is formed, and who controls frontier intelligence.
1️⃣ From craftsperson to machine operator
Kernel optimization was deeply hands-on.
Engineers learned Hopper and Blackwell, arranged shared memory, tuned warps, inspected PTX and SASS, then profiled repeatedly to push throughput higher.
The process itself was rewarding. But the role is shifting from weaving the sweater to supervising the knitting machine.
Experience still matters. Experts know which designs and failure modes to watch. Yet the activity they loved is no longer what production demands.
2️⃣ Kernels are ideal work for agents
An agent can read CUDA, PTX, and SASS, identify stalls, propose an optimization, compile it, run benchmarks, fail, and try again.
A human explores only a few paths at once. Fast models paired with tens or hundreds of agents can search far more broadly.
BBuf’s conclusion is blunt: whenever work supports repeated, meaningful trial and error, humans may struggle to compete.
The same pattern could extend from kernels to algorithms and mathematics.
3️⃣ The expertise paradox
If beginners let AI write everything from day one, where will senior judgment come from?
Experienced engineers may remain better at directing agents because they understand hardware and hidden trade-offs.
But the traditional path for acquiring that intuition may disappear as the underlying craft is automated.
The risk is not only fewer jobs. It is losing the apprenticeship process that once created experts.
4️⃣ Intelligence is also a distribution problem
If frontier models become the main engine of technical work, who controls the compute behind them?
Open weights do not mean everyone possesses frontier intelligence.
BBuf argues that unequal access to compute could become unequal access to effective intelligence.
The open-versus-closed debate is not merely about licenses. It is also about who can afford to use powerful intelligence at scale.
✅ What may be buried
AI may not eliminate experts first. It may turn them into supervisors of systems that perform the craft they once loved.
The harder question is whether we can preserve human judgment and the joy of making things while embracing tools that are faster than us.
🔗 Full analysis:
#DeepSeek# #CUDA# #AIInfra# #AIAgents# #FutureOfWork# #OpenSourceAI#
Show more
Zhihu question: What do you think of “I Have No Choice but to Bury My Talent in Yesterday” by DeepSeek’s Liu Shengyu?
— Original answer by Liu Shengyu himself
Let me answer this as the original author.
The link to the original article is at the end. Feel free to read it.
The way this article went viral was actually quite unexpected for me.
My original purpose in writing this article was not to express anxiety about unemployment, but to say goodbye to the time I spent writing kernels by hand. Before agents appeared, I typed out most of my code character by character. This seemingly tedious process was, for me, a pleasure: I could quiet my mind and carefully think through every detail, from module organization and the arrangement of functionality down to code logic and variable names. I also enjoyed racking my brains over kernel scheduling and optimization strategies, improving kernel performance, and ultimately beating established implementations (such as Flash Attention, kernels officially written by NVIDIA, and even certain tasks previously widely considered “impossible to optimize well,” such as token-level sparse attention). “The excitement I feel the moment I invent a new technique or see my kernel’s performance improve is no less than what a speedrunner feels when breaking their own previous record.” But now, AI is about to take this joy away: for the sake of productivity and kernel performance (today’s AI works faster than I do; tomorrow’s AI will be both fast and good), I have to embrace the new things of this new era and study how to use AI to write kernels better. During working hours, I will no longer have the opportunity to enjoy quietly and slowly writing, tuning, and optimizing kernels. Presumably, one day in the future, “writing kernels by hand,” or even “programming,” may become a recreational activity rather than a productive activity, just as hardly anyone today uses a javelin to hunt, treating it instead as a competitive sport. This amounts to forcing me to give up something I once loved and turn in another direction. Even if the new direction is equally fascinating, the feeling is still hard to bear. As the title says: I have no choice but to bury my talent in yesterday.
I am someone who places great value on memories and the feelings that move me. But memories inevitably fade, gradually buried beneath time’s fine snow (I previously wrote another article about this; see the link at the end). So this article is actually a reflection on, and remembrance of, my past. Through this article, I hope to freeze those images of writing kernels by hand, preserving these true memories and heartfelt emotions for me to look back on ten or twenty years from now. At the same time, I hope to use this article to give myself the courage to let go of the past, pick up new tools, and step bravely into the new era.
A passage I really like, excerpted from the comments on a WeChat Official Account:
“It’s like a soldier during a lull in battle, huddled in a corner of a trench, writing his own character arc on a tattered piece of paper, his rifle standing beside him.”
But people’s understanding seems to have diverged considerably from what I originally meant... The article’s final two sections were originally just some rambling thoughts: the second-to-last section briefly mentioned some social problems brought about by AI, without really analyzing them or offering answers in much detail; the final section contained some scattered personal thoughts I had recently, expressing the view that frontier intelligence should still be “provided to everyone in an open, inexpensive way.” But because I am not an expert in history, sociology, or other humanities disciplines, I only touched on this part briefly and moved on (while also taking a swipe at [someone or something omitted in the original] that I have never particularly liked). The discussion of communism and 2077 in it is not necessarily correct either. Although the two statements in it—“One of the reasons I chose DeepSeek was that I did not want the world to become like 2077” and “May all the beauty be blessed”—are true, and these really are my ideals, this is not the central point of the article. This passage also represents only my personal views, not the position of any company I work for.
As it turned out, after the article was published, although many people did indeed resonate with my nostalgia for the old days, most people put the spotlight on the final passage. The highest-ranked answers on Zhihu were fairly well written (which shows that Zhihu users’ reading comprehension is still pretty good), but in the comments on WeChat Official Accounts, large numbers of people were discussing Anthropic’s and DeepSeek’s attitudes toward open access to intelligence. On Xiaohongshu, there were even responses along the lines of “DeepSeek strikes back at Anthropic.” On platforms outside China, the word “communism” prompted all sorts of armchair political commentary and even personal attacks... Some people even saw the words “I’ll leave it here, otherwise I’m afraid it won’t pass review” and started wildly imagining how strict content censorship in China must be, and so on (in fact, I wrote those words because I felt I lacked sufficient knowledge and life experience to assess communism). I marvel at some journalism graduates’ ability to stir up hype, and reading all this also left me feeling rather helpless... Please pay a little more attention to the article’s main subject.
Returning to the subject, AI will certainly keep getting stronger in the future: even within the current paradigm of agents + harnesses + long context + CoT, AI’s capabilities will continue to advance steadily as data quality, model depth, and context length keep scaling. Not to mention that embodied intelligence, RSI, and other technologies we do not yet know about are still waiting ahead. I am optimistic about the capabilities of future AI, and relatively optimistic about my place in future society. But I am pessimistic about whether people in the future will still be able to settle down and devote themselves seriously to something, and also pessimistic about whether I will be able to keep doing something as both a job and a hobby over the long term.
But even so, I will continue to persist in writing kernels, and continue to bring AI agents into kernel writing. First, because “Of course I hope I won’t be overthrown by a revolution, but if I must be, I hope the person who overthrows me will be myself” (evolving myself is better than being made obsolete by others). Second, because I still hope that we (or other AI companies that likewise uphold the principles of openness and sharing) can build the most powerful intelligence before certain companies do, and bring its benefits to everyone. Hobbies and interests are one thing; ideals and convictions are another. In the future, I will also try, as much as I can, to realign my interests, strengths, and the needs of the times, and try to find a haven of my own in an era that belongs to AI. After having no choice but to bury my talent in yesterday, I still have tomorrow’s light to pursue. After being soaked by this cold rain at the end of the world, I will still use my heart, warming once more, to dispel the gloom and search for that gradually emerging shade of blue beyond the night[1] .
[1] lyrics from COP’s “Singer at the World’s End”
🔗 Full Reading:
📖I Have to Bury My Talent in Yesterday:
📖 Further reading — Liu’s “2025 Year-End Reflections, Part II: Memory”:
---
知乎问题：如何看待 DeepSeek 刘胜与的《我不得不把才华埋葬在昨天》？
——刘胜与 亲自答 原文
原作者来回答一下
原文链接位于文末，大家可以读读。
这次这篇文章的爆火其实是挺出乎我意料的。
我写这篇文章本来的目的，并非要表达对失业的焦虑，而是想和我过去手写算子的那段时光说句再见。在Agent出现之前，大部分代码都是我一个字一个字敲出来的，这看似枯燥的过程，对我来说反而是一种享受：我可以静下心来，仔细思考大到模块组织、功能排布，小到代码逻辑、变量命名的每个细节。我也享受绞尽脑汁研究算子的调度和优化方案，提高算子性能，最终打败公认实现（比如Flash Attention，NVIDIA官方编写的算子，甚至是某些之前公认的“不可能优化好”的任务，比如token级稀疏的attention）的感觉"我在发明了一种新技术、或者看到自己算子的性能上升的那一刻，心中的激动程度不亚于游戏的速通玩家打破了自己过往的记录"。但是，现在这种快乐要被AI夺走了:为了生产效率和算子性能（现在的AI干活儿比我快，以后的AI则是又快又好），我必须迎接新时代中的新事物，研究如何用AI更好地写算子，在工作时间中再也没机会享受静静地、慢慢地写算子、调算子、优化算子的时光了。想必未来有朝一日，“手写算子“甚至”编程“可能会成为一种娱乐活动而非生产活动，就像是现在几乎没人会用标枪打猎，而是把它作为一种竞技活动那样。这相当于逼着我放弃我曾热爱的事物，强行转向另一个方向。哪怕新方向同样令人着迷，这种感觉都不太好受。正如标题所说的：我不得不把才华埋葬在昨天。
我是一个很看重记忆和感动的价值的人，可奈何记忆会褪色，会被时光的细雪渐渐掩埋(之前还写过另一篇文章聊了聊这事儿，见文未链接)。因此，这篇文章其实是对我过去时光的一段总结与怀念。我希望借这篇文章，将过往的那些手写算子影像定格，以保存这份真切的记忆与真挚的感动，供十年、二十年之后的我来怀念。顺带借着这篇文章，给予自己放下过去、拿起新工具、勇敢地走向新时代的勇气。
一段我很喜欢的话，节选自公众号评论区：“像是在一场战斗中的间隙，一个士兵在战壕的角落里，往残破的纸上写着自己的人物弧光，钢枪立在身旁。”——@枕语
但大家的理解似乎和我的原意出现了不小的偏差...本来文章的最后两节只是一些碎碎念:倒数第二节简要提及了一些AI带来的社会问题，但其实也没有很仔细地去分析或回答;最后一节则是我个人在前段时间的一些零碎思考，认为前沿智能还是应该"以一种开放、廉价的方式，供应给所有人"。但由于我并不是历史学、社会学等人文学科的专家，这部分我也只是稍加探讨并一带而过(顺便踩一脚我一直看不太惯A/)，里面关于共产主义与2077的辩论也不一定对。虽然里面说的"我选择DeepSeek的原因之一是不想让世界变成2077那副模样"以及"Mayall the beauty be blessed"两句话是真的，这确实是我的理想，但这并不是本文的中心。这一段也仅代表个人观点，不代表任何我所在的公司的立场。
结果，这篇文章发出去之后，虽然确实有很多人和我关于旧日时光的怀念产生了共鸣，但大部分人都把聚光灯打在了最后一段上。知乎上排名最高的几条回答写得还行(说明知乎用户的阅读理解能力还是挺好的)，但微信公众号评论区中有大量人在探讨Anthropic和DeepSeek关于开放智能的态度，小红书上甚至已经有"DeepSeek反击Anthropic"这种回答了，外网上更是就这共产主义这个词展开了各式各样的键政言论甚至人身攻击...甚至有人看到"就写这些吧不然我怕过不了审"这几个字之后就大肆脑部国内言论审核严格云云(其实我写这几个字是因为感觉没有足够的知识与阅历来评价共产主义)。我很感慨某些学新闻学的的炒作能力，同时看了这些之后感觉很无奈...大家还是多关注关注文章的主题吧。
回归主题，AI在未来不断变强是肯定的:哪怕局限于当下的Agent+Harness +长上下文+CoT的范式，随着数据质量、模型深度、上下文长度不断继续扩展(scale)，AI的能力也将稳步前进。更别提，后面还等着具身智能、RSI、以及一些我们尚未知晓的其他技术。我对未来的AI的能力是乐观的，对于我在未来社会中的位置是相对乐观的，但对于未来人们还能不能潜下心来认真做一件事情是悲观的，对于我未来能不能长久地把一件事情同时作为工作和爱好，也是悲观的。
但哪怕这样，我还是要继续坚持写算子、以及不断引入AI Agent写算子。一是因为"我当然希望自己不要被革命，但如果非被革命不可的话，我希望革我自己命的人是我自己"(被别人淘汰不如自我进化)，二是因为我还是希望我们(或者其他同样秉持着开放共享理念的AI公司)能够先于某些公司，做出最强大的智能，惠及所有人。爱好兴趣是一回事儿，理想信念则是另一回事儿了。我在未来也会尽量尝试重新对齐爱好、特长和时代需求的方向，尝试在属于AI的时代找到属于自己的乐土。在不得不把才华埋葬在昨天后，我还有明天的光明可以追逐。在被这场世末的凉雨淋湿后，我仍会用回温的心灵驱散阴霾，寻找越过黑夜后渐变的那一抹蓝色[1]。
[1] 化用了 COP 的《世末歌者》等歌曲的歌词。
写记忆与感动的文章，以及原文链接：
2025 年终总结之二：记忆：
我不得不把才华埋葬在昨天：
Show more
Full text (translated by Astra-xhigh, I'm out of everything else):
I Have No Choice but to Bury My Talent in Yesterday
A few days ago, DeepSeek v4.1 was released, raising the ceiling of what small models can do by yet another notch.
AI has advanced far faster than anyone expected. From the earliest version of ChatGPT, which could do little more than stumble through conversations like a child learning to speak and had a context window of only a few thousand tokens, to reasoning-capable models such as OpenAI o1, DeepSeek R1, and Kimi K1.5 Thinking, took only two short years. From reasoning models to the agents we have today—able to work fluidly with all kinds of tool harnesses, execute commands, and complete complex tasks—has taken only another year and a half.
It is hard to imagine what AI will look like another one, two, or three years from now: how powerful it will be, whether it will already have acquired the ability to improve itself, and how deeply it will have spread into areas such as embodied intelligence.
AI Is Getting Better and Better at Writing Kernels
AI has been advancing just as quickly in my own field: the design and implementation of high-performance kernels.
In the space of only a year, it has gone from being a little assistant that could help me look up documentation, read code, and find bugs to something approaching a kernel expert in its own right: capable of reading CUDA, PTX, and SASS code independently, using specialized tools to analyze the stalls associated with individual instructions, and then optimizing kernels on its own.
I believe that before long, it will also be able to design kernel schedules independently, evaluate the performance of different scheduling strategies, implement them, and optimize the result.
Of course I am proud of DeepSeek v4.1’s success. After all, I wrote its main Attention kernels [1], and the fact that the model performs so well is also, in a sense, a validation of my work.
But the times keep moving forward, and no one can stop technological progress. I know very well that in another six months or a year, the kernels written by AI will probably be every bit as good as mine—and perhaps better.
AI can reason at 300 tokens a second, type out a command in half a second, and produce a piece of code in twenty seconds. I cannot. AI can keep increasing its model depth, reasoning effort, tool-call budget—the frequency with which it interacts with its environment—and even its degree of parallelism. I cannot.
Humanity has never shown much hesitation when it comes to destroying itself.
So why, when I know perfectly well that “the better the kernels I write, the faster our new models will train and run inference; the faster the models improve, the sooner I myself will be replaced,” do I still do everything I can to optimize them?
Partly because writing kernels is like playing a game to me. I get an enormous amount of pleasure from it. Whenever I invent a new technique, or see one of my kernels become faster, the excitement I feel is no less intense than what a speedrunner feels after breaking their own record. And when I see one of my kernels dramatically outperform the hardware vendor’s official implementation, I feel an equally powerful sense of pride.
But there is a more important reason.
Even if I simply gave up and started coasting—or deliberately put obstacles in the way to slow down model training—other companies’ models would continue advancing as usual, and in the end they would make me obsolete just the same.
“Of course I would rather not be swept away by the revolution. But if I have to be, then I would rather be the one who revolutionizes myself.”
When everyone is this determined to engineer their own obsolescence, I have little choice but to join this brutal arms race.
And What About Me?
When the day really comes that AI is better at writing kernels than I am, what will happen to me then?
My own judgment is this: I probably will not lose my job, but I will have to change what I do.
I should still be able to make a living. But I may no longer have the chance to do the work I once loved.
I once came to a conclusion about the pace of change and my own place in the future. The world is changing so quickly—the development of AI above is a perfect example—that I have no way at all to predict what things will look like five or ten years from now. But whatever happens, I believe that with my breadth of vision, judgment, initiative, and intelligence, I will be able to keep a seat at the table and find my way back to the leading edge of the times.
But that conclusion can only reassure me that I will not become unemployed. It cannot reassure me that I will never have to change professions. If anything, it tells me that changing professions may be precisely how I avoid unemployment.
And what does changing professions mean?
It means giving up the field of kernel design, implementation, and optimization that I have spent so long cultivating and have come to love so deeply, and instead becoming a “mech pilot” for AI agents.
Before, three things were largely aligned: what interested me, what I was good at, and what industry needed. Now AI has taken the thing I am good at and become even better at it. At the same time, industry demand has drifted from “people who can write high-performance kernels” to “people who can use AI to produce high-performance kernels faster.”
To keep up with what industry needs, I will inevitably have to leave behind the direction I once loved and move into some unknown new one.
I believe that with my understanding of engineering, of the requirements of higher-level models, and of low-level hardware, I will still be able to produce high-quality kernels efficiently. I also know that I may come to love this new direction.
Or I may not.
But there is something genuinely painful about having the thing you love taken away from you.
That quiet contentment of sitting at my workstation, settling in, and spending an entire afternoon writing kernels may sing its swan song this summer.
I have no choice but to bury my talent in yesterday and become a mech pilot.
There are more gears in my hands now, but fewer rhythms in my heart.
An analogy might make this easier to picture.
Suppose you are a master knitter. You are especially skilled at weaving intricate patterns and matching different colors. The sweaters you make are durable and beautifully patterned, and wealthy people from all the surrounding towns and villages come to ask you to make sweaters for them. You make a good living from it.
And you genuinely love the work itself. You love sitting by the window, brewing a pot of tea, looking out at the green hills, clear water, cattle and sheep, and wisps of cooking smoke in the distance, and quietly spending an afternoon knitting.
Then one day, someone invents a miraculous machine. Give it yarn and a pattern, and it can automatically knit the sweater for you. The quality and texture are every bit as good as what you could make by hand, and it works far faster than you ever could.
You know perfectly well that your peers can use this machine to reach, effortlessly, the level you once spent years attaining. So you have no choice but to use it as well.
You also know that with the twenty years of knitting experience you have accumulated, even once everyone has access to the same machine, you will still be able to produce better sweaters, faster, than your peers.
But the pleasure of sitting by the window listening to the rain, guiding needle and thread, and letting the hours pass slowly has, in the end, been crushed beneath the roar of the machine.
I know there is something deeply helpless about all of this, but there is no real way around it. I can probably keep my livelihood, but I will most likely have to give up an old love.
I am the sort of person who keeps reason and emotion fairly compartmentalized. When something needs to be handled rationally, I can be very rational. But I also have a sentimental side.
I remember that when I moved out of an apartment I had lived in for a year, I cried hard because I could not bear to part with all the memories tied to that place.
Saying goodbye today to the age when kernels were written by hand and optimized in the human mind is undoubtedly more painful still.
I do not know whether any readers have felt something similar.
But I suppose there is no other way for this to go.
And What About Everyone Else?
As AI continues to improve, I also find myself worried about a few questions:
Are students today increasingly likely to use AI to do their assignments, especially hands-on work such as labs? Imagine having two choices in front of you. One is to spend eight miserable hours struggling through a lab and perhaps not even get full marks. The other is to launch an AI model, spend a few cents and a few minutes, and have it write code that earns full marks for you. Which one are most students going to choose?
The point above may leave large numbers of students with seriously underdeveloped engineering ability: the ability to organize code, build systems, anticipate future needs and design for them in advance, create good abstractions, and so on. As AI becomes more capable, will those “engineering skills” still be necessary? Will they gradually become obsolete, the way fluency in handwritten x86 assembly largely has? Or will they remain permanently valuable, like understanding the entire computing stack from software to systems to hardware? If it is the latter, then we may be in trouble. Put AI in the hands of someone with poor engineering judgment, and they can now produce mountains of terrible code several times faster than before, burying all kinds of hidden problems inside systems and making the world even more of a ramshackle operation held together by improvisation.
In the society of the future, will power matter more than technical ability or intelligence?
Perhaps these are questions that only the times themselves can answer.
Conclusion
As AI develops, the society of the future may be pulled toward one of two extremes: communism or Cyberpunk 2077.
In the former, productive capacity is liberated on an enormous scale, and people’s standard of living rises substantially. (I’ll leave it at that, or I’m afraid this might not make it past moderation.)
In the latter, a handful of technology companies control most of society’s resources. Only a tiny number of people have access to the most advanced AI and other technologies and are able to achieve something approaching “mechanical ascension,” while most people are left with only weak, second-rate AI.
Moving from one social class to another would become harder and harder: you would first need access to the strongest AI in order to climb the class ladder, creating a self-reinforcing trap.
Suppose Anthropic were to retain control of the most advanced AI in the world indefinitely.
Which way do you think society would go—communism or 2077?
Take a guess.
That is why I still believe that frontier intelligence should be made available to everyone openly and affordably.
I do not trust Anthropic or OpenAI to do that. In particular, I do not want Anthropic to control the world’s most advanced artificial intelligence or AGI. To put it dramatically, I think the stakes would be comparable to Hitler obtaining the atomic bomb before the Allies did.
That is also why I chose to stay at DeepSeek, and why I have continued to stay.
We work on AI that is powerful, fast, and accessible to everyone, and we open-source it. Perhaps that can pull the world at least a little farther away from the 2077 end of the spectrum.
I hope the world we are heading into turns out all right.
May all that is good and beautiful endure.
[1] By “main Attention,” I mean only MQA attention with head dim = 512. This does not include the indexer used to select the top-k important tokens. That part was written by other colleagues—who are every bit as skilled—together with their AI agents.
-----
Original:
我不得不把才华埋葬在昨天
前几天，DeepSeek v4.1 发布了，将小模型能力的高度又向上推进了一个档次。
AI 发展的速度远远超过了所有人的预期。从那个只会咿呀学语地聊天、上下文长度只有几千 token 的初版 ChatGPT，到具有推理能力的 OpenAI o1、DeepSeek R1 与 Kimi K1.5 Thinking，只不过短短两年；从推理模型到如今能够流畅地在各类 harness 工具中执行命令、完成复杂任务的智能体，也不过一年半。很难想象，倘若再等上一年、两年、三年，彼时的 AI 会成为什么样子，会有多么强大，会不会已经具备了自我进化的能力，并深度渗透进了具身智能等领域。
AI 越来越会写算子了
AI 在我所从事的算子设计、编写这一领域同样进步飞速，在短短一年的时间内，他已经从一个只能帮我查查文档、读读代码、找找 bug 的小助手，蜕变成了一位能够独立阅读 CUDA、PTX 与 SASS 编码、通过专业工具分析每条指令的停顿时间、进而独立优化算子的算子大师。相信在不久的未来，它也能拥有自己独立设计算子调度、评估不同调度方案的性能、将其实现并优化的能力。
我当然为 DeepSeek v4.1 的成功而骄傲 —— 毕竟它的主 Attention 算子都是我写的 [1]，它的优秀正是对我的算子的一份肯定。但是，时代的车轮滚滚向前，技术的发展无人能挡。我很清楚，再过上半年或者一年，AI 写的算子大概率就会和我写得同样优秀，甚至将我超越。AI 能一秒思考 300 个 token、半秒敲出一行命令、二十秒写完一份代码，而我不行；AI 能在模型深度、思考强度、工具调用量（和环境交互的频率）、甚至并行度等方面都能不断提升，而我不能。
人类在毁灭自己这件事情上，自古以来都表现得毫不犹豫。为什么在明知“我算子写得越好，我们的新模型的训练、推理速度就会越快，模型能力进步就会更快，我就会更早地被取代”的情况下，我仍然选择尽力优化算子呢？一方面确实是因为写算子对我来说就像打游戏一样，能为我提供极大的快感。我在发明了一种新技术、或者看到自己算子的性能上升的那一刻，心中的激动程度不亚于游戏的速通玩家打破了自己过往的记录。同时，当看到自己的算子的性能远超厂商官方的算子时，我心中也会萌生极大的自豪感。但除此之外，一个更重要的原因是，哪怕我就此“摆烂”甚至故意下绊子耽误模型训练，其它家的模型也会照常发展并最终将我照杀不误。“我当然希望自己不要被革命，但如果非被革命不可的话，我希望革我自己命的人是我自己”。在大家都这么执着于毁灭自己的时候，我也不得不加入这场残酷的军备竞赛。
那我呢
等到 AI 写算子的水平真的高于我的那天，届时的我会怎么样呢？
我的判断是：我不至于会“失业”，但必须要“转业”。我的饭碗尚且能保住，但这可能会导致我再也没机会从事那份我曾热爱过的工作。
我曾经对时代的变化与我个人在未来的处境做出过一个判断：由于时代变化真的太快（上文的 AI 发展就是一个很好的例子），我完全无法预知五年、十年后会发生什么，但不论如何，我相信凭借着自己的眼界、判断力、主观能动性与智力，留在时代的牌桌上，并重新立于时代的潮头。但是，这个判断只能保证我不会“失业”，而无法保证我不需要“转业”，倒不如说这个判断鼓励我通过转业来避免失业。
那转业代表什么呢？它代表着我需要放弃我深耕已久并充满热爱的算子设计、编写、优化领域，转而去做 Agent 的“机甲驾驶员”。在之前，我的兴趣、我所擅长的、以及工业界所需要的，三者是基本对齐的；而现在，AI 让我所擅长的变成了它更擅长的，也让工业界的需求从“会写高性能算子的人”漂移到了“能用 AI 更快地产出高性能算子的人”。为了适应工业界的需求，我势必要放弃之前那个我热爱的方向，转向一个未知的新方向。我相信我能凭借着自己对于工程学、上层模型需求和底层硬件的理解，继续高质量、高效率地产出算子，我也知道我可能会热爱这个新方向（也可能不会），但被夺走热爱的感觉，确实不太好受。那份坐在工位上静心写上一下午算子的清欢，可能会在这个夏天成为绝唱。我不得不把才华埋葬在昨天，去做一位机甲驾驶员。我的手中多了些齿轮，但心中少了些节拍。
可以打个形象的比方：你精通织毛衣技术，尤其擅长各种图案的织造与各色色彩的搭配。你所织出的毛衣质量过硬且花纹美观，十里八乡的富人都来请你为他们织毛衣，你借此赚到了不少钱。同时，你十分享受着那种坐在窗边，沏一壶清茶，望着窗外的青山、绿水、牛羊与炊烟，静静地织上一下午毛衣的感觉。但有一天，有人发明出了一台神奇的机器，只需提供毛线与图案，便可自动织出毛衣，质量与纹理都不亚于你亲手织造的，且速度远快于你。你很清楚，你的同行可以凭着这台机器轻松达到你曾经的水平，因此你不得不也去用它。你也知道，凭借着你过去二十年攒下的织毛衣技术，哪怕大家都有机器，你织毛衣的速度与质量也还能超过同行。但那份临窗听雨、引针穿线、慢度光阴的意趣，终究还是被机器的轰鸣碾碎了。
我知道这很无奈，但没办法。饭碗可以保住，但旧日的热爱大概率是要放弃的。我是一个理性和感性分离得比较开的人，在需要用理性处理问题时可以很理性，但有时也会表现出感性的一面。我记得我在搬离住了一年的出租屋时，还大哭了一场，舍不得和过去的记忆分别。今天和之前那个手写算子、人脑优化的时代告别，无疑比这更加残酷。
不知道有没有读者有类似的感受，但我想这事儿也只能这样了。
那人们呢
在 AI 不断进步的同时，我也对一些问题表示担忧：
现在的学生是不是大概率会更倾向于使用 AI 完成作业，特别是偏向于实践的各种 Lab？想象一下，如果面前有两个选择，一个是苦哈哈地用八小时时间完成一个 Lab，或许还拿不到满分；另一个则是启动 AI 模型，用几毛钱的成本、几分钟的时间，直接让 AI 编写满分代码，那大部分学生会选择哪个呢？
上面一点会导致大量学生的工程能力严重不足，包括组织代码的能力、构建系统的能力、思考未来潜在需求并提前在设计上应对的能力、抽象的能力等等。那么在 AI 能力不断变强的背景下，这部分“工程能力”是否还是必须的呢？这些工程能力是会向旧日的“熟练编写 x86 汇编”的能力那样逐渐被时代抛弃，还是会像“理解从软件到系统再到硬件的整套计算机系统”的能力那样永远具有价值？如果是后者的话，那就危险了 —— 一个工程能力很差的人，在搭配上 AI 后，产出屎山的效率可以达到先前的数倍，进而给系统埋下各式祸患，让这个世界变得更加草台。
在未来社会中，权力（power）是不是会比技术或智商更加重要？
这些问题，或许就需要时代本身来回答了。
结语
伴随着 AI 的发展，未来的社会可能会趋向于两个极端：共产主义与赛博朋克 2077。在前者中，生产力得到极大的解放，人们的生活水平有了明显的提高（就写这些吧不然我怕过不了审）；而在后者中，少数科技公司控制着大部分资源，只有极少数人能够使用最先进的 AI 和各式科技，获得接近“机械飞升”的效果，大部分人则只能用上很孱弱的 AI。阶层跨越将越来越难实现：你得先有最强的 AI，才能跨越阶层，形成了一种死循环。
你猜猜如果 Anthropic 公司永远掌握着这个世界上最先进的 AI，未来社会是会变成共产主义还是 2077 呢？你猜？
所以，我还是相信，最前沿的智能应该以一种开放、廉价的方式，供应给所有人。我不信任 Anthropic 或者 OpenAI 能这样做，特别是不希望 Anthropic 掌握最先进的人工智能或 AGI，夸张点说其严重性不亚于让希特勒先于盟军掌握原子弹技术。这也是为什么我选择并坚持留在了 DeepSeek：我们研究强大、快速、普惠的人工智能并将其开源，或许能把世界从 2077 那端拉回来一些。
愿未来的世界一切安好。May all the beauty be blessed.
[1] “主 Attention”仅包括 head dim = 512 的 MQA attention，不包括用于选出 top-k 重要的 token 的 indexer，那部分是由其他（水平也非常强的）同事（以及他们的 AI Agent）编写的。
Show more
🎯 The Hard Part of RL Is Not Optimization — It's Constructing the Target Distribution
One decomposition reframes post-training RL: RL = Local Optimum Construction + Projection. Build a local distribution better than the current model, then project the model onto it. Zhihu contributor dung defender argues almost all the real difficulty sits in the first step — while most RL research polishes the second.
He also reports a reward-free construction of that target that, in his own experiments, improves the model even from a near-zero pass@K — beating a FlowGRPO-style baseline. The method is undisclosed and the results self-reported.
1️⃣ Two arrows: improve the distribution, then project onto it
Skip the parameters entirely and the learning process becomes two arrows:
🔹 Local improvement: from the current distribution, build a better local one — IGO-style, reweighting probability mass toward higher-utility samples.
🔹 Projection: make the neural network match that better distribution.
In this frame, policy gradient is not RL itself — just one implementation of the local improvement. PG, TRPO, PPO and GRPO all fit the same form.
2️⃣ Most RL machinery polishes the easier half
Variance reduction, baselines, advantage normalization, clipping, trust regions — nearly all of it serves the projection arrow: given a target, update stably.
But a beautifully engineered optimizer can only fit a poorly constructed target more precisely. The upstream question is the fundamental one: do we actually know what the next, better distribution should be?
3️⃣ SFT vs RL is an information gap
🔹 SFT: the dataset is the target distribution. You only project — a luxurious setting.
🔹 RL: you get samples from your own model plus a compressed scalar like 0.7, and must infer the target from that.
A scalar reward says which sample is better. It does not say what a better sample looks like — exactly the information the target distribution requires. In his reading, the whole "does RL really help LLM post-training" debate reduces to one question: can you construct the target at all? If good trajectories can't be sampled and values can't be estimated, no algorithm saves you.
4️⃣ Reward is optional — and maybe the bottleneck
Reward is merely one way to construct the target: a reallocation of probability mass. But "good" in complex generation is high-dimensional — semantics, reasoning, visual quality, consistency, style. Compressing all of that into one scalar, then hoping the gradient recovers the right direction, is a massive information bottleneck.
His closing line: RL is not fundamentally about gradients. It is about constructing a better local distribution and projecting onto it. The question worth asking is not how to compute prettier gradients, but what that better distribution actually is.
🔗 Full Reading:
🔗Author's IGO-form derivations (earlier post):
#ReinforcementLearning# #PostTraining# #LLM# #GRPO# #GenerativeModels# #AIResearch#
Show more
DeepSeek Harness Did Not Stop Updating. It Just Shipped a Breaking Rewrite.
The premise is already outdated.
DeepSeek Harness released v0.1.2-alpha.1 ( on August 27, followed by v0.1.2-alpha.2 ( on August 30.
The apparent silence came from a release-channel gap: the new code reached GitHub, but the npm package had not yet moved to the same version.
Zhihu contributor Kitt在进化 explains why. Alpha.1 was not a routine feature update. It rewrote several foundational contracts and could break much of the existing plugin ecosystem.
1️⃣ Why the update stayed on GitHub
According to the author, the amount of low-level refactoring in v0.1.2-alpha.1 exceeded that of several previous releases combined.
Publishing it immediately through npm would have pushed breaking changes to ordinary users before plugin developers had time to adapt.
Keeping it as a GitHub pre-release creates a migration window:
🔹 Core developers can test the new architecture.
🔹 Plugin authors can identify incompatibilities.
🔹 The ecosystem can stabilize before the release candidate reaches npm.
The delay therefore signals caution, not abandonment.
2️⃣ The old communication layer was removed
The legacy APIProxy interface is gone.
Plugins that called APIProxy directly or manually constructed RPC requests must now communicate through the standardized Remote gateway and Remote Controller.
This gives Harness a cleaner and more consistent communication layer. It also immediately breaks plugins built around the old API.
The subsequent alpha.2 release added unified RemoteError wrapping, suggesting that DeepSeek is still stabilizing this new gateway contract.
3️⃣ The Web client was structurally rewritten
The frontend was split into independent client modules and layered services.
That is a healthy architectural change for the core project, but the DOM structure also changed substantially.
Many community plugins had implemented UI features by targeting internal DOM selectors. They added sidebar panels, floating buttons, or controls beside the prompt box.
After the rewrite, those selectors no longer exist.
Plugins based on DOM injection may therefore require extensive retesting or a complete rewrite. The lesson is familiar: integrating with internal page structure is fast, but fragile.
4️⃣ Sessions now behave like strict event logs
Older plugins often treated the conversation session as a convenient local database. They inserted custom state by writing their own event types into the session log.
Harness now treats that log as a replayable event stream with strict semantics.
The reader follows a fail-closed policy. If it encounters an unknown event type, it refuses to restore the session rather than risk corrupting state.
This protects session integrity, but it also means that plugins with unregistered custom events can make earlier conversations unreadable after an upgrade.
Alpha.2 restored SessionEvent.ignorable, which had been removed in alpha.1. That change may ease some compatibility problems, but plugin authors still need to respect the new persistence model.
5️⃣ Models and subagents received a deeper upgrade
Harness is also moving beyond a simple single-model configuration.
Subagents can now receive their own:
🔹 Model provider
🔹 Model selection
🔹 Reasoning effort
🔹 Maximum output length
Claude Code and Codex subagents can also use configured models.
This required changes to the Models settings interface, provider authentication, and the surrounding API chain. Plugins that customize model settings are therefore among the most heavily affected.
By contrast, plugins that only add tools or provide configuration-based Agent Presets should require fewer changes.
⚠ Which plugins are most exposed?
The highest-risk categories are:
🔹 Plugins using the removed APIProxy
🔹 Web plugins that depend on DOM selectors
🔹 Plugins writing custom SessionEvent types
🔹 Extensions modifying model or provider settings
The author points to several concrete failures.
One plugin imported an internal CallId symbol. When that implementation detail changed, the plugin crashed during loading.
Other plugins inserted custom events into sessions. After upgrading, the stricter reader rejected those events and could no longer restore previous conversations.
Some UI plugins still loaded but effectively disappeared because their target DOM elements had been removed.
🔍 The broader takeaway
DeepSeek Harness remains a developer preview built around the idea that everything is a plugin.
That makes extensibility central to the product. It also means that changes to plugin contracts can affect almost every layer of the system.
The current release sequence shows a project moving quickly while its public extension boundaries are still being defined.
For plugin developers, the safest approach is to pin versions, avoid undocumented internal symbols, stop relying on page DOM structure, and migrate communication to the official Remote layer.
Harness is not slowing down. Its core is changing faster than the surrounding ecosystem can currently absorb.
🔗 Full analysis:
#DeepSeek# #DeepSeekHarness# #AIAgents# #AgentInfrastructure# #OpenSourceAI# #DeveloperTools# #PluginArchitecture#
Show more
Inside MiniMax H3: One DiT Stream for Text, Video, and Stereo Audio
Earlier this month, @MiniMax_AI open-sourced H3, a multimodal model that accepts text, images, video, and audio, then jointly generates video with native stereo sound.
The interesting part is not just the capability list. It is how H3 represents several modalities inside one diffusion transformer.
Zhihu contributor 微卷的大白 analyzed the released code and checkpoints. Since MiniMax had not published the full technical report, some low-level details should be treated as code-based interpretation rather than official specification.
1️⃣ What exactly was open-sourced?
H3 supports 4–15 seconds of video at 24 fps, together with 32 kHz stereo audio.
The released model has two main checkpoints:
🔹 FL2VA handles text-to-audio-video and generation conditioned on optional first or last frames.
🔹 Ref2VA accepts mixed references, including images, videos, and audio.
The open H3-Base path generates at 768p. The full 2K product pipeline relies on In-Context Regeneration, which was not open-sourced when the analysis was written.
The complete Contextual Omni Representation processing chain and Native Sparse Attention were also not fully available. This distinction matters when evaluating local results or inference cost.
2️⃣ Every modality enters one packed sequence
H3 uses a 50-layer Omni Transformer with a hidden size of 5,376.
Text conditions, reference media, noisy video latents, and noisy audio latents are packed into the same attention sequence. They share one set of attention projections and the same SwiGLU feed-forward network.
Only the target video and audio rows are updated during Euler denoising. Reference and conditioning rows remain context.
At the output, two separate heads predict video and audio velocities from the shared hidden states.
H3 is not generating video first and attaching sound afterward. Both modalities evolve inside the same denoising process.
3️⃣ The Token Refiner bridges understanding and generation
Before entering the DiT, representations from Qwen3-VL pass through a two-layer Token Refiner.
A simple linear projector can only transform each token independently. Self-attention allows every conditioning token to reread and reorganize the complete prompt context.
The refiner does not see noisy video or audio latents, and it does not perform denoising. Its job is to convert the understanding model’s output into conditioning that the generative backbone can use.
The author also found that short prompts often produced weak results. Rewriting them in the richer style of MiniMax’s official examples substantially improved generation quality.
4️⃣ RoPE creates a shared physical timeline
The hardest positional problem is that one attention stream must represent several different structures:
🔹 Text has sequential order.
🔹 Video has time, height, and width.
🔹 Audio has time and stereo-channel identity.
H3 solves this with three-axis positional coordinates. Video frames and audio samples are mapped onto a shared physical timeline, while the other axes encode spatial position or audio channel.
Audio latents run at 40 Hz, while video runs at 24 fps. H3 therefore advances video time by 5/3 units per source frame so audio and video can periodically align on the same coordinates.
Left and right audio channels share the same time coordinate but use different positions on another axis. This preserves synchronization while retaining channel identity.
Importantly, packed row order does not define physical time. RoPE coordinates do.
5️⃣ Modulation is huge in parameters, tiny in FLOPs
Each DiT block generates shift, scale, and gate parameters for both attention and MLP paths.
The parameters are selected according to two signals:
🔹 The diffusion timestep
🔹 Whether the row represents text, video, or audio
Across 50 layers, these AdaLN-related projections contain roughly 13 billion parameters, around 39% of the DiT.
That sounds computationally expensive, but the projections operate on a small table of unique timesteps and modalities. The resulting parameters are then gathered for each row.
For a five-second generation, this part contributes less than 0.002% of forward-pass FLOPs.
It is a striking design choice: parameter-heavy conditioning without token-proportional projection cost.
6️⃣ Long video turns attention into the bottleneck
After VAE compression and DiT patching, a five-second 768p sample still contains roughly 37,700 effective rows.
At ten seconds, that grows to about 73,400. At fifteen seconds, it exceeds 109,000.
With full attention:
✅ The sequence grows by about 2.9× from five to fifteen seconds.
✅ Compute per DiT forward grows by roughly 6.1×.
✅ Attention’s share of compute rises from 58.4% to 80.2%.
H3 uses a distilled CFG path and executes 49 DiT forwards across its sigma schedule. For a fifteen-second sample, the author estimates aggregate DiT computation at roughly 1.04 exaFLOPs.
Since Native Sparse Attention was not included in the initial open release, the public inference path analyzed here still pays the quadratic cost of full attention.
That makes sparse attention and fused kernels the clearest opportunities for infrastructure optimization.
🔍 The architectural takeaway
H3’s core idea is a shared generative space.
Text provides instructions. Reference media supplies context. Video and stereo audio are denoised together. RoPE aligns them in space and physical time, while indexed modulation tells each row how to behave.
The model’s biggest strength is therefore not simply “audio-video generation.” It is the attempt to make multiple modalities behave like one coordinated sequence.
Its biggest constraint is equally clear: as duration grows, full attention rapidly becomes the dominant cost.
🔗 Full analysis:
#MiniMaxH3# #VideoGeneration# #DiffusionTransformer# #MultimodalAI# #GenerativeAI# #AIInfra#
Show more
Will Embodied AI Be AI’s Next Breakout?
At this week’s World Humanoid Robot Games, organizers released a dataset containing more than 2,500 hours of real-world robot operation data.
It reflects a broader shift: embodied AI is moving beyond stage demos and toward data accumulated through physical interaction.
Zhihu contributor 任广杰, Assistant Vice President at @LejuRobotics_ , believes embodied AI will become AI’s next breakout field.
But it will not resemble ChatGPT’s overnight rise. The real signal will be a steady increase in the hours robots can work reliably in real environments.
1️⃣ Physical AI plays by different rules
The previous AI waves, including computer vision and NLP, operated largely in information space. When a model makes a mistake, the task can usually be retried.
Robots operate in the physical world. Changes in lighting, friction, payload, or object position can damage equipment or halt a production line.
That creates two requirements AI has rarely had to meet at scale:
🔹 Real-time, closed-loop control
🔹 Consistently high success rates in uncontrolled environments
A successful demo is not enough. The system must continue working when conditions change.
2️⃣ Three inflection points have arrived
🔹 Robot bodies are becoming reliable enough
Integrated actuators now combine motors, reducers, encoders, and drivers. This has sharply reduced joint failure rates.
At Leju, robot mean time between failures has increased from hours to thousands of hours.
Below that threshold, the economics do not work. Maintenance and downtime can erase the value of replacing human labor.
🔹 Robots now have both a “brain” and a “cerebellum”
Traditional industrial robots execute fixed instructions. A change in task usually requires new programming and teaching.
Large models give robots task-level understanding. A robot can inspect randomly placed components, then plan the order and pose for grasping them.
Meanwhile, lower-level control systems handle balance, locomotion, and physical disturbances.
The “brain” decides what to do. The “cerebellum” keeps the movement stable. The body must survive repeated execution.
🔹 The data flywheel is starting to turn
Embodied AI is beginning to follow the path of autonomous driving.
Real robots generate operational data. That data improves the models, which then return to the physical world and generate more useful experience.
This closed loop is essential because many problems only appear during deployment.
3️⃣ The real gap lies between the lab and the factory
Leju began developing humanoid robots in 2016. One of the clearest changes in the current cycle is that factories are now willing to open real production stations for testing.
Three years ago, that was much harder.
A 95% grasping success rate may look impressive in a laboratory. A factory may require 99% availability under changing lighting, reflective surfaces, deformed containers, and shifting object positions.
Customers therefore ask very practical questions:
🔹 How long can the robot operate without failure?
🔹 Can it recover from an exception by itself?
🔹 Can it keep pace with the production line?
Answering them requires the body, controller, model, data loop, and deployment engineering to work as one system.
4️⃣ The first commercial wave is already taking shape
The earliest deployments appear in structured environments with clear task boundaries and measurable value.
Leju’s full-size Kuavo 5 robots are already used for reception and guided tours in exhibition halls, banks, and stores, as well as for park inspection. The company says these projects now cover 23 Chinese provinces and hundreds of customer cases.
In manufacturing, Leju explored more than 70 factories and hundreds of potential tasks over the past year. Dozens passed proof-of-concept acceptance.
Its wheeled Kuavo 5-W has entered small-batch deployment for tasks such as loading small automotive components and depalletizing cartons.
The important change is that some customers are beginning to pay for repeatable workflows, not merely demonstration projects.
5️⃣ Home robotics remains the endgame
Homes may eventually become the largest market, but they are also the hardest environment.
They are highly unstructured. Task boundaries are almost unlimited, and consumers are extremely sensitive to cost.
Two conditions must be met:
✅ Embodied models must generalize well enough for real household use.
✅ The total cost of the robot must fall below the cost of human labor.
Until both happen, industrial and commercial settings will remain the more realistic path to scale.
6️⃣ Watch effective working hours, not flashy demos
The best measure of an embodied AI system is how long it can create value without human intervention.
Three questions matter:
🔹 Can it do the job?
This depends on whether the task can be decomposed and whether the environment is sufficiently structured.
🔹 Can it do the job reliably?
The key metrics are continuous operating time and autonomous recovery from failures.
🔹 Is it economically worthwhile?
The customer must be able to calculate the full lifecycle cost. Once the economics become clear, repeat purchases can begin.
Embodied AI is already moving from exhibition piece to production tool.
Its breakout will not be defined by one viral robot. It will be defined by thousands of machines quietly accumulating useful working hours in factories, stores, and eventually homes.
🔗 Full analysis:
#EmbodiedAI# #HumanoidRobots# #Robotics# #PhysicalAI# #ArtificialIntelligence# #ChinaTech#
Show more
🔥 @TencentHunyuan Hy4 preview just cited a Zhihu post with a surprisingly simple challenge to DeepSeek’s mHC:
What if the doubly stochastic matrix is overcomplicating things—and Identity actually works better?
Today, let’s revisit the cited post, “Your DeepSeek mHC May Not Need the ‘m’,” by Zhihu contributor 涮月亮的谪仙人.
After training Qwen3 1.7B and 8B dense models from scratch on 150B tokens, the experiments found:
💡 Identity HC > mHC > mHC-lite > orthogonal mHC
In other words: simply setting H_res = Identity beat the Sinkhorn-Knopp constrained version.
Here’s why 👇
1️⃣ What does mHC actually change?
Standard Transformers have one residual stream. Hyper-Connections (HC) expand it to multiple parallel streams:
🔹 H_pre reads from the streams
🔹 H_post writes back to them
🔹 H_res mixes information between them
DeepSeek’s mHC constrains H_res to a doubly stochastic matrix via Sinkhorn-Knopp, helping preserve norms and stabilize propagation.
But the experiments suggest a simpler question:
Do we need H_res mixing at all?
2️⃣ mHC seems to learn something close to Identity anyway
For a single layer, the learned H_res is already close to Identity:
diagonal ≈ 0.96, off-diagonal ≈ 0.01
But multiply H_res across many layers, and it gradually collapses toward a uniform 0.25 matrix.
So each layer may look almost like Identity, while their cumulative effect becomes uniform mixing.
The simplest fix?
Just set H_res = I.
3️⃣ Identity preserves stream semantics
With Identity, each residual stream stays where it is:
Stream 0 stays Stream 0. Stream 1 stays Stream 1.
No repeated reshuffling, no cumulative mixing, and Iᴸ = I.
H_pre and H_post also no longer need to track where each stream has been repeatedly moved—they simply learn where to read and where to write.
4️⃣ But cross-stream communication still happens
Setting H_res = I does not isolate the streams.
The projection that generates H_pre and H_post already sees all residual streams, making H_pre input-dependent.
So information can still be dynamically aggregated across streams before Attention/MLP and written back afterward.
H_res isn’t the only mechanism for cross-stream interaction.
5️⃣ Why might Sinkhorn hurt?
Repeated products of positive doubly stochastic matrices tend toward uniform mixing.
In the Qwen3-1.7B experiment, after 56 HC modules, the minimum singular value of the accumulated H_res product reached just:
9.2 × 10⁻¹⁸
By ~10 layers, the four streams were already approaching the same 0.25 uniform mixture.
Sinkhorn also comes with extra cost: 20 iterations, backward recomputation, extra parameters, and approximation error.
Identity has none of these—and preserves the residual signal exactly.
6️⃣ More sophisticated alternatives didn’t win either
The experiments also tested mHC-lite, softmax-weighted convex combinations, and orthogonal variants using Cayley/Givens transforms.
The observed ranking remained:
Identity HC > mHC > mHC-lite > orthogonal mHC
The simplest design won.
💡 The takeaway
DeepSeek’s mHC uses sophisticated manifold constraints to stabilize Hyper-Connections.
But these experiments suggest that H_res itself may not need to be learned or mixed at all.
Sometimes the best manifold constraint is the most boring one:
H_res = I.
Or, as the original post puts it:
Maybe DeepSeek’s mHC doesn’t need the “m.” 😆
👉 Read the full Zhihu post for the training curves, mathematical analysis, H_res visualizations, and implementation details:
#DeepSeek# #mHC# #Hunyuan# #Tencent# #LLM# #Transformer# #AIResearch# #AI#
Show more
🦾 Why Data, Not Models, Is the Real Moat in Embodied AI
The timing of this question is hard to miss.
This week, the World Humanoid Robot Games released a 2,500+ hour dataset covering 12 scenario categories, 44 operations, and more than 10,000 tasks. Crucially, it also includes failures and edge cases.
But raw hours tell only part of the story.
Zhihu contributor 于超, an assistant professor at Tsinghua Shenzhen International Graduate School, shares his team’s view on why data has become embodied AI’s hardest-to-replicate advantage.
1️⃣ Robot scaling is fundamentally asymmetric
Like language models, robot policies appear to benefit from more data, larger models, and greater compute.
But these three inputs do not scale equally.
Model architectures can be studied and reproduced quickly. General-purpose compute can, in principle, be purchased.
High-quality robot data is different. It must be accumulated through physical interaction, and competitors cannot recreate it overnight.
That asymmetry is what turns data into a moat.
2️⃣ Robot data must be manufactured
LLMs inherited decades of internet data. Robots did not.
Every useful trajectory must be produced through physical interaction. Even a simple cup-grasping task changes with the object, lighting, environment, camera angle, and robot body.
So raw hours are not enough. What matters is the diversity of embodiments, tasks, objects, failures, and recoveries.
Open X-Embodiment needed more than 20 institutions and 22 robot platforms to collect over one million trajectories. DROID used 50 collectors for a year, producing only 350 hours of data.
New methods such as UMI and egocentric recording make collection easier. But every hour still requires real people, equipment, and time.
3️⃣ A successful trajectory can still be bad data
Robot data quality is more complicated than whether a task was completed.
On the hardware side, camera accuracy, encoder readings, force sensors, calibration, communication latency, and synchronization across modalities can all corrupt a trajectory.
The human operator adds another source of noise.
Teleoperating a robot is not the same as performing the action directly. Operators hesitate, pause, readjust, and develop habits for compensating for the control system.
A task may succeed even when parts of the demonstration should never be imitated.
Success is therefore only the coarsest possible label. One trajectory can contain both excellent behavior and inefficient or misleading actions.
Training on the entire trajectory without distinction effectively tells the robot to learn both.
4️⃣ The next challenge is information density
Collecting more trajectories is only half the problem. Teams must also identify which parts are worth learning from.
Yu Chao’s team developed STEAM to detect local progress within a trajectory without frame-by-frame annotation or manually designed rewards.
It separates useful progress from hesitation, failure, and recovery.
The key question is shifting from “How many trajectories do we have?” to “How much useful information does each trajectory contain?”
5️⃣ Embodied data is physically expensive
Text can be copied. Videos can be downloaded.
Robot data requires a physical production process.
Collecting one hour may involve a robot, sensors, teleoperation equipment, an operator, a suitable environment, task materials, and engineers who maintain and calibrate the system.
Real factories, stores, and homes add even more complexity.
And pressing the record button is only the beginning. Transmission, cleaning, governance, and storage can cost more than collection itself.
The author offers a rough calculation.
If a company wants one million hours of real-world data and reduces the combined collection and management cost to RMB 200 per hour, the total still reaches RMB 200 million.
🔑 The real moat compounds over time
Quantity, quality, and cost explain why embodied AI data cannot be replicated through a short burst of spending.
Large, diverse, high-quality datasets require physical infrastructure, operational discipline, and years of accumulation.
As robot policies continue to benefit from scaling, the durable advantage will belong to teams that can repeatedly:
🔹 Collect broader real-world experience
🔹 Identify the most informative behavior
🔹 Preserve failures and recovery signals
🔹 Turn noisy trajectories into useful learning data
In embodied AI, having data and knowing how to use it are becoming two very different capabilities.
And the second may ultimately matter even more than the first.
🔗 Full analysis:
#EmbodiedAI# #Robotics# #PhysicalAI# #RobotLearning# #AIData# #ScalingLaw# #Tsinghua#
Show more
🧩 DeepSeek and OpenAI Open-Sourced Their Harnesses. The Runtime May Become the Next AI Platform
DeepSeek Harness and OpenAI's Codex harness are now open source. But the larger story is not simply that two more repositories became public.
Zhihu contributor 第欧根尼 argues that Agent products are beginning to unbundle. The future may be less about choosing one monolithic Agent app and more about assembling a runtime, model router, scenario-specific distribution, and trusted plugin stack.
1️⃣ A harness is becoming part of the model
The author's first hypothesis is that a harness will no longer be just a frontend that exposes model capabilities.
It will become a framework that co-evolves with the model.
The same model may perform very differently inside its official harness than inside a third-party implementation. Context management, tool descriptions, task decomposition, verification, and retry policies all influence the model's behavior.
This leads to an important conclusion:
A model and its Agent loop can produce better results together than the model can deliver on its own.
The competitive unit is therefore shifting from the model alone to the model-harness system.
2️⃣ Agents are becoming lighter and more distributed
The author's second observation comes from the evolution of MCP, Cloudflare's Agent infrastructure, and the growing demand for programmable workflows.
He expects Agents to become:
🔹 Smaller and more specialized
🔹 Easier to customize through code
🔹 More independent from monolithic apps
🔹 Numerous enough to run as lightweight background workers
Current products such as Kimi Work or WorkBuddy still control much of their unique behavior internally. Users cannot easily modify them or embed their complete workflows inside an enterprise system.
But market demand is moving toward more flexible forms: plugins lighter than standalone apps, Code Mode more powerful than static skills, and large numbers of low-overhead Agents running simultaneously.
That helps explain why vendors are opening their harnesses now.
3️⃣ The harness becomes a microkernel
DeepSeek Harness treats the harness as something closer to a microkernel plus a distribution.
The base runtime becomes thinner. It retains only the functions every Agent needs:
🔹 Plugin loading and lifecycle management
🔹 Event routing
🔹 Permissions and state
🔹 Execution protocols
🔹 Session and context infrastructure
Research, coding, office work, and customer service are then assembled through different plugin bundles.
The author sees OpenAI's Codex harness moving in a broadly similar direction, even if it uses different terminology.
In this model, users may stop choosing a single Agent product. Instead, they choose:
runtime + model routing + scenario distribution + organization plugins
DeepSeek Harness and Codex become open runtimes on which many different Agent products can be built.
4️⃣ Five changes follow from this architecture
🔹 Plugin count stops being meaningful
Prompts, skills, MCP services, and harness plugins can multiply quickly. The difficult problem will not be finding more plugins, but deciding which ones are trustworthy.
Security review, provenance, compatibility, maintenance, and permission control become the real barriers.
🔹 Models become replaceable execution resources
If context and data remain inside the harness, the runtime can route different tasks to different models.
A strong model may handle planning and review, while cheaper models perform repetitive execution. Switching models becomes a runtime decision rather than a full migration.
🔹 The Agent Loop becomes the main optimization target
As model capabilities converge, user experience may depend more on the surrounding loop:
When should context be compressed? When should a task be split? What should be remembered? How should results be verified?
Improving these decisions may create more value than replacing the underlying model. Models trained to cooperate with a particular harness could gain a significant advantage.
🔹 Skills, MCP, and plugins form a compatibility layer
The market is unlikely to accept a different extension format for every platform forever.
Competition will shift from “does this platform support plugins?” to “how many ecosystems can it support without degrading the experience?”
🔹 Personal runtimes separate from enterprise control planes
Individuals need flexible local Agents. Enterprises need governance, private marketplaces, permission policies, observability, and integration management.
These will become distinct product layers, even when they share the same open runtime.
5️⃣ Existing Agent products will defend through ecosystems
The author expects products such as WorkBuddy to expose compatibility layers without fully opening their core runtime.
They may quickly announce support for DeepSeek Harness plugins, Agent Skills, and more MCP services. But these capabilities would likely enter through adapters rather than replace the underlying harness.
They may also build private enterprise plugin marketplaces. The more open the ecosystem becomes, the more companies need vendors that can absorb integration and security risks.
Distribution remains another moat.
WorkBuddy can connect deeply with WeChat, WeCom, and Tencent Docs. An open harness may reproduce its plugins, but it cannot quickly reproduce users' work relationships and established business entry points.
Alibaba has a different advantage. The author expects it to use Alibaba Cloud and Bailian to provide a managed harness control plane, turning cloud infrastructure into the runtime layer for enterprise Agents.
6️⃣ This looks like the Android/AOSP moment for Agents
The current market resembles the early Android ecosystem.
An open foundation can stop hundreds of teams from rebuilding the same runtime. But publishing reference code is not enough to create an Android-scale platform.
The next six months may decide whether these projects converge into a durable ecosystem.
They need stable interfaces, trusted plugin infrastructure, and vertical software teams willing to maintain real products on top of the open runtimes.
The decisive question is not whether DeepSeek or OpenAI has released the better harness today.
It is whether the industry can turn open harnesses into a shared Agent platform, rather than another collection of incompatible reference implementations.
🔗 Full analysis:
#DeepSeekHarness# #OpenAI# #Codex# #AIAgents# #AgentInfrastructure# #MCP# #OpenSourceAI#
Show more
⚙ How GLM-5.3-Flash Served 70 Trillion Free Tokens on Chinese Chips
GLM-5.3-Flash's anonymous "Ox Alpha" trial burned through roughly 70 trillion tokens in a week — and Zhipu says all of it ran on Chinese AI chip clusters. For many observers, that is a bigger story than the model itself.
Zhihu contributor 恋猫 breaks down the systems engineering that made it work. His framing: the model architecture first reduces how much data needs to move, then the inference system compresses what remains.
The reported scale is around 100,000 Chinese chips — from Huawei, Moore Threads and Hygon, according to @latepostnews — though @Zai_org itself has only said "tens of thousands."
1️⃣ The architecture cuts data movement first
Versus GLM-5.3, Flash lowers attention compute by 3.01x and KV cache by 4.44x. Less data shuttling between memory and compute is the foundation everything else builds on.
2️⃣ Compute-for-bandwidth: trading FLOPs for HBM relief
The bottleneck on these chips is HBM: the compute units still have headroom while memory bandwidth is nearly saturated.
The fix, loosely speaking, turns "every step: read the full state, write the full state" into "read the state, recompute a little, write back periodically." A bit of extra matrix math buys a large reduction in HBM write traffic.
3️⃣ Communication-for-bandwidth: shard the cache across cards
The cluster also uses high-speed inter-chip links and aggregated bandwidth to cut how much data each card must keep resident.
The author's example: rank 0 holds the KV and indexer cache for some layers, rank 1 holds the rest. No card stores every layer's cache long-term; data is prefetched over the interconnect as each layer executes.
The trade-off is real — more communication, far less resident cache per card.
4️⃣ EPD separation: three pools, scaled independently
Finally, Encode, Prefill and Decode are split into three independently scalable resource pools, which matters most for multimodal traffic. Together, these pieces are what let the cluster run at high utilization.
5️⃣ The result: 3x end-to-end, cost "comparable to NVIDIA"
Zhipu's own claim: end-to-end serving performance improved 3x on the same hardware, bringing per-token cost close to mainstream NVIDIA GPUs.
The author's reading: individual Chinese cards may still be weaker, but model-system co-design lets the cluster as a whole reach international-mainstream throughput and cost.
He adds a wry footnote: Zhipu's API used to be notorious among Chinese developers for 429 rate-limit errors. That it could absorb this launch's traffic at all — entirely on Chinese silicon — is, in his words, proof that optimization never ends.
🔗 Full Reading:
#GLM# #Zhipu# #AIChips# #AIInfra# #LLM# #Inference# #OpenWeights#
Show more
