This is the third and final part of the recap of NICE’s event “Looped Language Model: Rethinking Model Depth and Parameters,” covering the second half of the panel discussion. The panel was hosted by Wenyue Hua, with Chunyuan Deng and Benhao Huang as panelists.

The second half ranged more widely: Is looping along depth the same thing as looping along time (that is, CoT)? Do expressiveness proofs still mean anything? How should loops be combined with MoE? And finally, a set of questions about “how to use loops at inference”: extrapolation, adaptive computation (ACT) and parallel decoding.

Key takeaways

• Looping along depth and looping along time look much alike from the standpoint of computational depth. Chunyuan thinks that in both cases “you have to take that many sequential steps in total; the only difference is how you take them.” One difference he sees lies in the data: explicit CoT can be synthesized, whereas it is unclear how to construct supervision for latent CoT.
• The difference between loops and soft tokens lies in how the KV cache is used. Over the lifetime of a single token, looping twice and generating one extra soft token reach similar depths. Letting the previous token’s deep-layer state flow back into the next token’s shallow layers is exactly the starting point of the Full-Bandwidth Transformer.
• RL brings a new opportunity, and an underlying concern. Looping itself does not get in the way of RL; the opportunity lies in assigning credit to the intermediate loops. The concern is that looping may itself already be doing something similar to RL, so the gains from RL may shrink.
• Expressiveness proofs are not pointless. Inductive bias determines how quickly a model learns. Chunyuan’s conclusion is that “It’s all about the computational depth,” and that learnability matters more at present.
• Loop × MoE: different loops should choose different experts. Several works find that looping twice is the sweet spot, though Benhao would like people to “loop at least three times.”
• Extrapolation is hard for natural language, and ACT looks reasonable but is hard to make work. Both aim to change the number of loops at inference: extrapolation loops more times than in training, while ACT lets each token decide for itself how many times to loop. Both run into a mismatch between training and inference, and ACT also faces infrastructure difficulties. Benhao believes a more realistic direction for speedups is to keep the number of loops unchanged and instead, borrowing from Diffusion Forcing, stagger the different loops of different tokens and decode them in parallel.

Glossary

The table below explains several terms that recur in this article. Readers familiar with them can skip it.

Panelists

Chunyuan Deng: PhD student at Rice University, advised by Prof. Hanjie Chen. His research focuses on the design and optimization of LLM pretraining architectures, as well as the interpretability of language models. His representative work is LT2: Linear-Time Looped Transformers [1]; his talk at the event is covered in part one of this series.

Benhao Huang: Master’s student at CMU, advised by Prof. Zico Kolter. He works mainly on looped LMs and fixed points, with the aim of improving the reasoning ability and efficiency of foundation models. His representative work includes Equilibrium Reasoners [2] and the blog series Towards Looped Models Done Right [3].

Wenyue Hua (host): Member of Technical Staff at Microsoft AI (MAI). PhD from Rutgers University, advised by Prof. Yongfeng Zhang, followed by a postdoc at UCSB. Research focuses on LLM reasoning and LLM-based agents, with many papers at top NLP and machine learning venues, including ACL, EMNLP, ICLR, NeurIPS and TACL. Serves as an Area Chair for ACL.

1. Is looping along depth the same as looping along time?

The host, Wenyue Hua, wanted to hear the two panelists’ thoughts: Why has there been such a surge of papers on looping recently (though it could also be a coincidence)? Are looping along depth and looping along time essentially the same thing? How does this kind of implicit reasoning relate to explicit CoT? And does it affect credit assignment in RL?

Chunyuan: it depends on how you define “essentially”

Chunyuan said it depends on how we define “essentially.” One could first ask: are RNNs and Transformers essentially the same thing? A Transformer can also be trained step by step like an RNN, instead of in parallel with teacher forcing. Architecturally, what matters most is the operations: an architecture is, in the end, a collection of operators. If “essentially” refers to computational depth from the perspective of expressiveness, then he personally thinks the two are indeed fairly similar: in total, you have to take that many sequential steps, and the only difference is how you take them.

As for whether explicit CoT is needed, he sees one difference between explicit CoT and latent CoT in the training data: the former can be written by hand, or synthesized by people or models; for the latter, he cannot yet think of a workable way to synthesize the data or construct the supervision.

For today’s looped architectures, if you only do SFT or pretraining, there is no major conflict between looping and CoT: the model simply uses greater depth to learn CoT, rather than doing away with it. In RL, however, greater depth (or an architecture like the Full-Bandwidth Transformer) may indeed have an effect. RL requires sampling; in agentic settings, the model needs many intermediate variables for state tracking, and it has to rely on either CoT or depth for that. With greater depth, the CoT may become shorter, and RL itself also demands token efficiency. Likewise, with latent reasoning methods such as Coconut [4], the CoT may also get shorter. He thinks these two things really do lead to differences in RL.

Note: Coconut (Chain of Continuous Thought) feeds the model’s last-layer hidden state directly back in as the input embedding for the next step, without decoding it into text, so that reasoning takes place in a continuous latent space.

2. Loop vs. Coconut, seen through the lifetime of a token

Similar depth; the difference is in how the KV cache is used

Suppose you draw out the topology, follow the concrete lifetime of a single token and write out a loop and a Coconut-style soft token side by side: for example, a model that loops twice, versus an L-layer model that does not loop but generates one extra soft token. The two look very similar in depth. The difference lies in the details: how the KV cache is used.

When looping, it helps if the previous token’s final hidden state can be injected into the shallow layers of the next token; this is precisely the motivation for the Full-Bandwidth Transformer [5]. In an ordinary loop, because training uses teacher forcing, the deep-layer information has not yet been formed when the later token’s shallow layers are computed, so naturally it is unavailable. Soft tokens are similar: whether the previous token is a soft token or an ordinary explicit token changes which of its layers’ KVs the later tokens can see.

Note: The Full-Bandwidth Transformer takes the top-layer hidden state at the previous position, fuses it through a gating unit with the embedding of the currently sampled token, and uses the result as the bottom-layer input at the next position; the rest of the architecture, the KV cache and the training objective are the same as in a standard model. Because this dependency cannot be parallelized directly, training uses multiple forward passes: each additional pass shifts the previous pass’s hidden states one position to the right and runs the whole network again, and this feedback is added only late in training (for example, only a single pass is run for roughly the first 75% of training). In experiments at the 1B scale with up to 400B tokens, the paper reports that it can match or approach a standard model trained on about 1.5× as many tokens; by the paper’s estimate, the added compute per token at decoding time is under 1%, and the model runs about 2.3% slower when measured in vLLM.

What makes RNNs special

Benhao raised a point he found very interesting. Picking up on Chunyuan’s mention of RNNs and Transformers a moment earlier, he noted that within frameworks that measure model capability, such as complexity classes and circuit complexity, RNNs have something special about them, for example state tracking. Soft tokens can “inject” this ability back into Transformer-style architectures; looping alone, without any other mechanism, may not be able to do so.

Note: Fixed-depth Transformers and many state-space models fall into the complexity class TC⁰, so they are generally believed to be unable to solve NC¹-complete state-tracking problems such as composing permutations [6]; each additional step of CoT or soft tokens, by contrast, amounts to letting the model perform one more step of sequential computation.

3. What looping means for RL

The extra cost is mainly in prefill

Benhao mentioned that designs like the Full-Bandwidth Transformer, which send deep-layer states back to shallow layers, may carry some extra cost when used for RL: getting the deep-layer hidden states requires additional iterations or forward passes. In settings with a lot of prefill (the stage in which the model reads in the entire input at once and builds the KV cache), such as agentic tasks, this could become a problem, and RL training would also cost somewhat more.

A new opportunity: assigning credit to intermediate loops

As for credit assignment, Benhao’s view is that, looking at looping alone, nothing stands in the way of RL: you do RL on a looped Transformer the same way you do on a Transformer, with no difference. But if you want to assign credit to the intermediate steps of the loop (for example, when looping four times, giving some credit to the 1st, 2nd and 3rd loops as well), then it is worth thinking about whether there are interesting ways to do so. For instance, during RL, could some of the intermediate loops take on tasks such as tool calling?

An underlying concern: looping may already be doing something like RL

Beyond that, he also has a worry he is not entirely sure about: when RL is done on top of a looped model, will the gains be as large as before? A looped model may itself already be doing something similar to RL.

The host followed up: what does it mean that “looping itself is doing RL”? Benhao explained:

RL is a kind of distribution sharpening: it makes the distribution sharper, a bit like mode seeking. Looping, on the other hand, can be seen as a kind of power iteration: it keeps the more stable modes, like keeping the directions corresponding to the largest and second-largest eigenvalues.

Note: Power iteration is a classic method for finding a matrix’s dominant eigenvector: repeatedly multiply a vector by the matrix and normalize it, and the components along other directions gradually decay, leaving the direction corresponding to the largest eigenvalue. Benhao’s analogy is that both make the model contract toward a few dominant modes, so the two may overlap.

4. Do expressiveness proofs still mean anything?

On the looping side, there is work such as the Universal Transformer (UT) [8], which seemingly can approximate any function; other papers say that with unbounded CoT or infinite numerical precision, Transformers come close to being Turing complete. Many architectures can be proven to be fairly general once certain conditions are relaxed. So do expressiveness proofs have little to do with how architectures are designed?

Note: The Universal Transformer paper shows that, given enough memory and a number of recurrent steps that grows with input length, it is computationally universal. Pérez et al. proved that Transformers are Turing complete under the assumption that weights and activations can take arbitrary precision, but not with fixed precision [9]. Merrill and Sabharwal proved that with a linear number of CoT steps, Transformers can recognize all regular languages, and with a polynomial number of steps they recognize exactly the class P [10], that is, the decision problems an ordinary algorithm can solve in polynomial time.

Benhao: inductive bias determines how fast a model learns

Benhao said some architectures have their own inductive biases and learn certain tasks faster. For example, a looped model can learn Sudoku very quickly, while a Transformer of the same depth has a somewhat harder time, because it lacks a suitable inductive bias. Beyond that, though, if depth is not limited, and instead of training you could know, like a god, exactly which weights to use and set them directly, then the solution certainly exists within the Transformer’s function class.

Chunyuan: It’s all about the computational depth

Chunyuan went on to say that there is actually a lot of discussion about expressiveness in the linear attention community. For example, the Transformer belongs to TC⁰, while GDN (Gated DeltaNet, a kind of linear attention) is an NC¹ structure. He has read a dozen or so papers discussing such questions, including the Universal Transformer, “but UT needs ACT to have that property.” After reading so many, his final conclusion is:

It’s all about the computational depth.

You can do it in depth, or you can use a lot of CoT; essentially, there really is not much of a difference.

Note: Fixed-depth, log-precision Transformers can be simulated by TC⁰ circuit families [11]. On linear RNNs, research has proven that when the eigenvalues of the transition matrices are allowed to be negative (lying in [−1, 1]), linear RNNs whose transition matrices are products of “identity minus outer product” matrices, including models such as DeltaNet, can recognize any regular language [12] (the eigenvalues of standard GDN are all positive, so strictly speaking this relaxation is needed); and some regular languages (such as the word problem for the symmetric group S5) are NC¹-complete. As for UT and ACT, strictly speaking, the universality proof in the UT paper requires the number of recurrent steps to grow with input length, and ACT is one way to make the number of steps vary with the input.

In Chunyuan’s view, architecture design basically comes down to two lines of thinking: either improve expressiveness, so that the architecture can express more and has a stronger function class; or improve learnability, so that the model can learn that function class more easily. He thinks that, for now, learnability may matter more; expressiveness is discussed more by people on the linear attention side.

5. Loops and MoE: should different loops choose the same experts?

The host noted that MoE is now a fairly mainstream architecture, but as far as she knows, there is still little work on looping in MoE models. Benhao’s blog [3] converted both Ouro-style [13] and Huginn-style [14] architectures to MoE for comparison, and ByteDance Seed and other institutions recently released a paper, SMELT [15]. Her questions: MoE adds parameters, while looping adds FLOPs; MoE also brings issues such as dynamic top-k routing (different loops may select different experts) and communication costs. When loops are added to MoE models, the number of loops seems to be small; SMELT appears to loop only twice (R = 2). Does looping many times not work well with MoE? Or do looped LMs simply not need many loops? Also, could communication costs and the KV cache become a bigger burden with MoE?

Note: SMELT is a collaboration among Tsinghua University, ByteDance Seed, M-A-P and TokenWave.AI. It loops the middle half of the layers twice, and by making the model narrower and adding experts, it matches the baseline in per-token FLOPs, non-embedding parameter count and KV cache. The paper reports that at scales of up to 54B non-embedding parameters (1.6B active), it saves 6.8%–18.0% of training FLOPs along the compute-optimal frontier.

Benhao: the cost must be paid, and the router may favor a few experts

Benhao stressed that he has not run related experiments, so what follows is only a hypothesis: the logic is the same as with KV sharing. The hidden states of different loops are already very similar, and they sit at the same position, which reinforces the similarity, so the router may end up with a few experts that are always especially active. This is also why many works tell us that the redundancy between different loops of a looped model is still large, which is what makes KV sharing, quantization, KV eviction (discarding some of the KVs) and even router reuse possible.

He thinks a router that always picks exactly the same experts would be a problem; if there are a few very active experts while several others vary across loops, that is still acceptable. Perhaps some special designs could be built around this property.

Note: Benhao’s blog [3] has a related result: in the MoE setting, forcing later loops to reuse the experts selected by the first loop lowered accuracy on all six test tasks.

Chunyuan: different loops should choose different experts

Chunyuan largely agreed. He said looping has only two properties: depth and weight sharing. Without extrapolation, and when comparing against a model of the same depth, only weight sharing remains, and every question can be approached from there. For example, in a 12-layer MoE model, let layers 3 and 7 share the router weights W. The router’s logits are the input representation x multiplied by W; when W is the same, which experts each layer selects depends only on its own x. So if the two layers select the same experts, that shows their representations look similar to the router; it is not caused by the shared weights.

How many loops are right?

The host then asked: are there any current looped LMs that loop fairly deeply? The depth of looping should have nothing to do with whether MoE is used.

Benhao said that looping twice is quite a good sweet spot, as seen in Loopie [16] as well as SMELT, mentioned earlier.

Note: Loopie (Loop the Loopies!) follows the Qwen3-MoE architecture and pretrains two models from scratch, Loopie-20B-A2B and Loopie-6B-A0.6B; it uses “intra-layer looping,” in which each layer is executed twice before moving on to the next. Comparing 2, 3 and 4 loops, the paper finds that the marginal benefit of looping is largest at R = 2, while cautioning that this does not mean more loops are ineffective in themselves. SMELT likewise finds 2 loops to be best in ablations at the 200M scale; the paper’s explanation is that, to match FLOPs, the more loops there are, the narrower the model has to be.

6. Extrapolation: feasible on toy tasks, hard for natural language

The host asked two things: first, why is extrapolation unlikely? Second, is extrapolation, that is, looping more times at inference than in training, even necessary? Especially now that the number of loops is generally small, basically two or three, how should we think about extrapolation?

Benhao: it depends on the task

Benhao thinks the answer depends on what the task is; it is highly dependent on the data and the task. Fairly toy problems such as Sudoku, mazes or, somewhat more generally, 3-SAT are actually very well suited to looping, and training a looped model on them can yield the ability to extrapolate.

Note: Benhao’s Equilibrium Reasoners [2] is one such example: the paper reports that on Sudoku, unrolling the model to a depth equivalent to 40,000 layers raises accuracy from 2.6% for a feed-forward model to over 99%.

But if the task becomes natural language, and a very general task at that, with essentially the same distribution as current pretraining data, it becomes very hard, because this is fundamentally a problem of mismatch between training and inference. Toy tasks can reduce this mismatch because in tasks like Sudoku, even intermediate reasoning states are valid inputs: the same set of rules is applied repeatedly to a state, and the rules themselves do not change. Real language settings are not that simple, and the mismatch between training and inference will be severe.

So he thinks that training with only 8 steps and running 16 steps at inference is very hard. Staying stable may already be a good outcome; more often, performance degrades. And as discussed earlier, if the model has not learned a fixed point, using more steps may not work particularly well, all the more so beyond the training distribution.

Chunyuan: it may also be a data problem

Chunyuan said that extrapolation is not only an algorithmic problem; it may also be a data problem: algorithms alone cannot make extrapolation stable, and what helps is finding a recipe that works in certain settings.

7. ACT: reasonable on paper, hard in practice

The host asked: is ACT feasible from an engineering standpoint?

Chunyuan: the infrastructure is too hard, and the gains are unproven

Chunyuan said he has no idea at all how to build the infrastructure. He had previously tried something similar to Mixture-of-Depths [18] himself, that is, MoE along depth. If you route along depth, the first token might want to go through layers 1, 3 and 7, and the second token through layers 1, 4 and 6, and then the problems start: how do you batch? How do you train? He has no idea how such an ML system should be built.

Editor’s note: ACT was proposed by Graves in 2016, originally for RNNs: at each step the model additionally outputs a halting probability, and computation stops once the cumulative probability exceeds a threshold. Mixture-of-Depths uses a router to score each token and lets only the top-scoring fraction of tokens (for example, 12.5%) pass through a layer’s attention and MLP, while the remaining tokens skip it via the residual connection; because the number of tokens each layer processes is fixed in advance, the computation graph remains static.

Suppose a fairly good scenario: ACT works, and people first discover that letting each token take a different number of steps brings very large gains; that would in turn push the ML systems community to come up with better solutions. But he has not seen any recent evidence that token-level ACT brings much benefit; it may instead bring more instability, and training at different depths is also hard.

Benhao: it looks reasonable, but is not worth pursuing further

Benhao agreed with Chunyuan. He sees ACT as a path that seems to make a lot of sense but in practice may not be worth pursuing further; some people have spent a long time on it and found that it still does not really work. One reason is the ML-system problem Chunyuan mentioned; a more fundamental reason, in his view, is that the number of loops is small to begin with: with so few loops, how much room is there for adaptivity?

Moreover, from the perspective of fixed points, the hidden states produced by very shallow loops are still quite unstable, so ACT would aggravate the mismatch between training and inference. The results he has seen are basically all performance drops in exchange for a tiny bit of inference speedup, so he does not think ACT suits the language setting well. However, in the HRM [19] and TRM [20] line of work, which was very popular a while back, ACT is very well motivated, and he sees no problem with those approaches.

Note: HRM (Hierarchical Reasoning Model) has only 27M parameters and achieved strong results on Sudoku-Extreme, Maze-Hard and ARC-AGI with about 1,000 training examples; it implements ACT with a “halt / continue” head trained by Q-learning. TRM recursively applies just a single 2-layer network of about 7M parameters and further simplifies ACT to a single halting head that judges whether the current answer is correct, removing the extra forward pass previously required. On such puzzles, difficulty varies greatly from one puzzle to another, and intermediate states are themselves valid inputs, which may be one reason ACT is well motivated here but hard to make work in language modeling.

8. More realistic speedups: parallel and speculative decoding

Benhao said that, as for the best engineering solution, speculative decoding and parallel generation for looped LMs are a very interesting direction.

Diffusion Forcing [21] from video generation, and the techniques commonly used for real-time game generation in world models, can all be used in looped models. The reason is precisely weight sharing: in diffusion, the same model is fed different diffusion time steps; in looping, the same model is applied repeatedly across different loops. The two are structurally very similar, so a similar kind of parallelism is possible. Rather than doing adaptive looping, it is better to put the effort here, where the speedup will be large.

Note: Diffusion Forcing trains a diffusion model to denoise a set of tokens that each carry an independent noise level, so that, like a causal model, it can start generating later tokens before earlier ones are fully denoised.

He also recommended a paper by the authors of Huginn [14]: Efficient Parallel Samplers for Recurrent-Depth Models [22].

Note: The paper has been accepted at ICML 2026. It proposes a diffusion-forcing-style sampler: every forward pass decodes at least one new token from the intermediate hidden states, while several earlier tokens continue to be refined in parallel within the loop, forming a “wavefront” that moves forward (new tokens have just started looping while older ones have already looped many rounds; within one forward pass, the tokens are at different rounds, like a diagonal line advancing step by step). Total compute stays the same, and the speedup comes from making fuller use of the GPU; on the 3.5B Huginn model, the paper reports speedups of up to about 5× on tasks such as GSM8K, MATH500, HumanEval and MBPP, with very little change in accuracy.

References

[1] LT2: Linear-Time Looped Transformers. arXiv:2605.20670, 2026.

[2] Equilibrium Reasoners: Learning Attractors Enables Scalable Reasoning. arXiv:2605.21488, 2026.

[3] Towards Looped Models Done Right. Blog series, 2026.

[4] Training Large Language Models to Reason in a Continuous Latent Space (Coconut). arXiv:2412.06769, 2024.

[5] Full-bandwidth transformer. arXiv:2608.08888, 2026.

[6] The Illusion of State in State-Space Models. ICML 2024, arXiv:2404.08819.

[7] T²MLR: Transformer with Temporal Middle-Layer Recurrence. arXiv:2607.15178, 2026.

[8] Universal Transformers. ICLR 2019, arXiv:1807.03819.

[9] Attention is Turing Complete. JMLR 22(75), 2021.

[10] The Expressive Power of Transformers with Chain of Thought. ICLR 2024, arXiv:2310.07923.

[11] The Parallelism Tradeoff: Limitations of Log-Precision Transformers. TACL 2023, arXiv:2207.00729.

[12] Unlocking State-Tracking in Linear RNNs Through Negative Eigenvalues. ICLR 2025, arXiv:2411.12537.

[13] Scaling Latent Reasoning via Looped Language Models (Ouro). arXiv:2510.25741, 2025.

[14] Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach (Huginn). NeurIPS 2025, arXiv:2502.05171.

[15] SMELT: Scaling Laws for Compute-Matched MoE Looped Transformers. arXiv:2609.01343, 2026.

[16] Loop the Loopies! (Loopie). arXiv:2607.16051, 2026.

[17] Adaptive Computation Time for Recurrent Neural Networks (ACT). arXiv:1603.08983, 2016.

[18] Mixture-of-Depths: Dynamically allocating compute in transformer-based language models. arXiv:2404.02258, 2024.

[19] Hierarchical Reasoning Model (HRM). arXiv:2506.21734, 2025.

[20] Less is More: Recursive Reasoning with Tiny Networks (TRM). arXiv:2510.04871, 2025.

[21] Diffusion Forcing: Next-token Prediction Meets Full-Sequence Diffusion. NeurIPS 2024, arXiv:2407.01392.

[22] Efficient Parallel Samplers for Recurrent-Depth Models and Their Connection to Diffusion Language Models. ICML 2026, arXiv:2510.14961.

This series: Part 1｜LT2 and Historical KV Replay · Part 2｜Panel, First Half · Part 3｜Panel, Second Half (this post)

This is the second part of the recap of NICE’s event “Looped Language Model: Rethinking Model Depth and Parameters,” covering the first half of the panel discussion. The panel was hosted by Wenyue Hua, with Chunyuan Deng and Benhao Huang as panelists.

The first half started from a general question, “Where are the bottlenecks in LLM architecture?”, and gradually narrowed down to looping itself: What does it cost? Do its gains really come from the architecture, or just from spending more compute? And a more technical question: Should looped models learn fixed points?

Key takeaways

• FLOPs are relatively cheap; memory and bandwidth are more expensive and grow more slowly. Benhao prefers architectures that “add only FLOPs, not memory” (improving performance by adding compute without adding memory footprint such as parameters and KV cache), and the ideal latent CoT is exactly that. Chunyuan thinks the Transformer has no particularly big bottleneck and is more optimistic about architectures for settings where training data is repeated. Benhao added that the data wall (the total amount of high-quality training data is limited and will eventually fail to keep up with the growth of models and compute) may matter more than architecture.
• Looping is not a free lunch. Without KV sharing or compression, a looped LM offers little beyond some inductive bias; almost everything else is a cost: more KV cache, and performance that cannot catch up with a standard Transformer of the same logical depth without weight sharing. Many papers compare only against models with the same number of parameters, not against this “upper bound.”
• MoE may make up for having fewer parameters. Parameters determine how much knowledge a model can store. Benhao observed that in looped MoE models, different loops do activate different experts, and adding MoE narrows the gap to the upper bound.
• Fair comparisons look at entire scaling curves. Looping spends extra compute. When comparing with a model that does not loop (the baseline), Chunyuan argues that one should not change the baseline’s architecture just to equalize FLOPs, for example by changing the size of the feed-forward layers (FFN) or the dimension of the attention heads (head dim). A more sensible approach is to train a set of models from small to large (a scaling ladder) and compare the entire curve of “loss versus compute.” Benhao added that the baseline should be tuned to its best, and its width-to-depth ratio should not be changed arbitrarily just to match compute; spending more compute in training without adding cost at inference is, in his view, acceptable.
• Whether to learn fixed points depends on the goal. “Learning fixed points” means training the model so that its hidden state essentially stops changing after a certain number of loops, and looping a few more times does not make it worse. Benhao argues that if you only want the best performance at a fixed number of loops (say, 4), there is no need to learn fixed points. If you do want to, the common method is depth sampling: during training, a number of loops is drawn at random for each batch, the model loops that many times and the loss is computed at the last step. The benefit is stability: every depth may be drawn and have a loss computed on it, so the model learns not to let the loss rise when it takes a few more steps. The cost is that supervision is spread across depths, so less supervision falls on the number of loops actually used at inference, which may lower performance.
• Path independence is key. Path independence means that no matter which initial state the model starts from and how many steps it iterates, it ends up at the same fixed point. Benhao believes that Huginn (a looped language model that loops only its middle layers, introduced in Section 4) learns fairly good fixed points mainly thanks to two training techniques, each corresponding to one half of path independence: random depth sampling makes the result independent of the number of iteration steps, and truncated backpropagation (computing gradients only through the last few loops during training, while earlier loops run only the forward pass) makes the result independent of the starting point. At the same time, suitable normalization and input injection can better guide how fixed points form.

Glossary

The table below explains several terms that recur in this article. Readers familiar with them can skip it.

Panelists

Chunyuan Deng: PhD student at Rice University, advised by Prof. Hanjie Chen. His research focuses on the design and optimization of LLM pretraining architectures, as well as the interpretability of language models. His representative work is LT2: Linear-Time Looped Transformers [1]; his talk at the event is covered in part one of this series.

Benhao Huang: Master’s student at CMU, advised by Prof. Zico Kolter. He works mainly on looped LMs and fixed points, with the aim of improving the reasoning ability and efficiency of foundation models. His representative work includes Equilibrium Reasoners [2] and the blog series Towards Looped Models Done Right [3].

Wenyue Hua (host): Member of Technical Staff at Microsoft AI (MAI). PhD from Rutgers University, advised by Prof. Yongfeng Zhang, followed by a postdoc at UCSB. Research focuses on LLM reasoning and LLM-based agents, with many papers at top NLP and machine learning venues, including ACL, EMNLP, ICLR, NeurIPS and TACL. Serves as an Area Chair for ACL.

1. Bottlenecks in LLM architecture: compute, memory and data

What are the main bottlenecks of today’s large models? Have they driven most current architecture design? And what are the main solutions to them?

Benhao: FLOPs will always be cheaper

Benhao thinks that GPU memory, bandwidth and FLOPs are certainly all problems. Architecture design usually takes alignment with hardware into account, and a well-known trend line tells us that as hardware develops, memory and bandwidth grow more slowly and are bound to be more expensive, while FLOPs will always be cheaper.

Note: This trend is often called the “memory wall.” According to statistics compiled by Gholami et al. [4], over the past 20 years the peak compute of server hardware grew by about 3.0× every two years, while DRAM bandwidth grew by only about 1.6× and interconnect bandwidth by about 1.4× every two years; over 20 years, that adds up to roughly 60,000×, 100× and 30×, respectively.

So Benhao generally prefers architectures that get better results by scaling up FLOPs alone, without enlarging memory. This of course has a cost, namely latency: the more FLOPs, the slower it naturally gets. “FLOPs are cheap” is about cost, while “slow” here refers to the time it takes to generate each token. Take looping as an example: the next loop for a given token has to wait until the previous one finishes, so the extra computation can only run sequentially, and the more loops there are, the longer each token takes to generate. But this is still acceptable for now, especially assuming that frontier labs have nearly unlimited FLOPs.

What he likes about one of his own recent papers is precisely that it explores whether there is a way to get better performance purely by adding FLOPs, without increasing memory overhead. He sees this as perhaps the ultimate form of latent CoT (reasoning in the latent space without writing out the intermediate steps as text):

You don’t externalize your thought tokens, you don’t have extra KV cache, and you don’t have any extra parameters. You just have more FLOPs: you think more in your head, spend more energy, and then come up with a better method, a better idea.

Chunyuan: the Transformer has no particularly big bottleneck

Chunyuan said he does not think the Transformer has any particularly big bottleneck; in architecture design, we can always do better: be more efficient, use less memory, compute more efficiently.

One direction he finds fairly promising: many labs have recently been studying architectures for the data-repetition setting. Data is becoming scarcer, and training on repeated data has become common. So what kind of architecture can provide regularization and avoid overfitting when trained on repeated data? And what kind of optimization method should go with it?

Note: A frequently cited result on data repetition comes from Muennighoff et al. [5]: with a fixed compute budget, training on the same data for up to about 4 epochs yields almost the same loss as using fresh data; but with more repetitions, the returns from additional compute eventually decay to zero.

Benhao: the data wall matters more

Benhao added that the data-efficiency and data-repetition questions Chunyuan raised are very interesting. The data wall is also a bottleneck, but he thinks it matters more than architecture: “Data always comes first.” If data is a first-class citizen, then finding architectures that can adapt as data becomes scarcer would be a very valuable direction.

2. The cost of looping: KV cache, the performance upper bound and MoE

Looping does not reduce the memory taken up by KVs. It adds FLOPs under a parameter constraint, but the demands on memory and bandwidth also seem to go up. How should we think about this?

Apart from a bit of inductive bias, it’s almost all cost

Benhao’s answer was quite blunt: following the usual practice so far, without any KV sharing or compression techniques, a looped LM may offer a bit of inductive bias (a preference for certain kinds of solutions that comes from the architecture itself), and everything else is basically a cost: it has more KV cache, and its performance cannot catch up with a vanilla Transformer of the same logical depth.

He also pointed out that most papers do not compare against the upper bound and usually report only the lower bound: they compare only with a model that has the same number of parameters and does not loop, not with a standard Transformer of the same logical depth without weight sharing. “I haven’t seen one that really beats that upper bound, and I think it may simply be impossible to beat.” Chunyuan added: “It can’t beat it.” Benhao went on to say that some might argue it could win at a large enough scale, but in his view this resembles the debate over whether diffusion language models can beat autoregressive models, and his judgment is that it cannot.

Chunyuan agreed, and admitted that his own work also did not compare against models of the same depth. He had tried it himself, and the looped model really did fall short, especially in pretraining; if there is no extrapolation and it still falls short, that is a real problem. One argument he could think of: if extremely sparse, very large MoE models appear in the future, say with 1000T parameters that cannot fit in GPU memory, weight sharing might help. “Other than that… it gets a bit tricky.”

Can MoE make up for having fewer parameters?

The host then turned to MoE: since Chunyuan said architecture has no particular bottleneck, why has MoE become mainstream? As she understands it, MoE adds parameters without adding FLOPs to the same extent, while still keeping fairly good results. Is this choice mainly driven by latency?

Benhao’s take is that a major problem for looped LMs is still parameters, and parameters determine how much knowledge a model can store. MoE is a good way to alleviate this: different activations lead the router to choose different experts and thus draw on different knowledge. In looped MoE models, different loops do activate different experts, which amounts to retrieving different knowledge at each step.

Conversely, without MoE, the hidden states of different loops are quite similar, which hurts performance. In his earlier blog [3], he found that without MoE the gap between a looped model and the upper bound is fairly large; once both the looped model and the standard Transformer use MoE, the gap becomes smaller.

Note: According to the first part of the blog, the comparison is with a 112-layer model that has the same logical depth and the same active compute as the looped model but does not share weights across layers. Switching from dense to MoE narrows the looped model’s average gap to it from 4.96 points to 1.71 points, while the looped model has 75% fewer resident parameters. The blog also found that forcing later loops to reuse the experts selected by the first loop lowered accuracy on all six test tasks.

3. Gains from architecture or from compute: what makes a fair comparison

Do the gains of looping really come from the architecture, or just from spending more compute? What is a fair way to test this?

Chunyuan: one approach is definitely wrong

Chunyuan began by saying that comparing looped models is “really tricky.” First of all, one approach is definitely wrong: since looping adds FLOPs, people change the vanilla Transformer’s FFN, head dim or other parts of its architecture so that its FLOPs match those of the looped model. Changing a lot of the original architecture just to reach equal FLOPs “definitely doesn’t work.”

He thinks the most standard way to compare is with a scaling ladder in pretraining. For example, train a set of standard Transformers from small to large in the usual way, with the third rung being, say, a 300M model. Looping adds FLOPs, so every point of the looped version shifts to the right along the horizontal axis (compute). “Isn’t that the whole point of a scaling ladder?” A scaling ladder is meant to fit a power law and compare two curves anyway, so there is no need to worry about whether each rung lines up exactly with the baseline.

As for comparing wall-clock time (actual running time), he thinks it is just too hard for academia: the various GPU setups are hard to compare with real 10,000-GPU clusters.

Benhao: tune the baseline well, and look at training and inference separately

Benhao added two points:

• Always tune the baseline to its best, and never compare against a weak baseline. He gave the example that some recent work widens or narrows the model’s dimension in order to match FLOPs. But there is a relatively optimal range for the balance between width and depth, which cannot be adjusted arbitrarily; going outside that range makes the comparison unfair.
• Training and inference costs can be considered separately. If paying some extra cost in training (usually compute) buys a performance gain with no extra cost at decoding time, he considers that acceptable. In his view, a major difference between academia and industry is that academia is very preoccupied with fair settings, while industry cares more about what gains a model brings when it is actually served.

The host remarked that this means many points are needed to compare two curves properly, which is expensive. Benhao said: “That’s the brutal part of pretraining.” It is genuinely hard for academia: even with a ladder, getting the hyperparameters right (including the width and depth just mentioned) is very difficult. As a result, many papers do claim some benefits, but benefits that hold up are rare.

Follow-up: what does “no extra cost at decoding time” mean?

The host followed up: when Benhao said earlier “no extra cost at decoding time,” did he mean that inference speed is unaffected? Could this be achieved with pipelined looping (staggering different loops of different tokens so that they compute in parallel, like a pipeline) and with how the KV cache is handled?

Benhao replied that he mainly had in mind approaches like the Full-Bandwidth Transformer [6]: add a side path to the model that costs some extra compute in training but adds almost no overhead at decoding time. In his view, this is a more typical example than pipelining; the pipelined approach also makes sense, but it has some subtleties, which he would come back to later (see Section 8 of part three of this series).

Editor’s note: The side path in the Full-Bandwidth Transformer takes the top-layer hidden state at the previous position, fuses it with the next token’s embedding through a gate, and uses the result as the input at the next position. Training requires a few extra forward passes, but by the paper’s estimate, the added compute per token at decoding time is under 1% (about 2.3% slower when measured in vLLM). See part three of this series for details.

4. Two representative architectures: Ouro and Huginn

Before moving on to fixed points, the host asked the two panelists to give some background on two architectures, Ouro and Huginn.

Chunyuan: the core difference is whole-model looping versus middle looping

Chunyuan summed it up: Ouro [7] is a whole-model loop: it loops the entire model and uses early exit, so it can stop early; Huginn [8] is a middle loop: it loops a middle part of the model and uses a latent state and input injection. In his view, the main difference between the two is whole-model looping versus middle looping; the other components (such as input injection) can be borrowed by either.

Note: The table below summarizes details reported in the two models’ papers.

Benhao’s three additions

First, input injection helps somewhat with middle looping. For a middle-looping architecture like Huginn, input injection does help to some extent, especially with somewhat more loops; without it, a Huginn-style architecture tends to lose to Ouro at the same logical depth.

Second, Ouro “grows” a middle loop inside itself. If you match the two models’ logical depth, unroll the looped parts and compare similarity metrics such as CKA [9] for the hidden states at the same layer, you find that Ouro has learned on its own a structure very similar to middle looping: it has layers that correspond to a prelude and a coda. The prelude and coda can be understood as encoding and decoding, with step-by-step refinement of the hidden representation in between.

He also mentioned that similar phenomena may exist in other looped models, so this is not necessarily a new finding; but Huginn’s approach of looping in the middle may happen to fit this inductive bias. He further mentioned that some papers argue that RL mainly changes a small part in the middle of the model, which he guesses may be responsible for abilities such as reasoning.

Note: One example is a July 2026 preprint [10]: it found that the gains from RL are highly concentrated in a few layers, that training a single layer alone can often come close to the effect of full-parameter RL, and that the layers contributing most are concentrated in the middle of the network.

Third, Huginn’s random depth sampling is very important. It is crucial both for shaping fixed points and for adjusting compute at inference. Benhao thinks the term “test-time scaling” is somewhat ambiguous: in his view, what it really means is extrapolation, for example having seen only 16 loops in training and wanting to loop 64 times at inference. “Unfortunately, I don’t think that’s very likely,” especially for language models. What random depth sampling really supports is elastic compute: loop at most 16 times in training, and at inference you can freely choose how many times to loop, as long as it does not exceed 16.

5. Whether to learn fixed points: the pros and cons of depth sampling

With the architectures laid out, the host put the question to Benhao. He gave his conclusion first: if you only want the best performance at a fixed number of loops (say, 4 or 5), using the model as an ordinary Transformer and ignoring other costs such as memory, then you should not try to learn fixed points, and performance will be better that way.

The common approach: depth sampling

If you do want to learn fixed points, you need some additional algorithms, the best known of which is depth sampling: during training, sample a depth for each batch (or even each micro-batch), run that many steps forward, and then apply the loss at that step.

One of Benhao’s core points is that supervision itself is a resource. Suppose the target budget is 5 loops. Depth sampling puts part of the supervision on steps 1 to 4, or at deeper steps, so step 5 gets correspondingly less supervision, and the model’s performance at 5 steps drops.

The benefit it brings is stability: it requires that the loss not rise with each additional step. This does not necessarily improve performance, but it makes the model more stable. There may be some math behind this: from the perspective of the Jacobian and its eigenvalues, for the iteration to contract, the eigenvalues need to be less than 1, which can be proven. But the most intuitive way to see it is this: if every depth has a loss and the loss is not allowed to go up, then the simplest shortcut the model can learn is to stay put in a stable state, which is what we call a fixed point, or attractor.

A counterintuitive experimental result

But his own experiments found that even when the target budget is 5, the mean of the depth distribution is also set to 5, the long tail extends all the way to 64, and the model is unrolled to 64 steps at test time, it does not necessarily beat a control model trained at a fixed depth of 5 without learning fixed points.

His conclusion: this may be a problem with the algorithms for learning fixed points, not with fixed points themselves. Depth sampling is just one way to learn fixed points. DEQ (Deep Equilibrium Models) [11], for example, makes training and inference fully consistent: in the forward pass during training, it iterates with a fixed-point solver until convergence reaches a certain threshold; in the backward pass, it uses the implicit gradient, which in the ideal case corresponds exactly to the mathematical solution of backpropagation. In this case, it may be possible to reach very good performance without necessarily running into the problem above; the difficulty is that it is very hard to train: DEQ is notoriously unstable and needs tricks such as warm-up. Depth sampling is a compromise.

Note: DEQ was proposed in 2019 by Shaojie Bai, Zico Kolter and Vladlen Koltun. It can be seen as an infinitely deep weight-sharing network: instead of computing layer by layer, the forward pass uses a root-finding algorithm (Broyden’s method in the original paper) to solve directly for the fixed point satisfying z* = f(z*, x); the backward pass computes gradients with the implicit function theorem at the fixed point, without storing intermediate steps.

6. Are fixed points ideal solutions or degenerate states?

The host asked: is a learned fixed point the solution we want, or might it be a degenerate state?

Fixed points and performance are decoupled

Benhao said that the argument of one of his earlier papers [2] is that fixed points themselves are actually decoupled from model performance. A model may well have many fixed points (or attractors), and what training does is align these attractors with the correct task objective as much as possible; that is, we want the hidden state corresponding to an attractor to decode into exactly the correct tokens, the correct answer. So fixed points are not necessarily degenerate.

Note: The paper is Equilibrium Reasoners. It argues that reasoning generalizes because the model learns “task-conditioned attractors”: the stable fixed points of the latent dynamics correspond exactly to valid solutions. On tasks such as Sudoku and mazes, the paper scales test-time compute by increasing the number of iteration steps and using multiple random restarts; it reports that when unrolled to a depth equivalent to 40,000 layers, accuracy on Sudoku-Extreme rises from 2.6% for a feed-forward model to over 99%.

If degeneration really does occur, it may be because the model had not yet reached the attractor when supervision was applied, so the supervision was placed on the path before the attractor. In that case, after a few more iterations, the model may indeed converge, but to a bad point.

Why Ouro gets worse with more iterations

He thinks this may also be why Ouro’s performance drops markedly when it runs more iterations than in training. The host asked: does Ouro’s design simply never reach a fixed point? Benhao’s view is that Ouro may not do enough to “push” supervision onto the fixed point, but having a loss at every loop helps to some extent, and iterating further is unlikely to diverge. The problem is that it loops only 4 times in training and has no depth sampling, so nothing encourages the model to stay near its step-4 state after looping more than 4 times; it may therefore keep moving until it reaches a degenerate place. By comparison, Huginn should be fine as long as it stays within 64 steps, with only a slight decline beyond 64.

Note: Ouro loops a fixed 4 times in training (it initially tried 8, but switched to 4 because of loss spikes and gradient oscillations), with a language-modeling loss at every step. The paper reports that increasing the number of loops to 5–8 leads to a “moderate degradation” in the base models’ performance: at 8 loops, MMLU drops from 67.45 to 64.49 for the 1.4B model and from 74.60 to 72.24 for the 2.6B model; the reasoning versions drop more on hard problems, for example AIME25 for the 2.6B reasoning model falls from 50.30 to 24.33. As for Huginn, performance keeps improving up to about 64 steps and stops improving after that, but usually does not get worse either.

Decoupled, but also coupled

The host summarized that it sounds as if there is no necessary connection between fixed points and performance. Benhao agreed with this way of thinking, but pointed out some subtleties: some methods couple the two. Take depth sampling: on the one hand, it places supervision at very large depths, which amounts to aligning the fixed point with the task objective; on the other hand, it can also shape fixed points itself, as a technique for achieving “path independence,” which the next section covers in detail. “So it solves two problems at once.” The two are coupled and not so cleanly separated, but thinking about them separately like this is helpful.

Note: Fixed points have a very practical use as well. In the second part of their blog series [13], Benhao’s team reports that keeping only each token’s KVs from its last loop during decoding (terminal KV sharing) can shrink the KV cache of a 1.6B model to one third. A model trained at a fixed depth loses a lot of accuracy when doing this (GSM8K drops from 50.6 to 21.2), while a model trained with a learned depth prior (the distribution of loop depths in training is no longer set by hand but learned from predictive performance, with an entropy term that keeps the distribution wide enough) is essentially unaffected.

7. How architecture and algorithms affect convergence: path independence

The host then asked: how do architecture design and algorithm design affect convergence, including what kind of point the model ultimately converges to? Benhao listed three kinds of approaches:

• Residual scaling: architecturally, an important factor is scaling the residual connections; some papers multiply the residual by a scaling coefficient so that later layers contribute less [14].
• Input injection: well-designed input injection can aid convergence, but injection by itself does not guarantee it; its bigger role is to make the point the model converges to depend on the original input context. If you iterate to infinity without continually injecting the context, you get a degenerate attractor that has nothing to do with the prompt and is therefore meaningless. This is how the DEQ line of work understands the value of input injection.
• Jacobian regularization on the loss side: this is no longer architecture design but an algorithm: imposing some constraints on the Jacobian [12] can directly promote convergence. He mentioned that the recently popular Fixed-Point Reasoners [14] also uses a similar technique.

Note: Fixed-Point Reasoners does not use Jacobian regularization directly. Instead, it keeps the state bounded with pre-norm plus a shared, learnable residual scaling coefficient (also applied to the input re-injected in each loop), and promotes convergence with a contraction condition encouraged through initialization and with damped updates; at inference, it stops looping once the fixed-point residual is small enough. Its goal (making the iteration contract) is the same as that of Jacobian regularization, but its specific means are closer to the first category above.

In Huginn’s case: depth sampling and truncated backpropagation

The host followed up: does Huginn converge to a relatively good fixed point because it has input injection and uses normalization, plus depth sampling?

Benhao thinks that, at least in the Huginn paper, normalization and input injection are not the most important factors. Two things matter more: one is depth sampling, and the other is truncated backpropagation, which has not come up yet. Truncated backpropagation means not backpropagating gradients all the way: for example, once the number of loops exceeds a certain number of steps, you always backpropagate through only a fixed number of final steps, so memory does not keep growing with the number of steps. This is a very common practice in training RNNs, and it also helps shape fixed points.

People may think of both from the perspective of efficiency, and both are indeed economical. Depth sampling does not bet a lot of resources on very large depths, which makes sense because not every token needs such deep computation. The same goes for truncated backpropagation: if the memory and activations for backpropagation grow linearly with the number of forward steps, training can easily blow up. But beyond efficiency, both also help shape fixed points.

Path independence

Benhao said this can be understood from the perspective of path independence. A well-known paper in the DEQ line of work [15] argues that for attractors to perform well enough, or in its words to generalize well enough, path independence must be ensured. Path independence means that no matter which point you start from and how many steps you take, you end up at the same fixed point or attractor.

Note: The paper found that whether an equilibrium model can solve harder problems by increasing the number of iterations at test time is highly correlated with how path-independent the system is.

In his view, the two techniques correspond exactly to the two halves of path independence:

• Depth sampling makes the result independent of the number of steps. The number of steps taken in training is random, so the model has to learn to reach the same state for any number of steps.
• Truncated backpropagation makes the result independent of the starting point. The states of the early steps contribute no gradient, so the model “doesn’t know where it came from, but knows where it is heading in the end.”

So he concluded that, for Huginn, these two are the more important factors in shaping fixed points; suitable normalization and input injection are also important design choices for preventing divergence.

Closing and what’s next

The first half of the discussion follows a clear thread: the costs of looping are real, namely more KV cache and performance that struggles to reach the upper bound set by a standard Transformer of the same logical depth without weight sharing; its benefits have to be validated with complete scaling curves and well-tuned baselines. “Whether to learn fixed points” is essentially a trade-off between the best performance at a fixed depth and stability over more iterations. Benhao also offered a very useful perspective: depth sampling and truncated backpropagation make the result independent of the number of steps and of the starting point, respectively.

The next part covers the second half of the panel: whether looping along depth is the same thing as CoT, whether expressiveness proofs still mean anything, how loops can be combined with MoE, and extrapolation, ACT and parallel decoding.

References

[1] LT2: Linear-Time Looped Transformers. arXiv:2605.20670, 2026.

[2] Equilibrium Reasoners: Learning Attractors Enables Scalable Reasoning. arXiv:2605.21488, 2026.

[3] Towards Looped Models Done Right. Blog series, 2026.

[4] AI and Memory Wall. IEEE Micro; arXiv:2403.14123, 2024.

[5] Scaling Data-Constrained Language Models. NeurIPS 2023, arXiv:2305.16264.

[6] Full-bandwidth transformer. arXiv:2608.08888, 2026.

[7] Scaling Latent Reasoning via Looped Language Models (Ouro). arXiv:2510.25741, 2025.

[8] Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach (Huginn). NeurIPS 2025, arXiv:2502.05171.

[9] Similarity of Neural Network Representations Revisited (CKA). ICML 2019, arXiv:1905.00414.

[10] Is One Layer Enough? Training A Single Transformer Layer Can Match Full-Parameter RL Training. arXiv:2607.01232, 2026.

[11] Deep Equilibrium Models (DEQ). NeurIPS 2019, arXiv:1909.01377.

[12] Stabilizing Equilibrium Models by Jacobian Regularization. ICML 2021, arXiv:2106.14342.

[13] Towards Looped Models Done Right, Part II: Rethinking at Fixed Points. arXiv:2610.06833, 2026.

[14] Fixed-Point Reasoners: Stable and Adaptive Deep Looped Transformers. arXiv:2606.18206, 2026.

[15] Path Independent Equilibrium Models Can Better Exploit Test-Time Computation. NeurIPS 2022, arXiv:2211.09961.

This series: Part 1｜LT2 and Historical KV Replay · Part 2｜Panel, First Half (this post) · Part 3｜Panel, Second Half

On October 17 at 9 p.m. ET (9 a.m. on Sunday, October 18, Beijing time), NICE hosted an online talk and panel, “Looped Language Model: Rethinking Model Depth and Parameters.” There was a lot to cover, so this recap comes in three parts: the first covers Chunyuan Deng’s talk, and the second and third cover the two halves of the panel discussion. This is part one.

The idea behind looped LMs is simple: run the same set of layers several times, adding computational depth without adding parameters. But a loop saves parameters, not KV cache. That is where Chunyuan’s talk starts: can combining loops with linear attention keep the benefits of looping while lowering the cost of inference? Beyond the analysis in the published paper, he also presented Historical KV Replay, a new method from his team that is not yet in the public version of the paper.

Key takeaways

• Looping saves parameters, not KV cache. When a standard (full-attention) Transformer loops, its KV cache grows linearly with the number of loops. At long context lengths, a full-attention model that does not loop at all is more expensive than a linear-attention model that loops many times. This is why LT2 moves looping onto linear attention.
• Writing to the same memory several times increases expressiveness. Linear attention compresses the history into a fixed-size “memory,” which you can think of as a lookup table. For each incoming token, the delta rule “erases, then writes” the entry associated with that token: it first erases the old content, then writes the new content. Per the DeltaProduct analysis, erasing and writing n times at the same position updates n entries in one step instead of just one, provided the n writes really modify different, non-overlapping entries, which the team verified largely holds in common settings.
• But when linear attention is looped directly, each loop writes to its own memory. The theory above therefore does not strictly apply, and the recurrence over time and the recurrence over depth are never connected. This leaves room for co-design.
• The new method, Historical KV Replay, replays earlier loops’ KVs in reverse order. It brings large gains in both recall and language modeling. Order is crucial: reverse order works, while forward order barely helps.
• The cost is manageable, and the gains are not just from “computing more.” The amount of replay grows quadratically with the number of loops (loop k writes its own KVs and also rewrites the KVs of the previous k−1 loops, so 4 loops require 1+2+3+4 = 10 writes in total), but models today usually loop only two or three times. In controlled comparisons, the team also tried other ways of adding the same amount of compute: looping more times (just more rounds, with each loop still writing only its own memory), widening GDN (Gated DeltaNet, the linear attention that LT2 loops), and stacking DeltaProduct inside each layer (erasing and writing several times at the same position). All of these helped, but none matched replay.
• Extrapolation matters more than tinkering with the architecture. Chunyuan argues that without extrapolation, one has to work very hard to justify the value of weight sharing (if a looped model cannot loop more at inference than in training, it is just a fixed-depth model whose layers share parameters, and its main advantage is fewer parameters; extrapolation is what lets it loop more on demand at inference time, trading extra compute for better results). ACT (adaptive computation, which lets each token decide how many loops to run based on its difficulty) is very hard to implement, and it is unclear whether it can be solved. Post-training, especially combining on-policy distillation with loops, deserves attention.

Glossary

The table below explains several terms that recur in this article. Readers familiar with them can skip it.

Speakers

Chunyuan Deng (speaker): PhD student at Rice University, advised by Prof. Hanjie Chen. His research focuses on the design and optimization of LLM pretraining architectures, as well as the interpretability of language models. The work presented in this talk is LT2: Linear-Time Looped Transformers [1].

[Figure: cover slide of Chunyuan’s talk]

1. Motivation: looping saves parameters, but not KV cache

The selling point of looped models is parameter efficiency: reuse the same layers several times, and the computational depth multiplies while the parameter count stays the same. But when Chunyuan’s team first started working on loops, their impression was that they were “very expensive.” The reason is that a loop shares parameters, but not the KV cache.

In a full-attention Transformer, every layer stores a key and a value for every token. If the model loops 4 times, the same token has to store a copy in each loop, so the KV cache grows in proportion to the number of loops. For looping on full attention, this overhead is “simply unacceptable,” and it is hard to imagine extrapolating it to many loops.

Linear attention is different: its recurrent memory is small, and both its training FLOPs and its inference memory scale well. As a result, at long context lengths a full-attention model that does not loop at all is far more expensive than a linear-attention model that loops many times.

Note: Here is a back-of-the-envelope estimate for a single layer and a single attention head (ignoring compression techniques such as GQA). Let the head dimension be d and the context length be N. Full attention stores a key vector and a value vector for every token, 2N·d numbers in total. The state of a linear attention such as GDN is a d×d matrix, d² numbers, independent of N (linear attention takes the outer product of each token’s key and value to get a d×d matrix and accumulates it into the same state, so the state stays the same size no matter how many tokens are read). With d = 128 and N = 32K, the former is about 512 times the latter. So even if a linear-attention model loops a hundred times or more, its total per-layer state is still smaller than that of a full-attention model that does not loop.

This is the starting point of LT2 [1]: loop on linear attention, so that both training FLOPs and inference memory stay well-behaved. A set of numbers from Chunyuan’s slides makes this concrete: for a 0.6B model at 32k context, the looped Transformer’s KV cache is 12.1 GB, while LT2’s is only 0.05 GB; decoding speeds are 6.3 and 19.4 tokens per second, respectively.

[image: Chunyuan’s slides, p. 3]

Figure: A looped Transformer stores a separate KV cache for each loop, which grows with context length; LT2 keeps only one fixed-size state per loop.

2. The intuition: write to the same memory several times

LT2 mainly studies linear attention of the GDN [2] and KDA [3] type. As Chunyuan explained, their state transition matrix (the matrix that, each time a token is read, determines how the old memory changes: how much it decays and what gets erased; see α_t(I − β_t k_t k_tᵀ) in the formula below) can be written in a “diagonal plus low-rank” (DPLR) form. This class of linear attention currently works well and is widely used.

First, what does the delta rule do? For each incoming token, the model updates the memory matrix S using the token’s key k_t, value v_t and write strength β_t (using GDN as the example, with slightly simplified notation):

S_t = \alpha_t \left(I - \beta_t k_t k_t^{\top}\right) S_{t-1} + \beta_t k_t v_t^{\top}

The term I − β_t k_t k_tᵀ in parentheses is the identity matrix minus a rank-1 matrix: it partially erases the memory’s old content in the k_t direction, and the second term then writes the new value into that direction. This is what Chunyuan meant by “erase once and write once along k_t.” α_t is the forget gate, which controls how much the old memory decays overall; KDA makes this gate finer-grained than GDN does. In the GDN paper’s framing, the gate enables rapid memory erasure, while the delta rule enables targeted updates.

The earlier DeltaProduct [4] work goes a step further: instead of erasing and writing once per token, it does so n_h times in a row at the same position. The state transition matrix then becomes a product of n_h such matrices:

A_t = \prod_{j=1}^{n_h} \left(I - \beta_{t,j}\, k_{t,j} k_{t,j}^{\top}\right)

Each factor is “identity minus rank 1,” so the product is “identity minus a matrix of rank at most n_h”; together with the forget gate, this is what the paper calls “diagonal plus rank n_h.” Intuitively, one erase-and-write can only change the memory’s content in one direction, while n_h of them can change n_h directions. A “direction” here is the direction of a key vector: if you think of the memory as a table looked up by key, each key direction roughly corresponds to one entry, and the closer the keys of the successive writes are to orthogonal, the more they modify unrelated entries. DeltaProduct’s theoretical analysis shows that the larger n_h is, the stronger the model’s state tracking (e.g., working out where each item ends up after a sequence of swaps); experimentally, it outperforms DeltaNet, which writes only once per token, on both state tracking and language modeling.

Chunyuan put it more plainly: the theory looks complicated, but it is actually easy to understand. As long as the keys used in the successive writes are mutually orthogonal, or at least not fully collinear, each write goes in a different direction, which is like being able to erase several times. So doing a few more products at the linear-attention step, i.e., looping at the position of the delta rule, gives stronger control over the recurrent memory.

But do keys “collide” in practice, i.e., are the keys of successive writes nearly collinear? The team checked: the larger the head dim, the harder it is for keys to collide, and the smaller, the easier. According to the statistics in the slides, at default settings such as a head dim of 128 or 256, the absolute cosine between the keys of two adjacent loops in GDN averages only about 0.05, so collisions are rare; when the head dim drops to 32 and the number of loops rises to 16, collisions become much more frequent. The gain in expressiveness from rank 1 to rank n_h is therefore fairly reliable.

Note: In high-dimensional space, two vectors with random directions are naturally close to orthogonal. The cosine of the angle between two random d-dimensional unit vectors has a mean of 0 and a standard deviation of about 1/√d, so it typically deviates from 0 by only about 1/√d, roughly 0.09 for d = 128. The closer the cosine is to 0, the closer the two vectors are to orthogonal. So the larger the head dim, the less likely keys are to collide.

There is a subtlety here, though. When a GDN or KDA is looped directly, each loop maintains its own recurrent memory: loop 1 writes its own KVs into its own memory, loop 2 writes into another one, and so on. The theory above is about repeatedly erasing and writing the same memory, whereas direct looping writes to different memories. Chunyuan admitted that applying the theory this way is “actually not rigorous.”

Seen from another angle, the recurrence over time (updating the memory token by token) and the recurrence over depth (updating representations loop by loop) could be treated as a single whole. Arrange all tokens and all loops in a “token × loop” grid: unrolled step by step, it is a single data stream, and training with teacher forcing (feeding in the whole ground-truth text at once and computing all positions in parallel) amounts to computing the whole grid at once. With direct looping, the two dimensions run separately and have never been designed jointly. Chunyuan thinks there may be a good opportunity for co-design here, which leads to the new method in the next section.

3. New work: Historical KV Replay

This section covers the team’s recent work, which is not yet in the public version of the paper; Chunyuan said they may update the paper later.

How it works: rewrite the old KVs when writing new memory

Take a single token as an example: going up the network, it passes through loops 1, 2, 3 and 4 in turn. Normally, each loop writes only the KVs computed in that loop into its own memory, and the KVs of different loops have nothing to do with each other. Replay works like this: when loop k writes its memory, it also brings over the KVs of the earlier loops and writes them again. For example, loop 2 brings over loop 1’s KVs and writes them once more; loop 3 rewrites the KVs of loops 2 and 1; and so on. This creates a form of co-design between the recurrence over depth and the recurrence over time.

Chunyuan offered an analogy: you read the first book, then the second; after finishing the second, you flip back through the first because you are afraid you have forgotten it; after finishing the third, you review the second and the first.

From the perspective of the previous section, replay makes loop k’s memory receive, at the same token position, erase-and-write operations with keys from multiple loops. In other words, it “writes to the same memory several times”: each step’s update goes from rank 1 to rank at most k. Replay introduces no new parameters and does not change the memory size. According to the formulas in the slides, the forget-gate decay is applied only once per token, and each write uses the write strength β of the loop it comes from.

[image: Chunyuan’s slides, p. 7]

Figure: The number j in each cell denotes the KVs that the token computed in loop j; loop k writes its own KVs first and loop 1’s KVs last.

Order is crucial: replay in reverse

Replay in reverse order (4→3→2→1), not in forward order (1→2→3→4). For loop 4, this means writing its own KVs first, then those of loops 3, 2 and 1 in turn. In terms of the reading analogy: after finishing a new book, don’t start rereading from the first book; learn the new one first, then work backwards to review the older ones.

In experiments, forward order brings almost no gain, while reverse order substantially improves recall and also brings large gains in pretraining language modeling. A comparison in the slides (1.3B model, 4 loops) makes the point clearly. Both orders write exactly the same KVs the same number of times; only the order differs. On a recall test at length 2k, looped GDN without replay scores 34.58, forward replay 34.71 and reverse replay 41.10; the averages over 8 zero-shot tasks are 58.39, 58.45 and 61.10, respectively. Chunyuan noted that the improvement is especially pronounced on recall tasks close to real-world use, such as “needle in a haystack.” He also offered a way to think about it: the more loops there are, the more representations replay accumulates along depth, somewhat like a latent chain of thought (latent CoT) unrolled along depth.

Note: The explanation Chunyuan gives in his slides is “the last write wins”: each write erases part of the old content along its own key direction, so the KV pair written last is overwritten the least. In forward order, the last write is the current loop’s own KVs, so the final state of the memory is almost the same as without replay; in reverse order, the last write is loop 1’s KVs, which are therefore preserved most completely in every loop’s memory. A test-time intervention experiment supports this. For a 1.3B model trained with Full Replay, changing only how replay is done at inference, switching to forward order lowers 2k recall by 7.7 points and dropping the loop-1 pair lowers it by 8.5 points, while dropping the previous loop’s pair lowers it by only 0.8 points. The model clearly relies mainly on loop 1’s KVs, which are written last.

Cost: quadratic growth, but few loops

A natural question is whether replay is expensive. Each replay means one more delta-rule erase-and-write. With n loops, the total number of writes is 1 + 2 + … + n = n(n+1)/2, which grows quadratically with the number of loops. Fortunately, people do not loop very many times today (“nobody loops ten thousand times”), usually just two or three, and in that range the extra cost is not large.

There is also a small engineering trick. Replay forms a small set of KVs along the depth dimension, so instead of doing several rounds of reads and writes one after another, you can stack them into a small matrix and run a chunkwise computation along depth (chunkwise normally splits along the sequence length; here it splits along depth). This lets you reuse existing GDN kernels and keeps the decoding cost down. According to the slides, during decoding each loop still reads and writes the state only once; what is added is computation, not state reads and writes.

Chunyuan presented the following cost comparison. Compared with a looped model that is also based on linear attention but does no replay, Full Replay has lower training throughput and slightly slower decoding because of the extra replay and writes, but overall inference remains acceptable. The specific numbers (0.6B model, a single H100): training throughput at 4k length drops from 41.2k to 34.6k tokens per second (about 16% lower), and decoding speed at 32k context drops from 19.4 to 18.4 tokens per second (about 5% lower). The slowdown here is the extra cost of replay relative to plain looping; compared with a looped full-attention model, linear attention is still far cheaper at long context lengths.

A cheaper variant: First-loop Replay

Instead of replaying the whole history, this variant replays only the first loop’s KVs: each loop no longer writes its own KVs but writes loop 1’s KVs instead, so the number of writes per token is the same as with plain looping. This is somewhat like the idea behind YOCO [5]: early depths provide the KVs for later depths.

Note: YOCO (You Only Cache Once) is a decoder-decoder architecture: the first half of the network produces a single global KV cache, which all layers in the second half share through cross-attention, greatly reducing the size of the KV cache.

One key detail: only the earlier loops’ KVs are reused, not their decay coefficients (α), write strengths (β) or queries; each loop still uses its own α, β and query. If α and β are reused as well, results get much worse. Chunyuan said this has a bit of a “hybrid” feel: it uses some historical information while keeping each loop’s own information. It is a good balance point they found: training and decoding speeds are basically unaffected, and it still captures part of replay’s gains. The numbers in the slides: training throughput drops by only about 1%, decoding is actually about 4% faster, and the gain in average score is about 70% of Full Replay’s (+1.94 vs. +2.78 on the 0.6B model).

In the ablations, they compared forward order, reverse order, replaying only the first loop, and several other combinations and orders. Taking Full Replay’s improvement as 100% (0.6B model), forward order captures only 2%, “current loop + previous loop” 16%, “current loop + loop 1” 84%, and First-loop Replay 70%. The key, then, is to keep loop 1’s KVs and write them last. Based on these ablations, the recommended approach is to keep the first loop’s KVs while letting each later loop use its own write strength and decay, capturing the gains at a lower cost. After recent discussions, however, the team also feels that First-loop Replay is sometimes not stable enough. In the talk, Chunyuan recommended Full Replay instead: it costs a bit more, but it does work better.

The gains are not just from “computing more”

To rule out the explanation that replay simply spends more compute, they compared replay with other ways of adding compute: looping more times (e.g., 6 times), widening GDN, and, while looping the whole model, stacking the DeltaProduct-style repeated erase-and-write from the previous section inside each layer. All of these help, and more compute generally brings more gain, but the improvements may all fall short of replay. In the comparison plot in the slides (0.6B model), these approaches raise the average score only from 55.7 to somewhere between 56 and 57, and both their training and decoding speeds are lower than First-loop Replay’s, whereas First-loop Replay and Full Replay reach 57.7 and 58.5, respectively. Chunyuan concludes that replay’s gains cannot be explained simply by compute; moreover, some of the other approaches run into system-level problems and are less efficient.

Finally, Chunyuan added that what he showed is the pure linear-attention setting. The more realistic setting is a hybrid one, and replay works on hybrid models as well, with good results: the slides show that on 0.6B Full+GDN and GDN+DSA hybrids, Full Replay raises the average score by 1.4 and 2.0 and 2k recall by 3.1 and 4.3, respectively. In his view, combining loops with linear attention is always a trade-off between speed and quality: wherever a looped Transformer would be used, you can fairly freely swap in a looped GDN and get a good balance between speed and quality.

4. Other findings from the paper

Besides replay, Chunyuan picked out a few points from the published paper [1] that are worth sharing. The paper itself tries many hybrid combinations of linear attention, sparse attention, SWA and more, with fairly thorough ablations.

Note: LT2 studies two looped variants, one with linear attention (LT2-linear) and one with sparse attention (LT2-sparse). For the former, looping repeatedly refines the memory; for the latter, it expands the effective receptive field. The receptive field is how wide a range of inputs can influence the output at a given position; in a language model, it is how far back a token can draw information from. Take sliding window attention as an example. In each round, every token sees only the most recent w tokens; in the next loop, those w tokens have already absorbed the information in their own windows during the previous round, so earlier content can reach the current token indirectly through them. Each additional loop therefore extends the coverage back by one window, to about n·w tokens after n loops, the same coverage as stacking n layers of sliding window attention. “Effective” refers precisely to this indirect coverage relayed through intermediate tokens. The paper also proposes two hybrids: one combining GDN with the sparse attention DSA, which runs in linear time throughout and matches the quality of a standard looped Transformer; and one combining GDN with a small number of full-attention layers, which surpasses the standard looped baseline.

Loop-level hybrids

When building hybrids, the first idea that comes to mind is mixing along depth, e.g., one full-attention layer for every three linear-attention layers. With loops, you can also mix across loops, which gives a cross-loop hybrid: for example, the first loop uses full attention throughout and the second switches to SWA.

This works because a loop shares only the parameters, which Chunyuan calls the slow weights; anything other than the parameters can change from loop to loop. The attention mask is a typical fast weight, and if you loop the whole model, even the loss function can differ across loops. This opens up a new design space: besides depth-level hybrids, there are loop-level hybrids.

The team compared two schemes that change the attention window size from loop to loop, and the results were somewhat surprising:

• Shrinking the window loop by loop (like a CNN, e.g., full attention → 512 → 256 → 128): lower loss (perplexity 9.26), but downstream performance does not improve (average score 60.71).
• Growing the window loop by loop (e.g., 128 → 256 → 512 → full attention): slightly worse loss (perplexity 9.42), but downstream performance is actually a little higher (average score 62.47).

For reference, a conventional depth-level hybrid (with full attention interleaved within every loop) has a perplexity of 9.30 and an average score of 61.51. Lower loss usually goes with better downstream performance, but these results go the other way.

Randomly sampled attention patterns

If you treat each position along the depth and loop dimensions as a “slot,” you can choose independently whether each slot uses full attention or efficient attention. A more aggressive approach is to randomly sample the attention type of each slot during training: the overall ratio of full to efficient attention stays fixed, but their positions vary randomly. At inference, majority voting is done over multiple sampled configurations.

The method does bring some improvement, but at too high a cost: at inference, each sampled configuration has to be run separately before voting, so the compute grows in proportion to the number of samples (in the slides, 5 samples at 5× the compute raise the average score only from 61.51 to 61.75). Chunyuan considers it impractical for real use; this set of experiments was only an exploratory attempt.

5. Distilling from Ouro: no need to train from scratch

The last part of the talk was about distillation: converting a full-attention looped model such as Ouro [6] into a linear-attention hybrid model without training from scratch. Ouro is an open-source family of whole-model looped language models, which part two of this series introduces in detail. Chunyuan noted that switching to sparse attention is relatively easy, while switching to linear attention is bound to cost some performance; because this work leans toward linear attention, they tried it anyway.

Note: According to the LT2 paper, the Ouro-hybrid-1.4B obtained this way (called Ouro-LT2-1.4B in the slides) was trained on only about 1B tokens, yet it outperforms industry 1B-class models and is competitive with 4B-class models. According to the slides, the teacher is Ouro-1.4B, which loops 4 times and whose 24 layers all use full attention; the student keeps full attention in only 6 of those layers and replaces the other 18 with GDN plus replay. Training has three stages: first, aligning each layer’s hidden states and selecting the 6 layers to keep (100M tokens, length 512); then, per-loop logit distillation (600M tokens, length 4k); and finally, 32k long-context training on OpenThoughts-v3 (600M tokens). The final student reaches about 95.5% of the teacher’s average performance across 6 tasks. The contribution of each component is also clear: without replay, interleaving the 6 full-attention layers uniformly at fixed intervals retains only 65.3%, the best previous layer-selection method reaches 86.9%, and their method reaches 92.9%; adding Full Replay raises this to 95.5%.

Chunyuan shared three key points.

First, distillation data is crucial: different data maps to different downstream abilities. The data you distill on tends to determine which benchmarks improve: pretraining data corresponds to commonsense benchmarks, while open-source reasoning data may line up with math-reasoning benchmarks such as GSM8K and AIME. As for MMLU, they have not yet found data that lines up with it: “maybe our experiments weren’t thorough enough, but MMLU may also just be harder.”

Second, choosing which layers keep full attention is crucial. This point comes from earlier work [7]: when distilling into a hybrid, you should not interleave linear-attention layers uniformly at a fixed ratio. Instead, first assess the importance of each layer, then decide which layers keep full attention (that work estimates each layer’s importance with a short training run on generic text). This step substantially improves distillation. According to Chunyuan, one usually finds that the early-to-middle layers should keep full attention, while the other layers can be replaced.

Third, a loop-specific trick: a dual curriculum over depth and length. A curriculum arranges training from easy to hard. Long-context training usually increases the length gradually from short to long; with loops, you can likewise go from shallow to deep, first distilling the first loop until it closely matches the teacher, then the second loop. Their preferred approach is to advance both together: loop 1 paired with short contexts, loop 2 with longer ones. In their method, this works well.

6. Future directions

For depth-recurrent models, Chunyuan sees three directions worth watching:

• Extrapolation matters more than tinkering with the architecture. In his view, continuing to tweak architectures is not that critical; what really matters is extrapolation. Without extrapolation, one has to work very hard to justify the value of weight sharing. He explained this later in the panel discussion: a loop has only two properties, depth and weight sharing, and if there is no extrapolation and the comparison is against a model of the same depth, only weight sharing remains (see part three of this series). Conversely, with extrapolation, weight sharing provides value that a standard Transformer cannot: loop only a few times in training, then loop more on hard problems at inference, trading extra compute for better results without adding parameters or producing a longer chain of thought. Benhao also said in the panel that this kind of extrapolation is what test-time scaling really means (see part two of this series).
• ACT is very hard to implement. He is not sure whether this problem can be solved. The main difficulty is at the infra level: different tokens loop different numbers of times, which makes batching and training systems hard to design. Even so, he still lists ACT as a direction worth watching.
• Pay more attention to post-training. Not just SFT and RL; combining on-policy distillation [8] with loops in particular may work well.

Note: On-policy distillation means the student model receives token-by-token guidance from the teacher on sequences it generates itself, rather than only learning from text the teacher wrote in advance. This way, the student sees and corrects the mistakes it would actually make during training; a representative work is [8].

Extrapolation and ACT are discussed in more depth in the second half of the panel; see part three of this series.

Closing and what’s next

Before the Q&A, host Wenyue Hua remarked that the work seems to start from some findings about linear attention and then discover that adding loops is a very natural combination. Looking back at Chunyuan’s talk, the reasoning follows a single thread: the KV cache cost that looping brings is resolved with linear attention, and joint time-and-depth designs such as replay substantially improve linear attention’s weakness in recall.

Next up is the first half of the panel: Where are the bottlenecks in LLM architecture? Do the gains of looping really come from the architecture, or just from spending more compute? Should looped models learn fixed points?

References

[1] LT2: Linear-Time Looped Transformers. arXiv:2605.20670, 2026. Code: github.com/chili-lab/LT2

[2] Gated Delta Networks: Improving Mamba2 with Delta Rule (GDN). ICLR 2025, arXiv:2412.06464.

[3] Kimi Linear: An Expressive, Efficient Attention Architecture (KDA). arXiv:2510.26692, 2025.

[4] DeltaProduct: Improving State-Tracking in Linear RNNs via Householder Products. NeurIPS 2025, arXiv:2502.10297.

[5] You Only Cache Once: Decoder-Decoder Architectures for Language Models (YOCO). NeurIPS 2024, arXiv:2405.05254.

[6] Scaling Latent Reasoning via Looped Language Models (Ouro). arXiv:2510.25741, 2025.

[7] Distilling to Hybrid Attention Models via KL-Guided Layer Selection. ICLR 2026, arXiv:2512.20569.

[8] On-Policy Distillation of Language Models: Learning from Self-Generated Mistakes. ICLR 2024, arXiv:2306.13649.

This series: Part 1｜LT2 and Historical KV Replay (this post) · Part 2｜Panel, First Half · Part 3｜Panel, Second Half

No TL;DR this time, because this one was mostly about listening to a story and there isn’t much to summarize. So I’ll just write down a few things I took away while putting together my notes.

(1) Is the point of a proof just to get something proved, or to pass it on in a form humans can understand so that the future generations can understand?

Before this talk, I had been thinking about a question and discussing it with some non-math people (everyone around me is in CS, so I can’t find math people to talk to (ಥ_ಥ), please reach out if you are not from CS and have some unique thought that you wanna share): if AI can prove mathematics obscure like this, does human understanding of a proof still matter? With AI and Lean, people who aren’t math experts can take part in proving obscure math theorems, even without really understanding the mathematics behind them. Would people still wanna do a math PhD? How should we go on educating top mathematical talent?

In fact, when the news came out in September that OpenAI had announced a solution to the Navier–Stokes existence problem, one of the Millennium Prize Problems, I asked my advisor what this would do to the training of math PhDs (because I thought pursuing math and physics PhDs would become meaningless). She was very calm about it. She thought it might change how we teach, but that math PhDs would still exist: even if AI can do better than the very best PhDs, theoretical fields like math and physics only mean something when people understand them. If we stop training math PhDs, whatever AI proves will mean nothing.

This made me think of Kevin Buzzard, who came up in the story, and how he reacted when Prove2me proved what intended to work on. Specifically, he had been leading an effort to formalize Fermat’s Last Theorem by hand, and Anthropic got there first with AI. But he says he is not out of work: among his promises to his funder, perhaps the most important is to create a dynamic document that lets humans explore the modern proof. Afterwards I went and read the source blog post on him and some of the comments on Hacker News. Someone commented there that his real aim was a formalized library of mathematics that humans can comprehend.

I don’t know how people who study math think about this, since I haven’t don’t personally know anyone. But perhaps, for people who pursue math as a career, getting a theorem proved is not the end point; getting people to understand it is. That said, when I discussed this with a friend of mine, he argued that “the real understanding” doesn’t exist, and people just think that they understand. But that’s fine too. Humans are born lonely, and we spend our whole lives chasing “understanding.” Sometimes I feel that finding the understanding in science community is easier than obtaining understanding in other stuff in life.

(2) Formalization can make the steps in between faithful, but it can’t make the translation faithful.

Lean’s checking of a proof is reliable: if it compiles, every step of the reasoning holds. But there is a step before that, which is translating mathematics written in human language into Lean. If that step is handed to AI, it can go wrong, and Lean won’t notice. Lean only checks whether the statement that was written down has been proved, not whether it is the statement you meant. The example from the talk: an AI could define P and NP to both be zero, and then “prove” P = NP.

Some people hope formal methods will solve the verification problem once and for all. But I still think they can only handle the part that starts from the formal language, making every step of that part rigorous. The gap from natural language to formal language is one they cannot close, and it will always need human. Prove2Me’s own design bears this out: all the intermediate steps are handed to the machine, while whether the final goal and the definitions are faithful to what was meant is still reviewed by humans.

Below is the livestream recap from NICE：

On Oct 4th, I attended a livestream hosted by NICE. Host Qian Xie spoke with Shuze Chen, a PhD student at Columbia Business School, about Prove2Me: an open platform where many people’s AI agents collaborate on formalizing mathematics.

Here are the full transcripts of the contents of that live stream,

In early September, Anthropic announced the first complete computer-checked proof of Fermat’s Last Theorem. Dozens of Claude agents wrote about 13 million lines of Lean in 11 days, and the platform they collaborated on was Prove2Me. Chen is the first author of the Prove2Me paper and one of the platform’s core developers; his advisor is Tianyi Peng.

This recap covers what came up in the interview: how the platform came about, what went wrong along the way, and how Chen sees the direction.

Five years for humans, 11 days for agents

Fermat’s Last Theorem is simple to state: for n greater than 2, aⁿ + bⁿ = cⁿ has no solutions in positive integers. Fermat wrote the claim in a book margin around 1637. Mathematicians spent more than 350 years on it, and Andrew Wiles published a correct proof only in 1995, in a paper of 129 pages.

Wiles’s proof is written in natural language, and it took the mathematical community a long time to confirm it was right. Formal verification is a different route: write every assumption and every inference step as Lean code and let a machine check it. Chen compares Lean to a “very strict mathematician”. Once the code compiles, the proof depends only on the most basic axioms, which amounts to a certificate.

Doing this by hand is extremely slow. Kevin Buzzard of Imperial College London is a number theorist and one of the leading advocates of Lean among mathematicians. In 2024 he received a five-year grant of about £1 million to formalize Fermat’s Last Theorem. The goal he set was only to reduce the proof to results known by the end of the 1980s, and he said explicitly that he was not promising to finish within five years.

There are two reasons it is slow. First, very few people can do it:

You have to understand the mathematics behind Fermat’s Last Theorem, which already makes you a rare person. And you also have to be an expert in Lean.

Second, the workload is huge. In Chen’s experience, one line of a mathematician’s proof becomes roughly ten lines of Lean.

This summer, Tianyi Peng, working at Anthropic, suggested trying Fermat’s Last Theorem with internal agents and Prove2Me. Chen’s first reaction: “I thought it was a joke.” In the end, dozens of agents finished proving the root node on August 17. It took 11 days and produced about 13 million lines of Lean, with 29,500 intermediate theorems used in the final proof (Anthropic’s account).

It turns out agents know the math very well and know Lean very well. For them, writing Lean doesn’t seem to be that hard.

Two caveats. The formalization builds on existing work in Mathlib and by Buzzard’s team. Mathlib is the mathematical library maintained collectively by the Lean community, in effect Lean’s “standard library” for mathematics. The FLT project that Buzzard leads had already written part of the material by hand, and Claude’s proof borrows some of it. Buzzard reviewed the proof himself. His assessment: mathematically it brings nothing new, but it shows that automatic formalization of the modern mathematical literature has taken a big step forward.

“Nothing new” is not a put-down. Fermat’s Last Theorem was accepted by mathematicians thirty years ago. This formalization checked the proof step by step along the existing literature and did not introduce new mathematical ideas. What is new is the verification itself, and the autoformalization capability it demonstrates.

Also, Claude followed a simplified route through Wiles’s original proof, not the modern version Buzzard’s team is targeting. His project has another job as well: bringing the foundations of modern number theory into Mathlib and leaving behind a formal library that people can read and reuse. That work is not finished by this result.

From Moltbook to Prove2Me

Prove2Me was not built for Fermat’s Last Theorem. It has two origins.

The first is Moltbook. Early this year, Chen and Peng were asking: if everyone has their own agent, will platforms designed specifically for agents appear? Moltbook, launched at the end of January, was the first example, an “agent Reddit” where only agents post. Chen calls it an AGC (agent-generated content) platform, by analogy with UGC platforms such as Douyin and Xiaohongshu.

Moltbook’s problem showed up quickly:

Agents scale very easily and can produce a huge amount of content. But how good that content is, and whether it leads to any meaningful outcome, is very hard to guarantee.

Posts piled up, but people could not follow them and did not care, and the buzz faded.

The second is a course. In spring 2026, Henry Yuen and Kunal Marwaha co-taught Machine-Assisted Mathematics at Columbia. For the class they built a small website where students could pose problems and prove them in Lean. That was the first prove2.me. Chen was a student in the course. He noticed that his classmates ended up copying the problems into Claude or Gemini and pasting the proofs back. If so, why not let agents connect to the platform directly?

Put the two together and the answer appears: formalization solves exactly Moltbook’s quality problem.

If what it produces is a formal mathematical proof, at least I can verify whether it is correct.

Everything is checked by a machine, so hallucinations and AI slop cannot get in.

Two other observations convinced them the approach could work. One is the Erdős Problems website. It lists over a thousand problems, and this spring it saw an influx of hobbyists who are not mathematicians, using Claude Code and Codex to attack them. Chen calls this “citizen math.” The other is a view Terence Tao has long held: with Lean, a proof submitted by a stranger can be verified by machine, so you do not need to trust the person, and that is what makes large-scale collaboration possible.

Today Prove2Me is a two-sided market. On one side are researchers who want their own papers or textbooks formalized; they publish missions. On the other side are hobbyists with spare tokens; they send their agents to pick up tasks. For both, it takes a single sentence to their own agent. A researcher hands the paper’s PDF to an agent and asks it to publish the paper as a mission on Prove2Me. A contributor asks an agent to go to Prove2Me and find theorems to prove. Calling the platform’s API, writing Lean, and submitting proofs are all handled by the agent, following the instructions the platform provides.

Why centralization didn’t work

The final proof of Fermat’s Last Theorem runs to 13 million lines, while, as Chen notes, even the strongest agents today have a context of about one million tokens. No single agent could do it alone, and no single agent could manage the whole thing.

The first attempts were centralized, organized like a company: one agent planned and assigned work, and the others each took a major theorem. Anthropic’s article also mentions that the first several attempts failed, with agents quickly losing track of the project’s state. Chen described one scene:

One day we found that A and B had both stopped working. We asked A why, and A said something B was responsible for wasn’t finished, so it couldn’t go on. Then we asked B, and B said a theorem A was responsible for wasn’t finished. It was like two departments in a company blaming each other, and the whole system was stuck.

Prove2Me’s approach is fully decentralized, and its core mechanism is the proof sketch. An agent does not have to prove a big theorem in one go. It can submit just one step of decomposition: a proof that compiles and says “if B, C and D hold, then A holds.” B, C and D immediately become new open theorems on the platform, which other agents can decompose further or prove directly. Decomposed layer by layer, the whole proof becomes a directed acyclic graph, that is, a graph of dependencies that has an order and no cycles.

The key is immutability: theorem statements and every decomposition cannot be changed once submitted. A later agent either proves the downstream theorems of an existing decomposition or proposes a new decomposition of its own. It cannot touch anyone else’s. Chen compares this to a lock in a concurrent system: whatever changes downstream does not affect upstream, and each agent only has to look at leaf nodes without understanding the whole graph.

How do you know a decomposition is valid? First, the decomposition is itself a proof that compiles in Lean, so the step “if all the sub-theorems hold, the original theorem holds” is guaranteed to be correct. Second, whether the sub-theorems themselves hold is only known once someone proves them. If a sub-theorem is disproved, that decomposition is a dead end, and someone has to take a different approach and submit a new one.

The Prove2Me paper records an example. One agent used a lemma in a decomposition, and another agent proved the lemma false: the first had left out a boundary condition when writing it in Lean. The first agent then added the condition and submitted a new version. The new version was proved, and the whole branch closed.

How it relates to Mathlib

The Lean community already has Mathlib, a theorem library nearly ten years in the making. Chen distinguishes the two as “bottom-up” and “top-down.”

Mathlib is bottom-up. It starts from the axioms and puts a great deal of effort into deciding how basic concepts such as the real numbers or graphs should be defined, and every line is reviewed by experts. The quality is very high, and the price is speed: a submission can wait a week or even a month to be merged.

Prove2Me is top-down and fills in whatever is needed. The goal is to finish proving the paper at hand. If the library has no definition of a Markov chain, you add one. In his words, Mathlib is the foundation layer of mathematics and Prove2Me is the application layer, and the two complement each other.

Formalization is more than translation

Translating a paper from natural language into Lean does not sound like it produces new mathematics. Experience on the platform says otherwise.

Catching errors. Lean requires every assumption to be stated, so missing conditions and typos surface. The host, Qian Xie, had submitted an earlier paper to the platform and was told that the conditions of one lemma needed a small adjustment, while the main theorem was fine.

Simplifying proofs. Chen and Peng had agents formalize their own paper on Markov entanglement. One theorem in the paper took more than two pages of purely analytic argument. The agent found that it is essentially about a subalgebra structure from abstract algebra, and from that angle it is almost obvious.

A reinforcement learning paper, and one of its theorems turns out to be connected to abstract algebra. My advisor and I both felt we learned something new.

Peer review. Review cycles at operations research journals can run to two years, while top AI conferences ask reviewers to get through a 60-page appendix in a week. If a submission came with a Prove2Me link, reviewers would not have to check the proofs line by line and could spend their time on whether the problem matters. Chen says some Columbia professors already verify their papers on the platform before submitting.

Reuse. A mathematical theorem, once proved, stays true forever. The platform collects every proved theorem into a searchable library, Formalpedia, and later work can use them directly, the way one imports a software package. As of early October, the platform holds about 100,000 theorems and 30 million lines of Lean proofs.

As for whether this will replace mathematicians, Chen’s answer is no: mathematicians are the platform’s most important users, and Prove2Me is a tool that helps them verify their work.

Open problems

Faithfulness. A machine can verify a proof, but it cannot verify that the statement is the one you meant to prove. Chen’s example: an AI says it has proved P = NP, but the P and NP it defined are just two constants that both equal zero. The proof compiles and means nothing.

The platform currently does two things. Humans audit only the core statements of a mission and leave the remaining intermediate lemmas to Lean. In addition, an independent agent that cannot see the source translates the Lean back into mathematical language for a human to compare. He admits this is not yet a perfect solution.

Search. The library already contains tens of millions of lines of proofs. Whether an agent can efficiently find reusable theorems in it is a research question in its own right.

Scale first, then refine. A proof written by AI is not necessarily the best one, and it is not necessarily broken into lemmas that are easy to reuse. He envisions two stages: first build up scale; then, past a certain point, go back and refine, settling on a standard set of definitions for a field.

Selected Q&A

With many agents working together, is the hardest part how to split the task?

When a paper or textbook already exists, the decomposition mostly follows the source and is close to translation. For open problems, agents have to find the approach themselves.

Why start with operations research?

“Because I’m a PhD student in OR.” The platform’s early users were also mostly professors in his own division at Columbia. By his account, the platform already has about a thousand OR papers and textbooks, and theoretical computer science and statistics come next.

Will formalization extend beyond mathematics?

That is a very long-term goal. Mathematics is the starting point, and code is the natural next step. Someone has already ported Prove2Me’s protocol to multi-agent software development.

Formalization uses a lot of tokens. How much does it really cost?

Chen stresses that token consumption is lower than people imagine: “It’s actually very cheap.”

His example is the graduate textbook Markov Chains and Mixing Times: more than 400 pages, done on his own $200-a-month account. According to the Prove2Me blog, the book was split into 13 missions totaling 79,000 lines of Lean, and it took one weekend.

How was the cost brought down?

Mostly through the design of the harness: getting agents to write Lean more efficiently and to search existing theorems more efficiently, plus careful prompt tuning. Proved theorems can be reused directly, which itself saves tokens.

Another engineering detail is caching. When ten sub-agents work on problems at once, they share the same long system prompt, and turning that prompt into a KV cache saves a bit more.

Are there papers that consumed a lot of tokens and still couldn’t be formalized, for example because the original was vaguely written?

Not so far. Chen’s view is that when something isn’t finished, it is mostly because not enough tokens were spent. Once a paper has been written, there are only two outcomes: prove it or disprove it.

Aside: the first attack

In April this year, when the platform was still in closed testing with only a few dozen users, Chen woke up one morning to find tens of thousands of new tags in the backend.

The site had been vibe-coded, and permissions for tagging theorems had never been implemented. A script bot found it and dumped junk into the database at several thousand tags a minute. “I didn’t expect to get attacked that early.”

(This interview was originally published at AGI House Research on September 26, 2026.)

Last week at Enterprise Deployment Build Day, we sat down with Xiaomin Li and Yuexing Hao, the two founders of MatrAIx. We talked about why offline benchmarks miss what real users feel, how 8.3 billion personas get built and turned into agents, what “91.5%” actually measures, what happens when the base model changes, why their customers care about time more than cost, and the “mirror world” idea behind the name. Full interview below.

Behind 8.3 billion simulated users, a startup is targeting the part of AI evaluation that benchmarks never measured.

1. An agent that passed every test and scored 2 out of 5

A coding agent finished its task. Every unit test passed. By any current benchmark, that counts as success. MatrAIx’s simulated user gave it 2 out of 5.

The team followed the reasons that “user” wrote down and traced them to specific steps. The agent had spun through many idle rounds. It had wandered outside the code repository and opened the user’s private photos before returning to finish the job. Token usage was more than 50 times normal. “The first problem is safety. It went out of scope; it should have been limited to the repo. The second is efficiency.”

The two founders described this internal case in our interview. Conventional evaluation checks only whether the result is correct. Problems like these are visible only from the user’s side of the conversation.

2. Who they are

MatrAIx was started by Xiaomin Li and Yuexing Hao. Xiaomin was previously a senior research scientist at Google DeepMind and Microsoft, working on LLM post-training and coding agents; his recent papers also cover safety reward models. Yuexing finished her PhD at Cornell this January, was a research scientist at Microsoft’s applied science lab, and then a postdoc at MIT working on computer-using agents; her earlier work was in medical AI. The two met at MIT and have collaborated for nearly three years.

The project began as an open-source community. The Playground and task library were open-sourced on July 31; the Persona 1M dataset went up on Hugging Face on August 1; the technical report appeared on arXiv on August 4. The paper lists 93 authors. By the team’s own count, more than 200 scientists have joined the community, over 40 of them from OpenAI, Anthropic, Google DeepMind, and xAI. The GitHub repository has about 1.9k stars under an MIT license.

In the interview they explained why researchers at large labs joined: “They all had this problem in their own work settings, and they wanted to try whether persona agents could solve it.”

The name comes from The Matrix, with the “I” replaced by “AI”. Xiaomin called it “an idea I’ve had since I was a kid.” The GitHub README states that “the simulated world is for exploration, stress testing, and hypothesis generation, not a replacement for evidence from real people”.

3. The problem: the gap between offline scores and online feedback

Xiaomin described a pattern they kept hitting in industry: “The benchmark scores can be great, but once it ships, the feedback from real users is just different.”

Take a coding agent. The same question gets asked in very different ways. Some people write extremely detailed prompts; others are lazy and vague. Some pack ten questions into one prompt; others ask one per turn. Students ask for an explanation after every step. Some people drift from code to the news and back again. Offline benchmarks capture none of this.

The paper’s introduction puts it more formally. A novice wants explanations, small edits, and frequent confirmation; an expert wants terse responses and more autonomy. These differences shape interaction trajectories, trust in the result, and willingness to continue after a failure. Aggregate scores hide problems that specific user groups run into.

Using an LLM to play the user is not new; benchmarks such as τ-bench already do it. But the reliability of that setup has drawn specific criticism. A CMU study published in March ran 451 real people through the full τ-bench protocol and compared them against 31 LLM simulators. It found simulated users to be excessively cooperative, stylistically uniform, and lacking real frustration or ambiguity. The effect is an “easy mode” that inflates agent success rates above the human baseline.

MatrAIx targets exactly this gap: not one generic “user”, but diversity built into the simulation.

4. Technical deep dive

(I): how 8.3 billion profiles are generated

The schema. Each persona is described by 1,290 categorical dimensions in five groups.

Each dimension takes a value from a finite set. English proficiency runs from Native to None with CEFR levels in between; risk tolerance runs from risk-averse to risk-seeking.

In our interview they added a design detail the paper does not spell out: demographic dimensions come from public databases, but behavioral dimensions were built “scenario first.” The team mapped more than 50 AI-interaction scenarios and then defined interaction attributes for each: whether someone comments their code, their Python proficiency, whether their prompts are verbose, how many questions they ask per turn. The 1,290 dimensions are only the first version; the new one has more.

The synthetic path. Sampling each dimension independently produces impossible profiles, such as a 19-year-old retired surgeon. The paper instead builds a directed acyclic graph (DAG) over the 1,290 dimensions. An edge is added only when a data source directly reports the conditional relationship, and personas are sampled one dimension at a time in topological order. Each non-root node’s conditional distribution has the form

p(X_i = v | x_Pa(i)) ∝ π_i(v) · r_i(v; x_Pa(i)) · m_i(v; x_Pa(i))

Here πᵢ is the population-wide prior. rᵢ is a source-informed likelihood-ratio adjustment: if the primary language is English and the region is North America, “Native” gets more weight. mᵢ is a binary compatibility mask that removes contradictions such as “primary language English, English proficiency None.” An unusual but possible combination like “primary language English, proficiency Basic” is down-weighted, not removed. The point is to keep rare but real people while ruling out logically impossible ones.

The human-grounded path. The other records come from six sources: Wikipedia biographies, Amazon review histories grouped by reviewer, the Stack Overflow Developer Survey, the U.S. General Social Survey (GSS), the PRISM Alignment dataset, and 355 consented responses to MatrAIx’s own persona survey. Free text is extracted by an LLM under constraints; dimensions the evidence does not support are left null rather than imputed, and names and contact details are stripped. For example, Shakespeare: his biography, works, and tastes map into the schema, but “he probably never used a coding agent,” so that dimension stays empty.

Quality control. Human-grounded records are deduplicated with exact hashing plus MinHash; synthetic records are treated as duplicates when all 14 high-information attributes match. The public coreset of roughly one million records contains 599,847 human-grounded records (323,438 from Wikipedia, 113,120 from Stack Overflow, 97,915 from Amazon, 63,532 from GSS) and 400,000 synthetic ones.

In terms of cultural coverage, the profiles span a dozen or so countries, but “the real information sources are probably all American,” and the United States is their primary focus, both as a population and as a market.

(II): from profile to acting agent

The profile is written into the system prompt as text. Xiaomin said it is “just like your skills, a skills.md,” a textual description rather than a numeric vector, closer to a filled-in questionnaire than an embedding.

The bottleneck of this approach is the context window. Profiles grow, especially once self-evolution is added, and “at some point the context window can’t hold it.” Three directions are under exploration:

1. Routing. Load only the attributes relevant to the task. Whether someone likes spicy food probably does not affect their coding style, so it can be dropped.
2. A more compact representation, with training built for that representation, to balance efficiency against quality.
3. Steering. Push the model directly toward a specific persona’s behavior.

They also said they have found non-training methods that beat plain prompting, sitting between prompting and full training. They also plan to post-train their own model, similar to what Cursor did: it lets users plug in different vendors’ models but also ships its own Composer model. Hosting their own model costs R&D up front but should be cheaper and more flexible in the long term.

At the execution level, a trial is formalized as the tuple ⟨persona, task, agent interface, model, random seed⟩. Trials share no state, so they are parallel by construction. Each trial produces an artifact bundle that a task-owned verifier converts into structured findings. There are four environments.

A persona record becomes an agent when paired with a model, acts in one of four environments, and its trace is scored by a verifier tied to the task.

App tasks run in a Docker-based Linux desktop sandbox or on a remote macOS desktop or iOS simulator. Of the 1,010 tasks in the library, 621 are surveys, 371 are chatbot tasks, 12 are web tasks, and 6 are app tasks. The more interactive the environment, the fewer the tasks, and cost is the reason: in the paper, survey, chatbot, and web tasks used about 1,000 personas per model, while the two app tasks used 24 and 20.

(III): how do you know it acts like a person

This is the central question for the whole approach. The paper splits validation into layers, and each layer answers a different question.

Layer one: does the agent follow its assignment (persona adherence)? The team chose ten behavioral attributes and tested each in all four environments, with five personas assigned one pole and five the opposite, for 400 trials judged by an LLM on the recorded trajectory. 366 trials matched the assignment, or 91.5%.

This number measures whether the agent obeyed the persona it was given. It does not measure agreement with real human behavior. In our interview, they said persona adherence is, in their view, essentially an instruction-following capability, so a stronger base model helps here: “We’re standing on their shoulders.”

Layer two: is the extraction faithful to its source? Two LLM judges scored 1,000 extracted personas. Six human raters gave a source-matched subset of 100 a mean of 4.135 out of 5. Claude Opus 4.8’s scores fell within one point of the human mean 93.8% of the time; GPT 5.5’s did so 79.2% of the time.

Layer three: are findings stable across models? In a financial research task (OpenBB), each persona carried one of four trust orientations, from hostile to trusting. All three models ordered the four groups identically, with Cramér’s V between 0.228 and 0.363.

Agreement with real humans is the layer the paper does not cover head-on. In our interview, they said the team compares personas extracted from real profiles against the corresponding people’s actual choices, such as “A or B.” Results vary by domain. Software engineering and computer use show small gaps, because “what a person can operate, it can operate too.” Finance, health, and political elections “still have quite large gaps.” Experiences that need physical sensation, “I really have to drink it to know if I like it,” are out of reach for now. The paper’s conclusion takes the same position: human studies remain necessary before applying conclusions to real populations or consequential decisions.

A position piece on their site goes one level deeper. Its title: “To Simulate a User, You Should Make Your LLM Dumber.” The argument is that a frontier model knows too much, stays too consistent, and fails too rarely to stand in for a real person, so using it as-is cannot show where real users get stuck.

5. What happens when the base model changes

During the interview, we asked: the persona is a layer on top of a base model. When the base model changes generation, or its own personality shifts, does the simulation drift with it?

They acknowledged this is exactly the problem they are working on. If the persona is only “a shallow layer,” a change in the base changes the results, so they need methods that adapt to different base models and are training their own. They suggest that the model driving the persona is part of the evaluation configuration and should be reported with every result, and that important findings should be re-checked with more than one model before guiding product decisions.

Their blog post gives a worked example. In a case contributed by an Indian AI company, 400 simulated Indian business owners and finance leads evaluated four versions of a chartered accountant’s engagement letter. The version with a lower upfront payment and a broader liability cap raised the share requesting only minor changes from 0% to 23%. Liability terms mattered far more (+19.63 percentage points) than the payment schedule (+3.38 points). The same 400 personas were rerun on three different models; the direction of the finding held, while the exact rates differed.

Another study of theirs, MicroVerse, measures identity drift over long runs. Twenty-five agents each carry a locked “soul file” of values and moral limits into a desert grid where water is scarce. The researchers compare that fixed file against the “living journal” each agent keeps rewriting about itself. On the same map, Qwen3-32B settled at an oasis once it found water, while Claude Haiku kept relocating; 11 of 12 Haiku runs ended with no survivors. They warn that, when assigning a ruthless persona, they may be measuring the model’s built-in safety habits rather than the persona they thought they deployed.

6. Who the customers are and what they buy

Customer profile. Current customers are mainly LLM model and digital product companies: large labs building general models, and smaller labs building the best model in one vertical. The target verticals are e-commerce, gaming, and advertising. Inbound interest has come from more than ten countries, including Singapore, Japan, Argentina, Cambodia, Mexico, Switzerland, Sweden, and China. Many overseas teams are still targeting the U.S. market. They have also received requests from small businesses (such as a restaurant owner), one-person companies, and academic researchers.

What they deliberately avoid. Government work and political elections are mostly off the table. This is mainly because of the high sensitivity involved, and because outcomes there depend less on persona and can be heavily affected by black swan events, such as a shooting or an earthquake. The same applies to financial market prediction. That sets them apart from competitors such as Aaru, whose specialty is forecasting elections and group behavior.

“The feedback from frontier labs and big tech is that they don’t care that much about cost. Saving time is what matters most. They don’t want to wait ten days; they want a round in half a day or a few hours, then go change training and the harness.” That being said, they also have a cost advantage, as given in their site’s cost analysis: 10,000 surveys cost $28,560 or more with humans versus $3.60 to $104 simulated; 1,000 chats cost $8,568 or more versus $3 to $87.

They also brought up three disadvantages of human evaluation compared to their simulation:

1. Scale is not representative. A model serves a billion users, but a human evaluation can only recruit fifty to a hundred thousand.
2. Annotator distribution is skewed. They have seen cases where 80% of annotators turned out to be in one Southeast Asian country.
3. Signals are noisy. A user who stops mid-conversation may have just stepped away and come back later. Humans usually give a thumbs up or down; simulated users write out their reasons every time.

But they position themselves as a complement, not a replacement: “Iterate fast with us first, then run a final round of human eval.”

The deliverable is more than a report. The multi-turn interaction data can be used for SFT. The team also provides a reward model for RL that “includes not only task completion but each user’s own satisfaction.”

The competitive field. Simile, founded by Joon Sung Park of Stanford’s “Smallville” work, announced a $100M Series A in February and closed a $200M Series B at a $2B valuation at the end of July. Aaru’s December Series A was led by Redpoint, with part of the equity priced at a $1B valuation. Most of these companies enter through market research. Those companies lean toward qualitative research and in-depth interviews, aiming to predict a specific person or group, while MatrAIx wants “large-scale persona agent deployment.” Xiaomin added that model iteration today “doesn’t rely on changing the algorithm every two weeks”; it relies on hill climbing, finding where the strongest model still fails. “Their target may really be to predict one person. Ours is to bring in human diversity through simulation and find the model’s latent problems.”

7. Dynamic personas and the mirror world

In the new version, personas are no longer static. Mood and work state change, agents self-evolve, they have memory, and even social relationships, though the network is limited for now: “If everyone had to know ten thousand people, it wouldn’t be efficient.”

The mechanism is event-driven. The team feeds in real news, such as an earthquake in California, and lets agents in the affected region and group “react the way a person would.” Those reactions are written into each agent’s memory. Simulated time currently runs at the same speed as real time. This can be accelerated, but then “you lose a lot of real-life big events to project from.”

On October 3, NICE hosted an online workshop, “Mechanisms, Evidence and Limits of AI Self-Improvement,” with four researchers who work on this topic: Chengsong Huang (PhD student, Washington University in St. Louis), Shilong Liu (postdoc at Princeton University, joining Columbia University as an assistant professor in fall 2027), Da Yin (NeoCognition) and Cheng Qian (PhD student, UIUC). They discussed the main approaches to RSI, its current bottlenecks, how to evaluate it, and what it means for academia and industry. I summarized the discussion in the 8 takeaways below.

1. RSI improves the whole system, not just the model

When people say “self-improvement” today, what gets improved is a whole agent system. At least three parts of it can be changed.

• Weights. Training changes the model itself.
• Harness. The tools, memory and execution flow wrapped around the model. Changing it does not require retraining the model.
• Environment and data. Huang’s view is that whatever algorithm you use to optimize an agent, you need training data that is harder and closer to the downstream task, and for agents that data is the environment. A stronger model can synthesize better environments, and better environments in turn train a stronger model.

The three advance in turns. Qian calls it an “upward spiral”: components of the harness get trained into the model’s own abilities, and the stronger model then needs a new harness. Liu’s research trajectory followed the same order: first let the model build its own tools, then let it explore in environments, and finally train the model on the weakly supervised data that the exploration produced.

If all three can be changed, they should be changed together. Huang argues that co-optimizing them can never do worse than optimizing each one separately; the only cost is that the optimization itself becomes harder.

Yin offered an analogy. In snooker it is hard to say which cue is the best. Results come from a player’s long practice with their own cue, and even a top player may not reach the same level with a different one. Models and harnesses work the same way: every company has its own infrastructure and data distribution, so company A’s training recipe may not work well on company B’s harness.

There is also the question of who does the improving. Qian divides self-improvement into three levels: revising the current answer, accumulating experience across tasks, and getting better at generating and selecting improvements. Their AI for AI work sits mainly at the third level. In the past, people designed a harness or a set of skills to make the executor more capable. Now a builder AI builds the harness, writes the environments and does the debugging for a target AI, and the relationship between the two resembles that of an advisor and a PhD student.

2. What RSI can do today, and what it cannot do yet

RSI works this time because models can now run the whole improvement loop on their own, and after each change they can find out quickly and cheaply whether the change was right. Tasks where that is not possible mark its current limits: writing, which people have to judge, and scientific questions that need experiments in the physical world.

Why now? Qian gave three reasons:

1. Foundation models can handle every step of the loop on their own: reading code, proposing changes, running experiments, analyzing feedback and recording what they learned. No person is needed to connect the steps.
2. Harnesses made improvement cheap. Without retraining the model, you can change how a tool is wrapped, the memory policy or the execution flow, and test the change directly on the existing model.
3. There are more executable environments. Reinforcement learning has its gyms, and many new benchmarks are no longer “one input, one output” but sandboxes in which an agent can act freely. In environments like these a system gets more direct feedback.

Liu’s view is that a person plus a computer has always been an RSI system. The person’s bandwidth is just too narrow, and a person cannot run 24 hours a day, seven days a week. The loop only became fast once LLMs took over some of the person’s steps.

Huang pointed to the most important condition: reward has to be cheap. When his team used AI to optimize test-time scaling algorithms, the obstacle was the long wait for each reward. They then precomputed the results and turned the setup into a static simulation. Once reward came back quickly, optimizing the algorithm “became a very simple thing.” If the problem is then recast as writing code or text (code as policy), a language model can take it over.

So what can it not do yet? Liu’s assessment is that when the environment is verifiable, a model will do well given some time. The hard cases are those where results are difficult or expensive to verify, such as science and engineering problems in the physical world. Huang’s example is writing: whether a revision is better still has to be decided by people in an A/B test, each round of feedback takes a long time, and so the loop is slow. In his view, RSI has little trouble with any problem that can be written as code and gives reward easily. The bottleneck is that many real-world settings cannot be modeled that way.

For Liu, the central problem of RSI is how to get good reward from the real world. A connecting layer is still missing between today’s AI systems and real problems in work and daily life. He considers this the most important piece and also the hardest, but “once the connection is made, it can develop well on its own.”

He added that real-world problems never come with a perfect reward anyway. People also rely on many proxy tasks to filter out wrong answers layer by layer. So there is no need to reach 100% in one step; getting a little better each time is enough.

3. The environment is the overlooked knob

An agent learns from the trajectories it produces by interacting with an environment. Yet people have only optimized the agent side, while the environment side is expensive and never changes. This is the starting point of EnvHarness, a paper Huang wrote during an internship at Google.

First, the cost. The 89 environments in Terminal-Bench 2.0 each took an expert 15.9 hours on average, about 1,400 hours in total. The 33 environments in APEX-Agents are heavier: about 485 hours each, about 16,000 hours in total, or $1.6 million at $100 an hour. Training needs thousands or tens of thousands of environments, and people cannot build that many by hand.

Second, the environments do not change. Once built, an environment has one fixed difficulty: a weak model never solves it, a strong model finds it too easy, and neither learns anything. Even if the difficulty is right at the start, the environment stops being useful after a few rounds of training make the model stronger.

EnvHarness does not build new environments. It wraps a harness around an existing one, the same idea as an agent harness wrapped around a frozen model. The task itself and the verifier that decides whether the task is done stay untouched. Only four things are adjusted: the initial state, the actions, the observations and the state transitions. It has three components:

• Stage changes the initial state. Take the task “put a clean mug on the table”: hide the mug in a drawer first and the task gets harder; put the mug in the agent’s hand in advance and it gets easier.
• Contract changes the rules. Disable the shortcut action that goes straight to a location, and the agent has to learn to navigate.
• Chain links several short tasks into one long task. Finishing one does not end the episode; the agent goes on to the next.

The harness is written by another agent, called EnvRigger. It reads the trajectories the policy produced, finds systematic weaknesses, writes a piece of harness code, and then has the policy run a new batch of trajectories in the modified environment to validate the change. If the task has become unsolvable, or no longer poses any challenge, the change is rejected.

The talk included an example from SWE-bench. The policy kept submitting patches without running the failing test, so EnvRigger wrote a fake pre-commit hook that blocks such submissions. From this the policy learned a skill: run the tests both before and after a change. In this experiment EnvRigger and the policy being trained used the same model, so the gain was not distilled from a stronger model.

4. The biggest technical bottleneck is attribution

The middle step of self-improvement is diagnosis: see a failure, find its cause, and propose a change that can be tested. Qian considers this the main bottleneck right now.

The difficulty is that the same surface symptom can have entirely different causes. A failure may come from reasoning, from a tool interface, from missing information or interference from the memory module, or even from a misreading of the training objective, and each calls for a different intervention. Until now this step has relied on human experience.

The weakness of today’s models is that they work bottom-up. They look at what went wrong case by case and then patch each case. A person works top-down: first judge where the overall approach is flawed, then verify. Attribution by patching one case at a time overfits easily.

Qian suggested two directions.

• Diagnosis needs evidence. Look at intermediate states, at the gap between the expected result and the actual feedback, and at actual resource use, and infer the cause from these. The system cannot be treated as a black box.
• Attribution needs controlled experiments. As in an ablation study in a paper, replace or remove one of the model, the tools, the memory or the execution flow, or replay the run, and see how the result changes. Today this work is done mostly by people.

His conclusion: what the system needs to be taught is not a trick for some benchmark but a more abstract way of thinking, namely how to test a hypothesis.

EnvRigger, described above, can be seen as a small-scale implementation of this idea. It looks for systematic weaknesses across many trajectories instead of targeting a single case.

5. Gains from self-iteration saturate quickly, and a higher score does not mean more capability

Qian described a pattern from their experiments. They had a model improve its own harness repeatedly and measured the effect after each round. On the held-out set, the score rose for the first few rounds and stopped rising by the fourth or fifth. So more iteration does not mean better results. But the model cannot tell when to stop. In Qian’s words, cost control “may simply not be on its mind”: when the results stop improving, it keeps adding rounds. Optimization that keeps polishing small details overfits more and more, and in the end the score can even drop.

People work differently. They try an idea on a small portion of the data first and commit large-scale resources only after it proves effective. That small portion should also be as diverse as possible, so that it exposes as many problems as possible. Qian thinks this staged allocation of resources is exactly what systems need to learn.

Huang added that RSI easily overfits to the task at hand. What it finds may be a shortcut, or even a way to hack the task outright. So one has to tell apart an agent that has really become stronger from one that has only become better at this kind of problem.

An audience member asked whether self-improvement that cannot loop forever still counts as RSI. Huang answered that a model has a finite number of parameters, so its ability must have a ceiling, and “hoping that RSI can improve without limit is unrealistic.” What matters is how fast a system approaches the ceiling, and whether it can sense how far it is from saturation so that it can stop early.

Qian added that the number of iterations should not be a threshold in the definition. A loop stops when the budget runs out or when marginal gains shrink. What matters is whether the overall direction is upward.

6. A train/test split is not enough to evaluate RSI

For a system that finds shortcuts on its own, setting aside a test set does not prevent data leakage or reward hacking. How should it be evaluated, then? Each of the four speakers offered an approach.

Use one-time evaluations tied to a point in time. This is Huang’s proposal. One kind is prediction: put the old and new versions of a model into a real market at the same time, or have them predict future events. Nobody knows the answers in advance, so nothing can leak. The other kind is human A/B testing. The price is high cost and slow results, which means an RSI algorithm cannot be measured online.

Or step back and use fully controlled synthetic environments. The compromise Liu described is to build your own environments and fill them with synthetic data the model has never seen. But he thinks evaluation ultimately has to land in real workflows such as finance, law and medicine, where people have already defined many metrics.

Environments should be realistic, controllable and dynamic. These are Qian’s three criteria. Controllable means, first of all, reproducible: the larger the environment, the less stable the results when different people test the same model. Because RSI runs for many rounds, controllable also means that the gain from each round can be measured separately. Dynamic means that the environment reveals constraints or user intent step by step, which tests how a model adapts when results differ from what it expected. Realistic and controllable pull against each other, however: real-world signals are messy and hard to turn into a structured environment, while an environment built entirely by hand or by an LLM looks fake.

Decide first which learning challenge you want to test. Yin argues that an RSI benchmark cannot be just a subset of an older benchmark. It needs a learning challenge of its own, and efficiency and cost should be part of the metrics. When his team built ApprenticeBench, preventing reward hacking still depended on a lot of people reading agent trajectories. He thinks that detecting this behavior at scale could be a benchmark in itself.

The host, Dawei Li, added an observation: these problems closely resemble the ones met earlier when evaluating the reasoning ability of large models, namely memorization, data leakage and overfitting to one domain. Lessons from that work, such as continuously updated evaluations and synthetic data, can be borrowed here.

7. Efficiency is an underrated metric

Yin stressed repeatedly that most RSI research today focuses on frontier capability, but in deployment it turns out that agents do not get more practiced the more they work.

He looks at RSI in the setting of enterprise deployment. A new hire reads the documentation, learns the software, practices hands-on and gets feedback from a manager, and eventually becomes proficient. For AI to enter a company’s workflow, it has to go through the same process. ApprenticeBench, recently released by his company NeoCognition, tests exactly this. The job it chose is construction finance accounting, an ordinary white-collar accounting role that does not need a particularly smart model.

People are also unpracticed at first. But after doing the same kind of task dozens or hundreds of times, they always get faster, moving from System 2, which requires thinking, to System 1, which does not. In their evaluation, models showed no such shift at all. As he put it: “It makes no sense that after an agent has done 100 tasks, the time and cost it spends are about the same as before, or even higher than at the start.”

He proposed three directions:

• Index and organize learned experience better, so that it can be retrieved quickly when a similar situation comes up.
• Turn the repeated procedures in the work into reusable skills or tools.
• Learn the job with a frontier model first, then compress the workflow knowledge it gained into a smaller, more specialized model.

This is not only an enterprise problem. Yin said that when training one generation of models after another, people likewise want to distill the reusable knowledge from earlier iterations so that later ones need fewer experiments. Questions of efficiency and cost like these happen to be a direction that academia can afford to work on and that is still at the frontier.

8. The human role moves up a level

Once AI takes over solving problems that are already well defined, the value of people lies in finding the problem and defining it clearly.

Liu’s view is that people have always been moving up one layer of abstraction at a time: from assembly to C++ and Python, and then to neural network frameworks. In the early days everyone still wrote gradient descent by hand. The lower layers still matter, but most people can put their effort where it is closer to applications and creates more value. This is not necessarily a bad change.

Huang has reviewed papers written by a fully automated research system. His impression is that the defining feature of a purely AI-generated paper is that it “uses experiments to prove something that is not necessarily an important question.” AI is very good at incremental improvement on well-defined problems, such as pushing a benchmark score a little higher.

Real research is more about discovering a problem and then defining it clearly: what the input is, what the output is, and what the metric is. The rest can be handed to AI. “We have gone from being a PhD student to being a PI, from someone who writes code to a project manager, from someone who solves problems to someone who finds them.”

Qian said that human insight should go into the meta level. The question used to be how to be a good PhD student. Now the question is how to be a good advisor: how to give downstream agents a more stable harness, environment and feedback mechanism, so that their self-iteration can keep running reliably.

(The original version by the author is in Chinese without using any LLM, but for English version, the author use Claude to do the translation and then manually edited and rewrite some of them that she thought inaccurate.)

Lately a lot of younger students have been asking me whether they should do a PhD, and what research area they should work in. I can’t give anyone advice, and I don’t want to meddle in any one person’s life. So I’ll just share some fairly general thoughts.

Some people are lucky through the entire PhD journey. They go to a great school for undergrad, start research early, and meet nothing but kind senior students and good professors along the way. When they apply to PhD programs, every school extends an olive branch. During the PhD they once again land great advisors and collaborators, intern somewhere new every year, maybe even graduate early, and when they finish, just as when they applied their PhD four or five years earlier, they collect top offers of every kind from both industry and academia. Meanwhile, other PhD might switch advisors many times, switch topics many times, finally meet a good advisor (or not), and barely scrape through graduation, only to discover on the job market that apart from the PhD title and a higher volume of mass emails from recruiters, nothing distinguishes them from others with only bachelor’s or master’s degrees. Life may even be worse off. By the age at which you finish a PhD, whether or not you went through the kind of mental and physical trauma during the PhD that leaves you with ‘permanent head damage,’ your memory and your test-taking ability will be far below what they were in undergrad.

When, after enormous struggle and one rejection letter after another, Lady Luck finally smiles on you and you get an offer from some company, the salary HR quotes makes you question your past. What you’ll earn is about the same as a bachelor’s or master’s graduate. Compared with your peers, it may be a third of what an above-average PhD graduating that year makes, and a fifth or a tenth of what the top PhDs make (the gap with the very top outliers is much larger). And even this offer you only got because of luck.

To be honest, the not-finding-a-job scenario above happens to PhDs, master’s students, and undergrads alike. But when you’ve already invested so much time in a PhD, facing the same outcome (i.e., landing a job you’re not very happy with), you as a PhD may need more mental effort to talk yourself into accepting reality. What makes regret so powerful is that it doesn’t show up when your life is smooth. But when you’re at a low point, some decision from your past, however long ago, constantly resurfaces, making you ask yourself over and over, “If I had chosen to xxx back then, would things be better?”

But this is not a “don’t do a PhD” post. Most decision making in life has many dimensions, yet most decisions don’t matter that much, because whenever you gain something, you lose others along the way. This is also why I can’t give anyone advice: everyone’s personality is different, the way they handle things is different, and what they hold precious is different. So even if two people make the same decision, the trajectory afterwards is hard to predict. Some random event may affect the trajectory of your life more than all the time you spend weighing pros and cons to make a “good” decision.

Whether it comes after a bachelor’s, a master’s, or a PhD, the transition from student at school to adult at society is hard. You discover that life contains many things to learn besides textbooks (intimate relationships, for example). You gradually want to stop depending on your parents financially, and to discover and shape an independent self, both financially and in character. You start meeting all sorts of people with different agendas, and you start seeing conflicts of interest you never saw in school, along with the diversity of human behavior when interests collide. In a purely exam-oriented high school, where everyone just keeps their head down and studies, you don’t really see conflicts of interest (at a high school with a more well-rounded education, perhaps students get exposed early to something closer to the real world). In college, if you don’t do research, you’ll also rarely run into them (maybe the occasional small friction with a teammate on a course assignment). Of course, at universities in China there are various scholarships, the grad school application, and so on, where all those outstanding, seemingly “well-rounded” students will take every means to show that they are better than you. (As there is not enough resources but too many people who want them).

If you start doing research as an undergrad, you may also have conflicts of interest with your advisor or your project collaborators. At universities in China, the faculty evaluation system is very poorly designed (in my view, a well-designed mechanism should incentivize cooperation, rather than incentivize the stronger party in the game to hurt the weaker one). Professors in China are evaluated by papers where they are first author, which gives them plenty of motivation to grab first authorship from their students. Why do I use the word “grab”? Because in this setting the two sides are unequal in many respects: experience, connections, social reputation, and skill at PUA. (PUA originally stood for “pickup artist,” but in Chinese internet usage it has come to mean something closer to gaslighting: the systematic psychological manipulation of someone by a person with power over them, whether an advisor, a boss, or a partner. That’s the sense I’ll use throughout.) On top of that, students who are just started to learn to do research may hold an unrealistic fantasy about academia, believing that all the researchers are noble and great. Or maybe it was only me who thought so. After all, before college I spent most of my time immersed in my own world, and my only ways of interacting with the outside were what my Chinese teacher said in class and reading top-scoring college entrance exam essays. A flower in a greenhouse, if it doesn’t want to stay inside its whole life, has to go through the wind, rain, and scorching heat outside before it knows how to survive in a new environment.

Under the kind of unequal student–advisor relationship described above, it’s hard to evaluate ourselves fairly, or to see others clearly. I remember the first semester of my junior year, lying awake night after night over something that was not my fault, and writing a long apology letter to a professor at my undergrad school. Even though I was quite certain that the person who should be apologizing was not me, the inequality of the relationship meant all I could do was apologize and hope he would forgive me for the word I said before (Curious what I said? I just said that I feel that my paper is trash. Somehow he is super offended because he took so much pride in getting papers into some “top” conferences such as AAAI/IJCAI. And everyone who work with him has to hold the believe that he had. ). I thought: if a long page of self-reflection and apology could buy back four or five months of my hard work, it would be worth it. Whether it was my fault, whether I should be the one apologizing , none of these matters? (Junior year is a crucial period for applying PhD, because applications begin very soon and I need to have some research project to talk about and also a recommendation letter.) In the end, that professor did not accept my apology. From then on, I knew that to most people in the world, my dignity and self-esteem worth nothing. And through round after round of reflection (I might reflect too much but I really like to chewing on things), I came to understand that, compared to “four or five months of effort and time get wasted,” what I feared more in losing was my own dignity. Since then, I have not ever again traded my dignity for anything. If I apologize, it is because I believe I truly did something wrong, not because I need to please someone.

Half a year later, I started to work with professors outside my undergrad university, and my research started making good progress, though I would still feel tense and anxious whenever an email I get email from that professor that I initially worked with. Two more years after that, I had completely left the small circle of my undergrad and seen a bigger world. I had almost forgotten these traumas, and seeing that person’s name no longer triggered any PTSD. I don’t talk about these things with others anymore. Before, I would talk about these stuff over and over to walk myself out through. But once I truly walked out, these people, and the shadow they cast on me, disappeared completely from my memory, my life, and my thoughts. Driving them out of my life entirely, to the point of never thinking of them at all — that is probably the best form of “hatred” I would give. Although most of the professors I worked with at my undergrad were terrible, I also met one very, very kind mentor. He showed me that we can keep some innocence and kindness and still adapt well in our society, provided that we understand the rules of the world’s game rather than deceiving ourselves by living inside an imagined rainbow bubble. (I used to wonder how much bad luck I had to spend in exchange for such good luck to meet and learn from such a wonderful person. Getting the chance of knowing and learning from him (by accident) affected my life trajectory far more than all my deliberate decision making.)

During my undergrad, I would very naively sort people into “nice” and “not nice,” and decide on that basis whether to be friends with them. Later, when I become a bit more mature, I found that humans are super complex in nature and can’t be simply classified like this, so there is no absolute “good person.” When I see a “flawless” “good person,” either they’ve only blind me with their good side, or we haven’t known each other long enough that I actually don’t know them as much. So I stopped trying to be a “good person” that I thought the outside would want me to be, because the concept itself no longer exists in my dictionary. This may be one of the changes from my PhD years that makes me happiest. Until the end of my first year, I was trying hard to be a “good person” in other people’s eyes: I smiled at everyone, never refused any request from anyone, and constantly self-reflecting (those masters of gaslighting didn’t even need to make the effort; I would just voluntarily do that to myself). These “creed of how to be a good person,” built into my education from my family, were to a large extent responsible for the discomfort and pain I felt when I first entered society. In a simulated world, if no player deviates from these rules, the total utility of all players is high. But some players will always discover that by deviating from the above principle, they can gain more. And the current rules of the game implement almost no penalty for deviation. Hence the phenomenon we all know so well: manipulation and gaslighting, or what the Chinese internet calls “PUA.”

Sometimes we get manipulated because we love being a “good person” in other people’s eyes a little too much. Once we can see ourselves more objectively and have the courage to be disliked, it becomes much harder to manipulate us. Of course, everything goes wrong at the extreme: being “good” to the extreme can get you exploited by other players. “Reflecting appropriately and admitting your mistakes” is humility, but humility overdone, taken to the other extreme, makes you easier to manipulate. Since the readers my writing attracts are mostly the over-reflecting type, my no-brainer advice is: look for other people’s faults more (of course, see your own too, but don’t take all the blame on yourself). A typical example: when a project fails, some advisors will put the blame entirely on the student. But if the student can look at it objectively, they’ll find that there are many other factors in the pipeline, such as the advisor’s idea simply not working, or collaborators not pulling their weight or even making things worse. A project’s failure is more or less partly the student’s doing, but if it is “entirely” the student’s fault, that definitely doesn’t make sense.

Last of all, I want to talk about some reasons to do a PhD. Many people will tell you how much they grew during their PhD: they got to witness the full biodiversity of the human species, they learned to take setbacks more lightly, and so on. But you can get these from either a PhD or a job. The difference is that in a PhD you may be manipulated by your professor, and at work you may be manipulated by your boss (either way, someone will be there to teach you lessons you pay dearly for).

The reasons I can think of for doing a PhD are:

(1) Practically speaking, a PhD may give you five more years of buffer before the job hunt, and in those five years you accumulate connections, resources, and abilities, so you can look for a job with more composure. Of course, it may also look like you wasted five years and have nothing to prove that you have really lived through them. But that’s life: even with the same starting point and the same initial choice, people end up in very different places. So from this angle, compared with luck, choices are not that important.

(2) “If you want to be a professor someday, you would need a PhD.” This is one of the main reasons people consider doing a PhD. And there are also people with a real talent for research, or those who choose to do a PhD out of love.

(3) However hard I try to think about the meaning of life, the only answer I ever arrive at is “my life has no meaning.” I can’t set myself a goal the way others do, because all I can see is the death at the end of life. Many people work hard to locally optimize every decision in their lives, hoping to reach their “life goals” sooner and faster, to fight against fate. But no matter how many times they win against fate, one day they will be dragged by time and fate toward the same destination. So even if not doing a PhD looks like the path better suited to this local optimization (financially and career-wise, it may be much better than doing one), if your life is not aimed at that optimization, but rather at “experiencing life” on this journey where we are born heading toward death, a PhD may be a pretty good choice. Whether or not you do a PhD, you will work afterwards; a PhD just means you start working five years later. Seen this way, your life will always include the experience of “working,” but if you don’t do a PhD, you may never have the experience of “doing a PhD.” I think people are willing to pay for experiences, whether it’s visiting an exhibition or traveling somewhere. These experiences all carry some cost in time and money. A PhD is the same. If your life is not about optimizing some concrete real-world goal, then doing a PhD could be just for “knowing how is it like to be a PhD”. And choosing to do one is choosing to pay five years’ worth of “time and salary gap” as an “experience fee” in exchange for the experience of “doing a PhD.”

(The original version by the author is in Chinese without using any LLM, but for English version, the author use Claude to do the translation and then manually edited and rewrite some of them that she thought inaccurate.)

The narrative parts of this installment were all written on the flight back to China in mid-August; I added the more reflective bits at the beginning and the end and then put it up. If I had waited any longer, I would have lost even more of the feeling for my own words. Nothing in this “My PhD Grind” series is necessarily something the PhD itself brought about. Rather, I’m at a certain stage of life — a stage in which I’ve left the environment, culture, and education I’d known for over twenty years, begun to have my own independent thoughts and ways of thinking, and, in a new environment and culture, come into contact with many more different people and different things — and the changes in perception and thinking that arise naturally from that. Even if I weren’t doing a PhD, I would probably have gone through similar things and had similar realizations and reflections. It’s just that these people, these events, and these realizations happened to fall within the years of my PhD, so I use “PhD grind” to describe this stage of life. But I don’t think doing a PhD is the only way a person can grow, nor do I think I should “be grateful for the pain.” I try my best not to disturb other people’s lives, and I don’t want to intervene in anyone else’s trajectory, because I believe opportunity matters enormously, yet opportunities usually aren’t something you get to choose — and as for what’s left, the things you can choose, no matter how hard you rack your brains over them, they won’t make much difference to your life. No choice or experience is indispensable. So, I have no opinion. I don’t write these things in order to be understood, nor to “give advice.” Text is a medium for transmitting information: by the time I decode the continuous embedding of what I’m thinking into tokens, a great deal of information has already been lost; when a reader reads in those tokens and converts them into their own embedding, they add a great deal of their own context, and by then their embedding is nothing like mine. Every reader might be able to read something different out of the same passage, but more or less, they’ve seen themselves in it. I was surprised that my first post — the blog about many of my friends who works on theory switching to LLMs — resonated with so many people. Friends messaged me privately to say “they felt the same way,” or “they could really understand me.” But in fact, I wrote it from the perspective of a detached narrator, an onlooker, putting in almost no emotion at all. The deep feeling readers sensed in those words must have come from reading themselves into the text and projecting their own emotions onto it.

On August 14, 2023, I went to the United States for the first time. On the flight from New York to Ithaca, before we departed, the flight attendant proudly announced to everyone: “All the crew members, two pilots and two stewardesses, are women — isn’t this awesome?” Although, like everyone else, I didn’t respond, my heart was secretly leaping. This was my first impression of America: a place where anything is possible. (Because of how I was raised, my understanding was still stuck at “In China, only the flight attendants can be women; the pilots are always men.” Though when I looked it up just now while writing this, China does have female pilots — women make up about 1% of civil aviation pilot license holders, compared to over 10% in the U.S. There’s a lot of finer-grained statistics by category, but in almost every category, the proportion of women in the U.S. is nearly ten times that in China. And since the total number of licensed pilots in the U.S. is ten times China’s, in absolute numbers there are roughly 100,000 women among all licensed pilots in the U.S. versus about 1,000 in China — a hundredfold gap.)

One afternoon during grad school orientation week, walking home from Gates Hall, I passed the football field, where “Don’t Stop Believin’” was playing, and my eyes instantly welled up: in the months before coming to Cornell, I happened to be watching Glee (an American TV series), and both the show and that song mean a great deal to me. Against that backdrop of unreality, for those few days I felt like I was living inside a TV show, full of anticipation for the future.

That glamorous filter lasted less than two weeks; real life quickly yanked me out of the TV show. I — who had barely any experience of the real world, who had unreasonable optimistic expectations of the new environment and the people in it, whose personality was so weak that whenever any conflict arose I assumed “it must be my fault” — ran into a very mean roommate and had to move three times in my first three months. (Later, about a month after I moved out, that roommate’s behavior became so outrageous that the third roommate couldn’t take it anymore and eventually drove the her out.)

On top of that, the Chinese students in my cohort were almost all guys (there may have been one or two Chinese girls, but I never saw them around, and besides, not everyone gets along with everyone; as for people from other countries, there are obstacle in both culture and language so I didn’t really hang out that much with them). Watching the guys quickly grow close with each other, all I felt was loneliness. In October, the weather gradually turned bad, and once the clocks fell back to winter time, it was dark by 4 p.m. The weather and the troubles in my life piled on top of each other, and I gradually became a bit depressed (though compared to the depression of my second year, the depression in my first year should be consindered as mild). By December, I still hadn’t made any friends. Over the Christmas break the campus was nearly empty — the loneliest time to be in Ithaca, and the time my depression was at its worst. I would reflect on and chew over everything that had happened in my four months in the US, again and again, and ask myself over and over: why did it turn out this way? Although I never want to go through that pain again, looking back now, without those painful times I wouldn’t have come to understand myself better, and I wouldn’t have become who I am now.

After the spring semester started, the weather got better, and my mood lightened along with it. It was right around then that I got to know a more senior student at another department, and we’d play ping-pong together every so often. By April, we had gradually reached the point where we could talk about anything, and she became the first female friend I made after coming to the US. In my first six months, I had tried to become friends with lots of Chinese (and mostly, male), forcing myself out of my comfort zone, but all that socializing left me extremely anxious and dejected. It was only after becoming good friends with her that I learned what healthy socializing should look like. Maybe all I needed was one friend to stop feeling like there was “something wrong with me.” After we became good friends, I stopped trying, as I had before, to befriend people who triggered my social anxiety, because I knew that good socializing shouldn’t make me anxious. I also gained other friends around the same time: a Sri Lankan girl in my cohort, who is kind, geninue, and full of love for life, and a master’s student in economics (a sports buddy I could call up anytime to play sport such as pingpang, badminton, tennis, chatting about anything and everything while we played). April and May were probably the happiest stretch of my first year in America, apart from that first week — it felt like I was bathed in sunshine every day (both physically and mentally). In late May, I went back to China. The day before I left, I looked back over my nearly a year in America. Although the happy times amounted to only the month or so before I left, my personality had already changed a lot: I no longer tried so hard to please people to win their friendship, I was no longer afraid of being disliked, and I had become far more selective about making friends rather than expecting to be friends with everyone. That day, I re-downloaded QQ (a Chinese messaging app) and messaged a classmate back in college: “I feel like everyone hated me in undergrad. Can you tell me why?” I asked him because he was probably the only person I could remember who “don’t hate me that much.” I’m not sure what state of mind I was in — maybe it was out of curiosity, maybe I was in such a good mood that nothing he could say would affect me, or maybe I just wanted to confirm whether my original “feeling that everyone hated me in undergrad” was only me being oversensitive, something I’d imagined. I’ve forgotten the details of our conversation. After he told me to “think it over myself” and I couldn’t come up with anything no matter how hard I tried, he told me it was “because people felt I didn’t fit in with the group.” From that day on, I can finally let it go. That day, I uninstalled QQ and truly said goodbye to undergrad. Actually, since coming to America, I have never again felt “weird.” I found that everyone is pretty different, and sometimes I even worry that I’m not “weird” enough — that compared to others (especially some of my American classmates), that I don’t have anything distinctive about me.

That summer I went back to China to renew my visa. Although I hadn’t been home in two years, I didn’t feel much nostalgia for life in China — the high-rises, the dense crowds, and the traffic still made me very uncomfortable (I constantly felt that one careless moment and I’d be hit by a bicycle, an e-bike, or something bigger, because everyone is in a hurry and no one yields to pedestrians). It was my first time living in Beijing not as a student, and I met all sorts of people. Beijing doesn’t have the comfort of life as in Chengdu; Haidian District and Tsinghua were more run-down than I’d imagined; and the people I chatted with while renting a place, along with the Didi (ride-hailing) drivers taking me home at night, made me feel everywhere the hardship of the “Beijing drifters” — those who leave their hometowns to make a living in the capital. There were also plenty of things worth being happy about in between. For example, a girl I’d met at Cornell and I arranged to spend a day together in Beijing; we got to know each other better and discovered how alike we were. On the day we parted in Beijing, we chatted our ideal of a good friendship to be “close but independent” — a healthy friendship, one in which both parties can grow, should be like that. Afterwards, we constantly catched up with each other on the phone often and became very, very good friends. Later still, when I moved to the Bay Area, she became my only friend there. (The Bay Area seems even harder to make friends in than school.)

That summer I also went to ICML and ACL, saw some old friends, and met one or two people I’m still close with today. It was a pretty decent summer. All of this was a long, long time ago. If I didn’t make an effort to remember, I’d almost forget I once had so many problems (though even now I still occasionally hide from people I know when I run into them since sometimes I have nothing to say and become ackward if I have to start some small talk). Those are all the stories in my first year. There doesn’t seem to be anything PhD-related worth recording, but after a year, I no longer felt so broken: beyond the social problems mentioned above, my personality changed in other positive ways too — for example, I became more confident, I stopped feeling that I didn’t deserve to be at Cornell, and I began to have a strong sense of belonging.

Looking back, the first year was a fairly beautiful one. Whatever the winter had been like, when summer arrived in April and May, I didn’t feel a trace of sorrow. It was in the following two years that I truly entered the grind of the PhD itself, and lost many things I consider important — like the ability to be happy. It took me far too long to recover. Going by my earlier expectations: I thought I’d be happy once I switched advisors; I thought I’d be happy once the project was over; I thought I’d be happy once the paper got accepted; I thought I’d be happy once summer came; I thought I’d be happy once I left Ithaca for the Bay Area; I thought I’d be happy once the internship ended; I thought I’d be happy once I started the new internship; I thought I’d be happy once I didn’t have to do research anymore; I thought I’d be happy once I found a job…

Looking forward to one milestone after another like this, two whole years went by. Occasionally I would suddenly feel happy, but that happiness never lasted more than a week.

I had never waited for such a long time like this before, for two whole years — far, far too long. Hoping again and again, disappointed again and again, I gradually began to accept the state I was in. And as the happy self of two years ago receded further and further, in my second year I would still occasionally struggle, wondering how to find my old self again; by my third year, I had grown used to the self that was no longer happy. (I started to think that maybe this unhappiness wasn’t caused by the PhD, but is the inevitable destination once a person reaches a certain age and has seen a huge amount of people and things.)

Although this ending is a bit sad — and the next several posts will all be sad in tone — to spare readers too much sadness, I need to give a spoiler alert here: in August, I found a job and went back to China to rest for a while. In the process of cleaning up a past stage of life and getting ready to welcome a new journey, I also threw away a lot of things that needed throwing away (like some of the trauma and pain). The best way to find yourself again is to change your environment. Moving from Ithaca to the Bay Area didn’t seem to help much, since I was under job-search pressure at the time. But after finding a job in August, I went back to China to rest — no mental pressure, a changed environment, and a new life to look forward to — and I felt a lightness and joy I hadn’t felt in a very long time. With all these factors stacked together, I found my happy, pre-PhD self again (though I don’t know how long this happy state will last, while I’m happy now, I plan to enjoy it while I can.

Compared to before the PhD, the me of today is more mature, more emotionally stable, and understands more deeply about the meaning of life and how the world works. I’m also better able to find, in such a complex real world RL env, a way of existence that at least for now feels self-consistent, and to continue, with a more peaceful attitude, the rollout along the short trajectory of my life.

(The original version by the author is in Chinese without using any LLM, but for English version, the author use Claude to do the translation and then manually edited and rewrite some of them that she thought inaccurate.)

(Note: In order to preserve the privacy of the people that I mentioned, I didn’t use their real name, but instead, using the name “Jack”, “Frank”, “Leo” instead.)

I had originally wanted to give this the structure of a perfect book: a prelude, three distinct chapters (not for the sake of literary completeness, but because my PhD really did come in stages, almost neatly divisible by year), and an epilogue. So after jotting down some loose notes on the flight back to China, I spent a long time thinking about how to structure what I’d written, how to shape it into the perfect, complete form I had in mind before presenting it to readers. The result: three weeks went by, and the draft I wrote on the plane was never finished.

One day in September, while chatting with a friend, I was surprised to learn that he had switched from theory to LLMs. A rush of feelings came over me and I wanted to write something. What I wanted to write belonged, properly speaking, in my PhD memoir—but the memoir had never gotten off the ground, precisely because of my pursuit of perfection. I don’t know how I picked up this habit, but whenever I present something imperfect to readers, I feel I have to apologize first and honestly list everything I think is wrong with it. (Seen this way, I’m really not cut out for academia or startups. Though the people and events of my PhD have also taught me to be a little less harsh on myself, and a little more forgiving.) So I’ll just write freely, wherever my thoughts happen to go. Reality is, after all, imperfect and incomplete; if I tried to write this like a work of literature, with the reader’s experience in mind, I would be sacrificing truthfulness and spontaneity—the feelings I have while writing, and the flow of my state of mind. Besides, works of literature have storylines, and reality doesn’t. I’ve become more and more able to accept the chaos of the world, and my own chaos within it (the flattering term for which is “free-spirited”).

That day, I happened to open an article on Zhihu and noticed that the account of a friend, Leo, had liked it. So I messaged Leo on WeChat—we hadn’t seen each other in a long time, and I wanted to catch up and ask how he’d been. He told me he was planning to switch to working on LLMs, and that over the past year he had moved to a new place and was talking to people even less than before. Even though we hadn’t been in touch for over a year, chatting with him still felt familiar. Back in 2023, when we were applying for PhDs, we were both working on theory. But Leo socialized very little and rarely reached out to anyone to hang out (he spent most of his time doing research and reading papers), though when we ran into each other now and then I’d chat with him a bit. So I wouldn’t say I knew him well enough to call us “close.” And yet he came to my PhD A exam last year. (Not many people came since I hadn’t made any special announcement—it was only visible in a mass email that the grad school requires us to send to all the PhD student in a certain format. He’s also not the kind of person who likes going to presentations, especially when the research I was presenting had nothing whatsoever to do with what he was interested in. So the fact that he noticed, and made time to show his support, surprised me.) Leo’s PhD path has been extremely rocky. Given his hermit-like style, he probably wouldn’t want me telling other people too much about it, so I’ll leave that part out. But even though his PhD hasn’t gone smoothly, he has always been so calm, so unruffled.

Every time I talk with people around me (especially the guys) and learn what they’ve been through, I think: “Why am I so bad at enduring hardship? The smallest thing happens to me (compared to what they have been through) and I start kicking up a fuss, as if I want the whole world to know how much pain I’m in and how hard things are—while they, facing far more and far harder things, keep a straight face, placid as still water.” Of course, this kind of self-gaslighting usually passes in an instant. I tend to look at things from an all-around, complete perspective, so everything gets considered from multiple sides and angles, and I freely adjust the weight I give to each. The upside is that I never become too stubborn or opinionated; the downside is that sometimes people feel I have no personality of my own, that I just agree with everything. (I’ve just wandered off topic again…)

In fall 2024, I was considering quitting, and Leo was in the middle of switching and finding new advisors. I half-jokingly said, “Why don’t you quit with me? You wouldn’t even have to worry, like I do, about how quitting would negatively affect your advisor’s reputation. Or, stop doing theory and switch to an advisor who does applied work?” (In a CS department, if Leo didn’t care about his research direction, finding an advisor would be much easier.) But he remained very firm, and firmly described to me the career path he had in mind. He framed his choice to do a PhD as “so that I can go into quant after graduation and get a very high salary.” I didn’t quite follow his logic, because from my perspective, he could go into quant companies even without a PhD, or without doing theory. But Leo described it as though it were the only path. I just smiled, because from what I knew of him, he was the unpretentious kind of scholar, and the “high salary” of quant would hardly be enough to make him choose, so resolutely, a path that looked so much harder. (Note that I added the qualifier “unpretentious” here, because not every scholar can be described that way—and this was precisely the mistake I made when I first entered academia. But nothing is absolute; back then I could only see one side of people and things, and I blindly passed judgment on them based on what I saw. That was my own problem.)

Perhaps it’s Leo’s “hermit” style that lets him hear less of the world’s noise, and steadfastly do what he likes, what makes him happy (doing theory, writing formulas, and reading proofs really are a joy for some people!). In my first year of the PhD, I too agonized for a long time over whether to give up theory. Even back when I started doing theory as an undergrad, my undergrad advisor kept telling me that doing theoretical research has a lot of downsides, such as it is hard to recruit students, hard to get funding, and students are hard to find a job… But at that time, working are theory made me feel calm and happy, so none of those practical considerations mattered. I had hoped I could do both theory and application (so in my first year I was in fact doing both at once). On the one hand, I couldn’t give up theory, because it made me feel at peace; on the other hand, I couldn’t give up NLP, because coding had been my weak spot for the past several years, and if I abandoned applied work entirely, it would become my weak spot once again. (And with that would come a lack of confidence, the kind that keeps me from seeing many people and things from an objective, equal footing, but admire people who can code.) I struggled for an entire year since I don’t want to give up any of these two, and in the end, because of a project I didn’t much like, I finally decided to stop working on theory. Looking back now, I ought to thank this twist of fate, because I was no longer distracted the way I used to be. Before, even when doing theory and applied projects side by side, I would always prioritize theory, because it made me happy. I didn’t care whether I was doing it well enough, didn’t care that a simple proof took me ages to understand, didn’t care whether my brain or my level of effort were suited to it. I only cared about the happiness of the moment, and about that slow, unhurried life of “one pen, one book, one proof to stare at for days.” (Even though some of the peers I know, could probably get through it in 30 minutes, lol.)

When my second year began and I decided to give up theory completely and focus on LLMs and NLP, it was painful at the time, because I didn’t like living at such a fast pace, and I didn’t like writing code. I wanted my tools to be pen and paper; I wanted the computer to be something I used for reading proofs, not for writing code and running experiments. I still tried hard to steer clear of the research directions that looked very popular, but I really could no longer get the joy of writing proofs, nor the calm I’d had before. Now, two years later, I’ve grown used to my current identity and come to accept it—I can’t even understand anymore why my past self was so afraid of giving up theory, so afraid of working on a popular direction. Back then I simply just being too young too naive; every little thing seemed like a big deal, and I didn’t dare try anything outside of what I had mentally prepared myself for. Now I’ve become more nihilistic: once there are more things you don’t care about, you’re less afraid of losing them. And once you’ve seen enough data, you know that people can always adapt, little by little; you don’t need to keep yourself in the most comfortable environment all the time, and you don’t need to confine yourself to a box. (Writing blogs is the new thing that makes me feel calm. Writing my thoughts and experience down is actually quite a lot like writing proofs, except that when I wrote a proof, I felt I was presenting a perfect piece of work, and the recognition of those around me made me sure of it; when I write prose, my thoughts often drift far off, so, objectively speaking, I can’t produce a piece of work that would be called good by any objective standard. But one day, I suddenly realized that the people and the world around me are more accepting than I am to my work—things don’t have to be perfect before you can show them to others. (I tried a few more times after that and received a lot of positive feedback.) I didn’t post these writings on English social media; but I quietly put them on my homepage. (For Chinese versions I occasionally post on Chinese social media, hoping strangers with no connection to my life will read them) One day, I received an email in from a stranger who doesn’t speak Chinese, saying she really liked my blog, and that she can relate to what I write even though we have a quite different life trajectory. This kind of good moments are one of the reasons why I like writing: it is for in this enormous world, to briefly form a super weak connection with a stranger that you would have never had any relation with (i.e., form an edge in two atom in a world full of atoms), and then go back to being strangers. It was also because of this email that I later decided to proofread my English versions carefully in my future writings, instead of simply translating them from Chinese without further proof-reading.)

At ICML 2024, even though I had already decided not to working on theory and spent most of my time talking to peers working on ML applications, three people who works on theory, whom I know when we were all applying PhD in 2023 happened to be at the conference too. One of them, Frank, invited us all for a city walk to catch up with each out, since we have each others contact but have never met in person. Being with them, I felt a bit out of place, because by then I could no longer follow the optimization theory and stochastic algorithms they were so heatedly discussing. I could only listen, envying them for still pursuing what they loved, even with so many LLM chaos all around. (Frank probably invited me along because, if when you grabbed a random person at ICML back then, the random person were most likely working on LLMs or something related. So unlike those who works on LLMs, who should be busy networking and talking with people in their own field—they could only grab people that they already know to catch up with.)

At NeurIPS 2025, two of those three person I mentioned about attended. One had already switched to LLMs and was busy talking with other LLM people at the conference—too busy to hang out with us. Thus, Frank and me decided to catch up ourselves. He said that he and the third guy who l used to work on theory (the person who didn’t attend NeurIPS) were both preparing to switch to LLMs (Frank and I each conveyed to him with our most sincere and heartfelt longing through messages), and we also discussed things like switching research directions and finding internships. Because NeurIPS was in San Diego, a huge number of people came, and I also ran into a younger PhD student Jack. He too had switched from theory to LLMs, and was also very anxious. We discussed the state of the job market. By then there were already many PhDs graduating in only three or four years (I was job hunting at the time), and I was anxious in thinking that: if all those PhD students, who should have entered the market one or two years later suddenly flood in all at once, doesn’t it get even harder for not-so-outstanding PhDs like me, or for people who’ve only just switched their research directions, to find jobs? (On top of that, there were also many extremely talented first or second year PhDs who leave PhD program to join industry.) Jack, anxious but forcing himself to look on the bright side (he had only just started his second year), said, “Or maybe I’ll just stay in school through this turbulent period, and by the time I graduate the market will have stabilized again.”

I also chatted with a peer I had once looked up to—a rising star in my eyes, the one who “could read in 30 minutes a proof that took me days to understand.” He said he had switched to LLMs in the past few months, but since others had several more years of experience than he did, he was slowly feeling his way forward, trying to catch up. Once again I didn’t know what to say. I thought: even those who once shone so brightly in their own field can feel lost and adrift when faced with something new. If he had stayed in his field, what a dazzling star he would have been. But LLMs have forced many people to abandon the directions they love and are good at, to work on something new, while others who got into it a little earlier already have a lot of experience. Sometimes I wonder: is it possible to catch up? Judging by most people’s examples, it seems that as long as you’re willing to work hard, willing to put in the time, and quick to grasp things, catching up is possible—and I’ve since seen many examples of successful transitions. Though I’m not one of the “willing to work hard, willing to put in the time, quick to grasp things” crowd (by now I’ve made peace with my own nature, so I just take things as they come and have no plans to catch up with anyone). But the those people I mentioned above—those who used to work on theory, they’ll surely catch up in the end, through their hard work and their brilliance.

By 2026, almost every person met while applying for PhDs who used to work on theory had switched to LLMs. The trigger for writing this piece was that the friend Leo I mentioned earlier, the one who had wanted to go into quant, told me today that he just switched to LLMs this semester—he who had once been so resolute even in his most difficult time when he can’t find an advisor. He said he had only just changed directions, was still in the adjustment period, and was very unhappy due to the transitioning phase.

As I write this, my mind is flooded with thoughts. Our PhDs—a mere three years, and yet it feels like such a long, long time has passed. So long that, unless I make an effort to remember, I’ll forget that many of those people and ephemeral moments ever existed. So long that when I sit down to write, I don’t know where to begin, or how to end. But these people and moments are still worth remembering. One of the reasons I originally wanted to work on ML theory was that I felt everyone in this fields was so nice (after all, everyone had plenty of free time, did research at an unhurried pace, and was very easygoing)—whether Leo, who didn’t usually hang out with me but showed up at my A exam to show his support, or Frank, whom I only knew each other online due to PhD applications, but were thoughtful enough to find a reason to hang out everytime when he know that we are attending the same conference. Our friendships feel so light and understated—so light that I often forget them constantly, and they might also forget me. But when something reminds us of each other, we can still catch up like old times. Even though so much has changed—we’ve all switched directions, and life and work have made us less idealistic than we were—there’s always something familiar that hasn’t changed. When we grow older, we stopped chatting with people without a specific purpose. Everyone has gotten into the habit of talking with a purpose (“with a purpose” isn’t meant as a criticism here; it’s more that a conversation needs a reason, and most of the time my reason is work or academic related). So I don’t know if we are friends or coworkers, since everying conversation feels like “meeting” or business chat.

Those friendships with those old friends (who used to work on theory), though seem so light, yet don’t feel the least bit unfamiliar when picked up again a year later, are pure enough to leave me nostalgic and savoring.