Paper deep dive
Tyler: Typed Latent Reasoning for Language Models -- When to Think, What to Compute, and How Much to Allocate
Hanyu Lin, Min Cai, Jiawei Wen, Haodi Zhang
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%
Last extracted: 6/20/2026, 8:18:40 AM
Summary
TYLER (Typed Latent Reasoning) is a framework designed to improve the reasoning capabilities of Large Language Models (LLMs) by allowing them to switch between visible text decoding and specialized latent computation. Unlike existing latent reasoning methods that use undifferentiated representations, TYLER introduces three typed operators: Global Orientation (Og), Local State Update (Os), and Procedural Abstraction (Op). The framework uses a two-stage training process: Stage 1 optimizes the latent synthesis module (using LoRA) to align operators with specific reasoning functions, and Stage 2 uses Group Relative Policy Optimization (GRPO) to learn a budget-aware policy that decides when and how to invoke these operators. Experiments show TYLER improves accuracy across various backbones (Qwen, SmolLM) and benchmarks (GSM8K, MATH-500, etc.) compared to standard Chain-of-Thought (CoT) and other latent reasoning baselines.
Entities (8)
Relation Signals (5)
TYLER â trainedwith â Group Relative Policy Optimization
confidence 100% ¡ Stage 2 optimizes an operator-invocation policy with Group Relative Policy Optimization (GRPO)
TYLER â uses â Global Orientation
confidence 100% ¡ TYLER introduces three typed latent operators: Og, Os, and Op.
TYLER â uses â Local State Update
confidence 100% ¡ TYLER introduces three typed latent operators: Og, Os, and Op.
TYLER â uses â Procedural Abstraction
confidence 100% ¡ TYLER introduces three typed latent operators: Og, Os, and Op.
TYLER â improves â Chain-of-Thought
confidence 90% ¡ TYLER improves accuracy by up to 14.49 points over CoT
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Chain-of-thought (CoT) prompting improves reasoning in large language models (LLMs) by externalizing intermediate computation as discrete text tokens, but this textual interface also introduces redundancy and inference overhead. Latent reasoning offers a promising alternative by carrying part of the computation in continuous representations. However, existing methods typically predefine when latent computation is invoked and how it is allocated during decoding, leaving a key problem unresolved: when to invoke latent computation, what type of computation to perform, and how much budget to allocate. We propose \textbf{Ty}ped \textbf{L}at\textbf{e}nt \textbf{R}easoning (Tyler), a typed and budget-aware framework for latent reasoning during autoregressive decoding. Tyler learns a policy that, at each decoding step, chooses between emitting a text token and switching to a latent computation module specialized for a particular reasoning function. Once invoked, an operator maps the current reasoning state into latent tokens that support global planning, local state updates, or reusable procedural abstraction. Across extensive experiments on three backbone LLMs, Tyler improves accuracy by up to 14.49 points over CoT and by up to 4.30 points over the strongest competing baseline. It further generalizes across diverse reasoning domains and achieves the best final-stage performance with the lowest forgetting.
Tags
Links
- Source: https://arxiv.org/abs/2606.16360v1
- Canonical: https://arxiv.org/abs/2606.16360v1
Trouble viewing inline? Open PDF directly â
Full Text
73,068 characters extracted from source content.
Expand or collapse full text
TYLER: Typed Latent Reasoning for Language Models â When to Think, What to Compute, and How Much to Allocate Hanyu Lin 1 Min Cai 2 Jiawei Wen 1 Haodi Zhang 1 1 Shenzhen University 2 University of Alberta typed-latent-reasoning.github.io Abstract Chain-of-thought (CoT) prompting improves reasoning in large language models (LLMs) by externalizing intermediate computation as discrete text tokens, but this textual interface also introduces redundancy and inference over- head. Latent reasoning offers a promising al- ternative by carrying part of the computation in continuous representations. However, ex- isting methods typically predefine when la- tent computation is invoked and how it is al- located during decoding, leaving a key prob- lem unresolved: when to invoke latent compu- tation, what type of computation to perform, and how much budget to allocate. We propose Typed Latent Reasoning (TYLER), a typed and budget-aware framework for latent reasoning during autoregressive decoding. TYLER learns a policy that, at each decoding step, chooses between emitting a text token and switching to a latent computation module specialized for a particular reasoning function. Once invoked, an operator maps the current reasoning state into latent tokens that support global planning, local state updates, or reusable procedural ab- straction. Across extensive experiments on three backbone LLMs, TYLER improves ac- curacy by up to 14.49 points over CoT and by up to 4.30 points over the strongest competing baseline. It further generalizes across diverse reasoning domains and achieves the best final- stage performance with the lowest forgetting. 1 Introduction Large Language models (LLMs) typically solve complex reasoning tasks by generating explicit chain-of-thought (CoT) token sequences (Wei et al., 2022; Wang et al., 2022; Jaech et al., 2024; Guo et al., 2025). Although CoT improves reasoning performance, it requires intermediate computation to be externalized as visible text. This requirement increases redundancy generation and inference cost. It also imposes a rigid interface: intermediate rea- soning must be written out before the final answer Query Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need to ... Thinking ... Query Method 1 Thinking ... Extent Operator Tokens Query Thinking ... Low conf. Query Thinking ... High conf. Query Thinking ... Low conf.High conf. External plugin model Extent Tokens Laten token Input: How many tulips are in bouquet? Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Method 2 Method 3 Response: To solve this problem, we need to consider the following steps: ... Input: How many tulips are in bouquet? Our Method Laten token Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need to ... Method 1 Low conf.High conf. External plugin model Input: How many tulips are in bouquet? Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need Input: How many tulips are in bouquet? Our Method 2 Method 3 Extent Tokens to consider the following steps: ... Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need to ... 1. Fixed-position Low conf.High conf. External plug-in model Input: How many tulips are in bouquet? Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need Input: How many tulips are in bouquet? Our: Latent Control Flow 2. Confidence-based Triggering 3 External Plug-in Model Operator Tokens to consider the following steps: ... Input: How many tulips are bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need to ... 1. Fixed-position Low conf.High conf. External plug-in model Input: How many tulips are in bouquet? Input: How many tulips are in bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need Input: How many tulips are in bouquet? Our: Latent Control Flow 2. Confidence-based Triggering 3 External Plug-in Model Operator Tokens to consider the following steps: ... Input: How many tulips are in each bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need to ... Fixed-position (Coconut, SoftCoT) Low conf. Low conf. High conf. High conf. External plug-in model Input: How many tulips are in each bouquet? Input: How many tulips are in each bouquet? Response: To solve this problem, we need to ... Response: To solve this problem, we need Input: How many tulips are in each bouquet? Our: Latent Control Flow Typed Latent Reasoning (Ours) Confidence-based Triggering (SwiReasoning) External Plug-in Model (MemGen) Operator Tokens to consider the following steps: ... Figure 1: Comparison of latent reasoning paradigms. Existing methods rely on fixed-position latent tokens, confidence-triggered latent computation, or external trigger models. TYLER instead allows the LLM to interleave between visible decoding and typed latent- operator invocation during generation. is produced, rather than invoked internally on de- mand during autoregressive decoding. Latent reasoning provides a promising way to relax this interface by keeping part of the interme- diate computation in continuous representations, instead of unfolding the full reasoning process into explicit tokens (Zhu et al., 2025; Hao et al., 2022; Xu et al., 2025a; Zhang et al., 2026). From this perspective, latent reasoning should not be viewed merely as a compressed form of CoT. Rather, it can serve as a computation mechanism that allows the model to choose between visible decoding and silent latent computation during generation. Despite encouraging progress, two limitations remain. First, prior work mainly focuses on how to construct latent tokens, such as from hidden states (Hao et al., 2022; Liu et al., 2026), mixtures over token-embedding distributions (Zhang et al., 2026; Shi et al., 2025), or auxiliary soft-thought generators (Xu et al., 2025a,b; Zhang et al., 2025). arXiv:2606.16360v1 [cs.CL] 15 Jun 2026 This construction-centered view often treats latent tokens as general-purpose carriers of intermediate computation. However, explicit reasoning chains are functionally heterogeneous: different steps may orient the problem, update the evolving reasoning state, or reuse procedural solution patterns. A la- tent reasoning mechanism should preserve these functional distinctions rather than collapse them into a single undifferentiated representation. Second, existing methods remain limited in how they adaptively coordinate explicit reasoning and latent computation during generation. Fixed- position methods (Hao et al., 2022; Xu et al., 2025a) decouple latent computation from the evolv- ing reasoning state, while adaptive methods mainly decide whether or where to enter latent space based on uncertainty signals (Shi et al., 2025; Liu et al., 2026) or an external trigger model (Zhang et al., 2025). They do not allow the LLM itself to de- cide, during autoregressive decoding, which type of latent computation to perform or how much com- putation budget to allocate. This gap motivates the following research question: Can an LLM learn to interleave visible de- coding with silent latent computation, while de- ciding when to think, what type of computation to perform, and how much budget to spend? To answer this question, we propose TYLER, a typed latent reasoning framework that learns when to invoke latent computation, which type of com- putation to perform, and how much budget to al- locate. During generation, the LLM chooses be- tween visible-token decoding and three typed la- tent operators:O g for global orientation,O s for state update, andO p for procedural abstraction. Each operator maps the current reasoning state to a sequence of operator-conditioned latent tokens, which then guide subsequent visible decoding. Be- cause these operators are defined by reusable com- putational roles rather than task-specific output for- mats, TYLER supports latent computation that can transfer across reasoning domains. The training procedure consists of two stages. Stage 1 optimizes the latent operators and the Latent Synthesis Model while keeping the LLM frozen, aligning each operator with its intended reasoning function. Stage 2 optimizes an operator- invocation policy with Group Relative Policy Opti- mization (GRPO), updating the policy parameters while keeping the latent synthesis interface learned in Stage 1 fixed. An operator-anchored auxiliary objective further stabilizes policy learning at sparse invocation positions. Empirically, TYLER achieves consistent im- provements across multiple backbones and bench- marks, with gains that transfer beyond the training domain. Further analysis shows that the learned policy invokes different operators across task diffi- culties and reasoning stages, suggesting that these operators acquire differentiated functional roles. In a sequential adaptation setting spanning code, science, math, and theorem reasoning, TYLER ob- tains higher final performance with lower forget- ting, indicating stronger continual adaptation. Our contributions are summarized as follows: â˘We formulate latent reasoning as an online, typed, and budgeted computation problem, where an LLM learns when to invoke latent computation, which operation to perform, and how much budget to allocate. â˘We introduce TYLER, a typed latent reasoning framework that interleaves visible decoding with latent operators for global orientation, state update, and procedural abstraction. â˘We conduct extensive experiments across mul- tiple backbones and reasoning benchmarks, showing that TYLER improves accuracy over strong baselines, generalizes beyond the train- ing domain, and exhibits stronger continual adaptation under sequential domain shifts. 2 Related Work Explicit reasoning.CoT improves the reasoning ability of LLMs by making intermediate computa- tion explicit as text (Wei et al., 2022). Subsequent work extends this paradigm through sampled rea- soning paths (Wang et al., 2022), external actions and tool use (Yao et al., 2022; Schick et al., 2023), and search-based method (Yao et al., 2023). Rein- forcement learning has also become central to scal- ing explicit reasoning behavior, ranging from PPO- based RLHF (Schulman et al., 2017; Ouyang et al., 2022) to recent methods based on GRPO-style opti- mization (Shao et al., 2024; Yu et al., 2026). These methods strengthen reasoning mainly by increase the computational load. In contrast, TYLER pre- serves the autoregressive decoding interface while allowing the model to adaptively choose between emitting visible tokens and performing silent latent computation. Loop Hidden state Tokens <global> <state> <procedure> Extended vocab Sec 3.3: Operator Invocation Operator Invocation Text & Latent tokens Latent Synthesis Sec 3.4: Latent Synthesis Response: To solve this problem, we need to consider the following steps: ... Response: To solve this problem, we need to consider the following steps: First, find the total number ... Putting it all together, each bouquet has ... The answer to this question is 13. The answer to the given question is 13. Backbone Typed Latent Reasoning Input: A gardener has 4 rows of 12 tulips; 9 are destroyed; the rest are split into 3 equal bouquets. How many tulips are in each bouquet? Text V â = V<g>, <s>, <p> Query O g O s O p Project head g Query token g Query token s Query token p Project head s Project head p Three operators & semantic roles Global Orientation Local State Update Procedural Abstraction Typed Operator Bank Sample Text Token Operator Token QwenSmolLM Feature Vector Latent token Notations Activate Logits ExTTexT Backbone Project head s Synthesis ⪠Latent tokensLatent tokens Latent tokens Laten tokens Figure 2: Overview of TYLER. During decoding, the backbone interleaves between visible text tokens and typed operators. When invoked, each operator maps the current context to an operator-conditioned sequence of latent tokens, which is inserted back into the context to guide subsequent decoding. Latent reasoning.Latent reasoning replaces part of the visible tokens with continuous representa- tions (Zhu et al., 2025; Chen et al., 2025). Exist- ing methods mainly study how latent tokens are constructed, including recycled hidden states (Hao et al., 2022; Shen et al., 2025), soft thought to- kens (Xu et al., 2025a; Wei et al., 2025), and embedding-space mixtures (Zhang et al., 2026). Other work studies when to activate latent compu- tation through confidence signals (Shi et al., 2025; Liu et al., 2026), enternal trigger model (Zhang et al., 2025), or pause tokens (Goyal et al., 2024; Pfau et al., 2024). These methods demonstrate the value of latent reasoning, but they usually treat latent computation as a uniform form. They pro- vide limited study for deciding what functional role latent computation should serve or how much com- putation budget should be allocated. In contrast, TYLER formulates latent reasoning as an online, typed, and budgeted computation problem, where latent operators serve different computational roles and are invoked under an explicit budget. 3 Methodology 3.1 Preliminaries We consider a decoder-only autoregressive lan- guage model parameterized byθ, which defines a next-token distributionp θ (¡| x t )over a discrete vocabularyVgiven an input embedding sequence x t . Letddenote the embedding dimension, and letx t â R T t Ăd be the decoding context at stept, whereT t is the current sequence length. In stan- dard autoregressive decoding, the model samples a visible token a t âź p θ (¡| x t ),(1) and appends its embedding to form the next-step input: x t+1 = [x t ; emb(a t ) ].(2) This scheme tightly couples intermediate compu- tation with discrete token generation: each reason- ing state must be externalized through a vocabulary- indexed embedding before it can influence subse- quent decoding. Latent reasoning addresses this constraint by allowing continuous vectors to be inserted into the decoding context. Given the cur- rent embedding sequencex t , a set of latent tokens z t â R N t Ăd can be appended as x t+1 = [x t ; z t ].(3) These latent tokens are consumed by the autoregres- sive model as internal computational states while remaining invisible to the user. 3.2 Overview As shown in Figure 2, method extends autore- gressive decoding with adaptive latent computa- tion. The framework consists of two main compo- nents. First, the operator invocation policy decides whether the model should emit a visible token or invoke a typed operator (Section 3.3). Second, the latent synthesis module maps the activated opera- tor and the current context to a sequence of latent tokens (Section 3.4). 3.3 Operator Invocation We first define the latent operators and describe how TYLER invokes them during autoregressive decod- ing. In explicit CoT reasoning, intermediate tokens often play different functional roles: some provide global orientation, some update the local reasoning state, and others express reusable procedural pat- terns. This suggests that latent computation should not be treated as a single undifferentiated operation. Motivated by this observation, TYLER intro- duces three typed latent operators. Each operator O k has learnable parametersĎ k and maps the cur- rent decoding context to a sequence of latent tokens that supports subsequent generation: O k (¡;Ď k ) : x t 7â z k t â R N k Ăd .(4) The operator type provides an inductive bias about the intended computational role, while its behavior is learned from CoT data. We instantiate three operators: O =O g ,O s ,O p ,(5) whereO g supports global orientation and planning, O s supports local state updates, andO p captures reusable procedural abstractions. These operators are encouraged by heuristic position supervision in Stage 1 (Section 4.1) and regulated by a budget- aware routing policy in Stage 2 (Section 4). To enable operator invocation during decoding, we introduce one special token for each operator. LetU = u g ,u s ,u p denote the set of operator tokens, whereu k is associated withO k . The de- coding action space is extended toV Ⲡ= V âŞU by adding three trainable operator-token rowsĎ â R 3Ăd to the LM head. The next-token distribution is denoted as p θ,Ď (¡| x t ), and the model samples a t âź p θ,Ď (¡| x t ), a t â V Ⲡ.(6) Ifa t is a visible token, the model appends its embedding and emits it to the user. Ifa t = u k is an operator token, the corresponding operator synthesizes latent tokensz k t = O k (x t ;Ρ k ), which are appended to the context x t : x t+1 = ( [x t ; emb(a t ) ], a t â V, [x t ; z k t ],a t = u k âU. (7) The same policy is then applied to the updated contextx t+1 . Thus, visible-token emission and latent-operator invocation compete within a sin- gle next-action distribution, without requiring an external controller. 3.4 Latent Synthesis Once the LLM samples an operatorO k , TYLER must synthesize latent tokens that are compatible with the LLM input-embedding space. Rather than directly reusing hidden states (Hao et al., 2022) or mixing vocabulary-space embeddings (Zhang et al., 2026), we follow MemGen (Zhang et al., 2025) and add trainable LoRA layers (Hu et al., 2022) to the backbone while keeping the original parametersθ frozen. Thus, latent tokens are synthesized through parameter-efficient adaptation without updating the backbone directly. WhenO k is activated at stept, it uses the cur- rent contextx t to produceN k latent tokens. All operators share the LoRA-augmented synthesizer Synth θ,Ď , but specialize through operator-specific query tokensQ k â R N k Ăd and projection heads Proj k : R d âR d . The activated operator appends its query tokens to the current context and performs a single for- ward pass through the LoRA-augmented LLM. Be- cause the synthesizer is decoder-only and the query tokens are placed after the context, the query posi- tions can attend to the preceding context: h k t = Synth θ,Ď ([x t ; Q k ]) query â R N k Ăd .(8) The operator-specific projection head then maps the query-position hidden states into the LLM input- embedding space: z k t = Proj k (h k t )â R N k Ăd .(9) Although all operators shareSynth Ď and read the same contextx t , they specialize through distinct query tokensQ k , distinct projection headsProj k , and context-aware supervision over invocation po- sitions introduced in Section 4.1. 4 Training TYLER is trained in two stages. Stage 1 learns to synthesize operator-conditioned latent tokens while keeping the backbone LLM fixed. Stage 2 freezes the latent synthesis-specific parameters learned in Stage 1 and trains the LLM to invoke typed opera- tors adaptively under a computation budget. Com- plete training details are provided in Appendix F. 4.1 Latent Synthesis Optimization Stage 1 optimizes the LoRA parametersĎin the la- tent synthesizerSynth θ,Ď and the operator-specific componentsQ k , Proj k O k âO , while keeping the backbone LLM parametersθfrozen.We de- note the trainable Stage 1 parameters byÎŚ = Ď,Q k , Proj k O k âO . For each supervised rea- soning trace(q,y 1:T ), we construct a set of candidate boundaryâoperator pairsB(q,y)using structure-aware heuristics. Specifically,O g is as- signed to answer-onset positions, O s to reasoning- step boundaries, andO p to structural boundaries such as formulas, code blocks, and structured fields. Details are provided in Appendix F. Given a pair(b,k)âźB(q,y), the selected opera- tor synthesizes latent tokensz k b = O k (x b )from the prefixx b = (q,y <b ). We insertz k b into the teacher- forced trajectory, perform a single causal forward pass, and compute the next-token cross-entropy only at visible target-token positions: L stage1 =âE D,B T X t=1 logp θ,ÎŚ y t | Ěc k b,t . (10) Here,E D,B denotes the expectation over(q,y)âź Dand(b,k) âź B(q,y). Ěc k b,t denotes the latent- augmented context before predicting the visible to- keny t . Fort < b, this context reduces to the visible prefix(q,y <t ); fort ⼠b, it additionally contains the inserted latent tokens, i.e.,(q,y <b ,z k b ,y b:tâ1 ). The inserted latent tokens are used only as context and are not prediction targets. Gradients are applied only toÎŚ, while the backbone parametersθremain frozen. Consequently, Stage 1 trains each opera- tor through visible next-token supervision while preserving the backbone reasoner. 4.2 Operator Invocation Optimization Stage 2 learns a budget-aware operator-invocation policy that decides whether to emit a visible to- ken or invoke latent computation, which typed op- erator to select, and how much budget to spend. We freeze the Stage 1 synthesis parametersÎŚ = Ď,Q k , Proj k O k âO , including the latent syn- thesizer LoRA parameters and all operator-specific components. The backbone base weightsθare also kept frozen. The decoding policy is adapted through a separate set of LoRA parametersΡ, to- gether with the operator-token head rowsĎ. We denote the resulting policy distribution byp θ,Ρ,Ď and optimizeΡ,Ďwith GRPO (Shao et al., 2024). For each promptq, the policy samples a group of trajectories. Each trajectory is assigned a reward that combines task performance with a success- gated budget penalty P bud : P bud (Ď ) = s(Ď ) n op (Ď )â B O + , R(Ď ) = R task (Ď )â ÎťP bud (Ď ). (11) Here,s(Ď )indicates whether the trajectory suc- cessfully solves the task,n op (Ď )is the number of operator invocations, andB O is the invocation bud- get. The penalty is applied only to successful over- budget trajectories, encouraging the policy to use latent computation efficiently without discouraging exploration on failed trajectories. Because operator invocations occupy only a small fraction of each generated trajectory, sequence-level rewards provide weak credit- assignment signals for operator selection. We there- fore introduce an operator-anchored auxiliary ob- jective that applies the GRPO surrogate at operator- invocation positions. The Stage 2 objective is L stage2 =L GRPO (R) + ÎąL anch ,(12) whereL anch stabilizes optimization at sparse invo- cation positions, andÎącontrols the strength of this auxiliary objective. 5 Experiments We organize the evaluation around five questions: whether TYLER (i) generalizes across domains, (i) retains continual-learning capabilities during sequential task adaptation, (i) benefits from each proposed component, (iv) invokes operators in a task-adaptive manner under a computation budget, and (v) induces distinguishable functional roles among the three typed operators. 5.1 Experimental Setup Backbones and training.We instantiate TYLER on Qwen2.5-1.5B-Instruct (Yang et al., 2024), SmolLM3-3B (Bakouch et al., 2025), and Qwen3- 4B (Yang et al., 2025), covering three model fam- ilies in the 1.5Bâ4B range. Stage 1 and Stage 2 are trained on 15K problemâsolution traces sam- pled from OpenR1-Math (Hugging Face, 2025); the same data and prompt templates are used for all training-based baselines. Benchmarks. We evaluate on four benchmarks covering three reasoning regimes: mathematical reasoning with GSM8K (Cobbe et al., 2021) and BackboneMethodGSM8K MATH-500 GPQA-Diamond TheoremQAAverage SmolLM3-3B CoT58.9168.0019.7019.5441.54 (â0.00) SFT83.0266.6021.7225.3049.16 (â7.62) GRPO72.7174.2028.2826.5150.43 (â8.89) SoftCoT83.8569.2024.2425.0350.58 (â9.04) Soft-Thinking76.6568.4021.7221.1546.98 (â5.44) MemGen84.1570.2025.2527.3051.73 (â10.19) SwiReasoning74.9868.6020.7019.4045.92 (â4.38) TYLER Stage 183.2471.2030.5028.7653.43(â11.89) TYLER Stage 285.2176.4033.5029.0056.03 (â14.49) Qwen3-4B CoT90.5282.6016.1636.9556.56 (â0.00) SFT86.9672.8021.7235.6154.27 (â2.29) GRPO90.1481.2039.9039.3662.65 (â6.09) SoftCoT88.3272.6038.3834.9458.56 (â2.00) Soft-Thinking91.5181.4015.1536.4156.12 (â0.44) MemGen89.6578.2040.4036.8761.28 (â4.72) SwiReasoning90.2182.0017.1733.5055.72 (â0.84) TYLER Stage 191.6683.0039.9038.9563.38(â6.82) TYLER Stage 292.8785.8043.4341.0265.78 (â9.22) Table 1: Results on SmolLM3-3B and Qwen3-4B. All values are Pass@1 accuracy (%). We highlight the best and second-bestresults. Improvements across both backbones indicate that TYLER generalizes well across multiple task domains. MATH-500 (Hendrycks et al., 2021); scientific rea- soning with GPQA-Diamond (Rein et al., 2023); and theorem-oriented reasoning with TheoremQA (Chen et al., 2023). Baselines.We compare TYLER against represen- tative methods in two regimes. (i) Explicit reason- ing: CoT (Wei et al., 2022), SFT, and GRPO (Shao et al., 2024). (i) Latent reasoning: SoftCoT (Xu et al., 2025a), Soft-Thinking (Zhang et al., 2026), MemGen (Zhang et al., 2025), and SwiReasoning (Shi et al., 2025). Metricsandimplementation. Wereport Pass@1 accuracy under greedy decoding, and compute the average as an unweighted macro- average across the four benchmarks.Unless otherwise specified, Stage 1 uses latent-token lengths(N g ,N s ,N p ) = (8, 4, 4), and Stage 2 uses a latent-call budgetB O = 5. Implementation details are provided in Appendix E. 5.2 Main Results Consistent Gains, Cross-Domain Generaliza- tion, and Robustness.TYLER achieves the best average performance on both backbones.On SmolLM3-3B, Stage 2 reaches an average accuracy of56.03, outperforming CoT by14.49points and the strongest baseline, MemGen, by4.30points. On Qwen3-4B, Stage 2 reaches65.78, improving over CoT by9.22points and over the strongest prior baseline, GRPO, by3.13points. Although TYLER is trained only on a subset of OpenR1- Math, its gains extend beyond mathematical rea- soning to scientific and theorem-oriented bench- marks: Stage 2 improves GPQA-Diamond over CoT by13.80and27.27points on SmolLM3-3B and Qwen3-4B, respectively, and improves Theo- remQA by9.46and4.07points. These results sug- gest that the learned latent computation transfers beyond the training domain. Existing baselines are more sensitive to the choice of backbone: SFT im- proves SmolLM3-3B but slightly degrades Qwen3- 4B, while GRPO is stronger on Qwen3-4B than on SmolLM3-3B. Latent-reasoning baselines show similar variance, with MemGen being strongest on SmolLM3-3B but not on Qwen3-4B. In contrast, TYLER consistently achieves the best average per- formance and maintains gains on out-of-domain benchmarks, indicating stronger robustness across backbone choices and evaluation domains. Continual Learning.Figure 3 evaluates TYLER under sequential adaptation across code, science, math, and theorem-oriented tasks. After the fi- nal adaptation stage, TYLER achieves the high- est macro-average accuracy, reaching39.8%and outperforming the strongest baseline by about3.5 points. It also obtains the lowest forgetting score, withF = 2.3, reducing forgetting by about1.4 points compared with MemGen. These results indi- VariantRouting Typed Budget L anch GSM8K MATH GPQA TheoremAverage Per-stage (a) CoTâ90.5282.6016.1636.9556.56 (â0.00) (b) +Stage 1Ăââ91.6683.0039.9038.9563.38 (â6.82) (c) +Stage 2 (task-only)â Ă Ă93.2583.6038.3840.0563.82(â7.26) (d) +Stage 2 (+budget)â Ă91.5783.8038.8940.4263.67 (â7.11) (e) TYLERâ92.8785.8043.4341.0265.78 (â9.22) Typed?(f) Shared operatorsâ Ăâ91.1083.2037.8839.6262.95 (â6.39) (g) Swap O s âO g âswapâ92.4980.4035.3533.5060.44 (â3.88) Routing? (h) Rand@25%randomâ ââ90.7182.8034.8538.8161.79 (â5.23) (i) Rand@50%randomâ ââ91.0183.0035.8639.2262.27 (â5.71) (j) Rand@75%randomâ ââ91.1582.6036.3638.6562.19 (â5.63) (k) Rand@100%randomââ91.6683.0039.9038.9563.38 (â6.82) Table 2: Unified ablation on Qwen3-4B. All values are Pass@1 accuracy (%); CodeGPQAGSM8KTheorem Adaptation stage 28 32 36 40 Macro-average accuracy (%) AccuracyForgetting 0 4 8 12 Forgetting score F SFTGRPOMemGenTYLER Figure 3: Continual-learning results on Qwen2.5-1.5B- Instruct. (a) Macro-average after each adaptation stage. (b) Forgetting scoreF ; lower is better. cate that TYLER not only adapts more effectively to new reasoning domains, but also better preserves previously acquired capabilities. Additional details are provided in Appendix H. 5.3 Ablation Studies The full TYLER combines operator-conditioned latent token synthesis, budget-aware operator invo- cation, and the operator-anchored lossL anch . Ta- ble 2 ablates these components on Qwen3-4B by incrementally enabling Stage 1 and Stage 2, and by replacing typed operators or the learned router under comparable invocation settings. The Swap variant keeps the router, budget, and anchor loss fixed, but exchanges the synthesis paths ofO s and O g at inference time. Rows (a)â(e) show that Stage 1 provides the largest gain, while Stage 2 improves selective op- erator use. Invoking learned typed operators at all candidate boundaries raises the average accuracy from56.56to63.38, with GPQA-Diamond improv- ing from16.16to39.90, indicating transfer beyond in-domain math traces. Learned routing and budget control maintain this gain, and addingL anch further improves the average to65.78, outperforming CoT by9.22points and Stage 1 by2.40points. This suggests that anchored credit assignment is useful for sparse operator-invocation decisions. Rows (f)â(g) further show that the improvement is not merely due to latent capacity or access to candidate boundaries. Sharing operator-specific modules reduces the average to62.95, while swap- pingO s andO g drops it to60.44, indicating that the learned state-update and global-orientation op- erators play distinct roles. Rows (h)â(l) show that random or fixed invocation schedules remain in- ferior. Overall, these results indicate that TYLER must jointly learn which latent operator to invoke and where to invoke it. 5.4 Additional Analysis We further analyze whether TYLER learns mean- ingful control over latent computation from two perspectives: whether the router allocates latent operators according to task difficulty and reason- ing stage, and whether the typed operators induce differentiated latent computation. An efficiency analysis is provided in Appendix I. Operator Specialization.We next study whether the three typed operators induce distinct functional roles. As shown in Figure 4(a), SoftCoT (Xu et al., 2025a) mainly occupies a mixed latent re- gion, whereas the representations conditioned on O g ,O s , andO p form operator-aligned clusters in the same PCA space. This separation suggests that the operators do not collapse into homogeneous latent representations. The removal analysis in Figure 4(b) further supports this interpretation: re- -202-202 PC 1 within each method â2 â1 0 1 2 PC 2 (a) Embedding comparison SoftCoTTYLER(Ours) O g O s O p 050 Newly induced errors w/oO g w/oO s w/oO p (b) Removal effect n=63 n=66 n=69 (c) Invocation ratio 050100 0.0 0.2 0.4 GSM8K O s O p 050100 Relative invocation position (%) 0.0 0.2 0.4 GPQA-Diamond StrategyStateProceduralFormatOther Figure 4: Diagnostics of typed latent operators with Qwen3-4B. (a) PCA visualization of latent representations under the same embedding protocol. (b) Error decomposition of newly induced failures after removing each typed operator on MATH-500. (c) Relative invocation-position distributions on GSM8K and GPQA. 07132844 Latent tokens 01258 Latent-call budgetB O 60 62 64 66 Pass@1 accuracy (%) saturation Accuracy Latency 6.2 6.6 7.0 7.4 7.8 Latency per example (s) Figure 5: Latent-budget scaling on Qwen3-4B, averaged across GSM8K, MATH, GPQA, and TheoremQA. movingO g leads to more strategy and setup errors, removingO s increases state and arithmetic errors, and removingO p produces more procedural and symbolic errors. Together, these results indicate that the typed operators learn complementary latent representations with distinct functional effects. Task-Adaptive Invocation. Figure 4(c) reports the invocation ratios and relative positions ofO s andO p on GSM8K and GPQA-Diamond. We visualize onlyO s andO p , sinceO g is a global- orientation operator invoked at the beginning of generation. The router shows a clear task-adaptive pattern. On the relatively simple GSM8K task, the overall invocation ratio remains low, whereas GPQA-Diamond triggers latent operators more fre- quently, suggesting that the policy allocates more computation to harder reasoning tasks. The relative positions further reveal a stage-aware division of labor:O s is invoked more often in the early and middle stages of reasoning, where local states and intermediate conclusions are actively maintained; O p becomes more frequent in later stages, where reusable solution procedures are more likely to dominate. These results indicate that TYLER does not follow a rigid schedule, but learns to invoke la- tent computation according to both task complexity and reasoning state. Token Budget Scaling. Figure 5 studies the ef- fect of the latent-call budget. Accuracy improves rapidly asB O increases from 0 to 5, showing that TYLER benefits from additional latent computa- tion. However, when the budget increases further to B O = 8, the marginal accuracy gain becomes very small, while latency increases noticeably. Thus, B O = 5provides a better accuracyâlatency trade- off than using a larger budget. 6 Conclusion We introduced TYLER, a framework that reframes latent reasoning as online, typed, and budgeted operator invocation. By combining three typed la- tent operators with a budget-aware policy, TYLER enables autoregressive decoding to decide when to invoke internal computation and which latent operation to perform under a computation budget. Across extensive experiments on three backbone LLMs, TYLER improves average performance by up to 14.49 points over CoT and by up to 4.30 points over the strongest competing baseline. It also generalizes across diverse reasoning domains and achieves the best final-stage performance with the lowest forgetting in sequential adaptation. 7 Limitations We note four limitations. First, our evaluation spans 1.5Bâ4B backbones across three model fam- ilies; whether typed latent operators retain their advantage at substantially larger scales remains an open empirical question. Second, TYLER re- lies on rationale-like supervision to construct can- didate boundaries in Stage 1. Although Stage 2 learns a routing policy over these candidates, fully unsupervised boundary discovery remains future work. Third, operator invocation triggers silent latent-token synthesis, which improves efficiency but reduces direct auditability compared with visi- ble chain-of-thought rationales. The intended roles of the latent operators are learned rather than guar- anteed by construction, so deployments should log operator identities, invocation positions, and bud- gets when traceability matters. Fourth, our experi- ments focus on reasoning benchmarks with verifier- style evaluation; broader open-ended generation tasks may require different rewards and additional safeguards against unfaithful or hard-to-inspect la- tent computation. 8 Ethical Considerations This work studies latent reasoning as a mechanism for improving the efficiency and effectiveness of language-model reasoning. The experiments are conducted on public reasoning benchmarks and do not involve human subjects, private user data, or the collection of personally identifiable information. The main potential risk is dual use: improving the reasoning capability or inference efficiency of language models may also reduce the cost of de- ploying models in harmful applications. In addi- tion, latent computation may make intermediate reasoning less transparent than explicit CoT gen- eration, which could complicate debugging and auditing. Our work is intended as a research con- tribution on controllable latent computation rather than a deployed system. We encourage future ap- plications of this method to include standard safety evaluations, misuse analysis, and appropriate mon- itoring when used in real-world settings. References Elie Bakouch, Loubna Ben Allal, Anton Lozhkov, Noua- mane Tazi, Lewis Tunstall, Carlos Miguel PatiĂąo, Edward Beeching, Aymeric Roucher, Aksel Joonas Reedi, Quentin GallouĂŠdec, Kashif Rasul, Nathan Habib, ClĂŠmentine Fourrier, Hynek Kydlicek, Guil- herme Penedo, Hugo Larcher, Mathieu Morlon, Vaib- hav Srivastav, Joshua Lochner, and 4 others. 2025. SmolLM3: smol, multilingual, long-context reasoner. https://huggingface.co/blog/smollm3. Rich Caruana. 1997. Multitask learning. Machine learning, 28(1):41â75. Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, and 1 others. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374. Wenhu Chen, Ming Yin, Max Ku, Pan Lu, Yixin Wan, Xueguang Ma, Jianyu Xu, Xinyi Wang, and Tony Xia. 2023. Theoremqa: A theorem-driven question answering dataset. In Proceedings of the 2023 Con- ference on Empirical Methods in Natural Language Processing, pages 7889â7901. Xinghao Chen, Anhao Zhao, Heming Xia, Xuan Lu, Hanlin Wang, Yanjun Chen, Wei Zhang, Jian Wang, Wenjie Li, and Xiaoyu Shen. 2025.Reasoning beyond language: A comprehensive survey on la- tent chain-of-thought reasoning. arXiv preprint arXiv:2505.16782. Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, and 1 others. 2021.Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168. Ronan Collobert and Jason Weston. 2008. A unified architecture for natural language processing: Deep neural networks with multitask learning. In Proceed- ings of the 25th international conference on Machine learning, pages 160â167. Matthias De Lange, Rahaf Aljundi, Marc Masana, Sarah Parisot, Xu Jia, AleĹĄ Leonardis, Gregory Slabaugh, and Tinne Tuytelaars. 2021. A continual learning sur- vey: Defying forgetting in classification tasks. IEEE transactions on pattern analysis and machine intelli- gence, 44(7):3366â3385. Sachin Goyal, Ziwei Ji, Ankit Singh Rawat, Aditya Kr- ishna Menon, Sanjiv Kumar, and Vaishnavh Nagara- jan. 2024. Think before you speak: Training lan- guage models with pause tokens. In International Conference on Learning Representations, volume 2024, pages 27896â27923. Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Peiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, and 1 others. 2025. Deepseek- r1 incentivizes reasoning in llms through reinforce- ment learning. Nature, 645(8081):633â638. Shibo Hao, Sainbayar Sukhbaatar, DiJia Su, Xian Li, Zhiting Hu, Jason Weston, and Yuandong Tian. 2022. Training large language models to reason in a continuous latent space, 2024. URL https://arxiv. org/abs/2412.06769, 98. Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. 2021. Measuring mathematical problem solving with the math dataset. Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Liang Wang, Weizhu Chen, and 1 others. 2022. Lora: Low-rank adaptation of large language models. volume 1, page 3. Hugging Face. 2025. Open r1: A fully open reproduc- tion of deepseek-r1. Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richard- son, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, and 1 others. 2024. Openai o1 system card. arXiv preprint arXiv:2412.16720. James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Ag- nieszka Grabska-Barwinska, and 1 others. 2017. Overcoming catastrophic forgetting in neural net- works. Proceedings of the national academy of sci- ences, 114(13):3521â3526. Zhizhong Li and Derek Hoiem. 2017. Learning without forgetting. IEEE transactions on pattern analysis and machine intelligence, 40(12):2935â2947. Weihao Liu, Dehai Min, and Lu Cheng. 2026. Latent thoughts tuning: Bridging context and reasoning with fused information in latent tokens. arXiv preprint arXiv:2602.10229. Michael McCloskey and Neal J Cohen. 1989. Catas- trophic interference in connectionist networks: The sequential learning problem, volume 24, pages 109â 165. Elsevier. Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, and 1 others. 2022. Training language models to follow instructions with human feedback. volume 35, pages 27730â27744. Jacob Pfau, William Merrill, and Samuel R Bowman. 2024. Letâs think dot by dot: Hidden computa- tion in transformer language models. arXiv preprint arXiv:2404.15758. Anastasia Razdaibiedina, Yuning Mao, Rui Hou, Ma- dian Khabsa, Mike Lewis, and Amjad Almahairi. 2023. Progressive prompts: Continual learning for language models. arXiv preprint arXiv:2301.12314. David Rein, Betty Li Hou, Asa Cooper Stickland, Jack- son Petty, Richard Yuanzhe Pang, Julien Dirani, Ju- lian Michael, and Samuel R Bowman. 2023. Gpqa: A graduate-level google-proof q&a benchmark. Sebastian Ruder. 2017. An overview of multi-task learning in deep neural networks. arXiv preprint arXiv:1706.05098. Victor Sanh, Albert Webson, Colin Raffel, Stephen H Bach, Lintang Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Teven Le Scao, Arun Raja, and 1 others. 2021. Multitask prompted training en- ables zero-shot task generalization. Timo Schick, Jane Dwivedi-Yu, Roberto DessĂŹ, Roberta Raileanu, Maria Lomeli, Eric Hambro, Luke Zettle- moyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. volume 36, pages 68539â68551. John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. 2017.Proxi- mal policy optimization algorithms. arXiv preprint arXiv:1707.06347. Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Yang Wu, and 1 others. 2024. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300. Zhenyi Shen, Hanqi Yan, Linhai Zhang, Zhanghao Hu, Yali Du, and Yulan He. 2025. Codi: Compress- ing chain-of-thought into continuous space via self- distillation. pages 677â693. Dachuan Shi, Abedelkadir Asi, Keying Li, Xiangchi Yuan, Leyan Pan, Wenke Lee, and Wen Xiao. 2025. Swireasoning: Switch-thinking in latent and explicit for pareto-superior reasoning llms. Fan-Keng Sun, Cheng-Hao Ho, and Hung-Yi Lee. 2019. Lamol: Language modeling for lifelong language learning. arXiv preprint arXiv:1909.03329. Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. 2022. Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171. Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, and 1 others. 2022. Chain-of-thought prompting elic- its reasoning in large language models. Advances in neural information processing systems, 35:24824â 24837. Xilin Wei, Xiaoran Liu, Yuhang Zang, Xiaoyi Dong, Yuhang Cao, Jiaqi Wang, Xipeng Qiu, and Dahua Lin. 2025. Sim-cot: Supervised implicit chain-of- thought. arXiv preprint arXiv:2509.20317. Yige Xu, Xu Guo, Zhiwei Zeng, and Chunyan Miao. 2025a. Softcot: Soft chain-of-thought for efficient reasoning with llms. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 23336â 23351. Yige Xu, Xu Guo, Zhiwei Zeng, and Chunyan Miao. 2025b. Softcot++: Test-time scaling with soft chain-of-thought reasoning. arXiv preprint arXiv:2505.11484. An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, and 1 others. 2025.Qwen3 technical report. arXiv preprint arXiv:2505.09388. An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, and 1 others. 2024. Qwen2.5 technical report. Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. 2023. Tree of thoughts: Deliberate problem solving with large language models. volume 36, pages 11809â 11822. Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Weinan Dai, Tiantian Fan, Gaohong Liu, Lingjun Liu, and 1 others. 2026. Dapo: An open-source llm reinforcement learning system at scale. Advances in Neural Information Processing Systems, 38:113222â113244. Guibin Zhang, Muxin Fu, and Shuicheng Yan. 2025. Memgen: Weaving generative latent memory for self- evolving agents. arXiv preprint arXiv:2509.24704. Zhen Zhang, Xuehai He, Weixiang Yan, Ao Shen, Chenyang Zhao, and Xin Wang. 2026. Soft thinking: Unlocking the reasoning potential of llms in continu- ous concept space. Advances in Neural Information Processing Systems, 38:168990â169012. Rui-Jie Zhu, Tianhao Peng, Tianhao Cheng, Xingwei Qu, Jinfa Huang, Dawei Zhu, Hao Wang, Kaiwen Xue, Xuanliang Zhang, Yong Shan, and 1 others. 2025. A survey on latent reasoning. arXiv preprint arXiv:2507.06203. A Artifact A.1 Artifact Licenses and Terms We use publicly available datasets, benchmarks, open-weight models, and evaluation tools for re- search purposes only. We cite the original creators of all artifacts and follow their stated licenses or terms of use. Our use of these artifacts is consis- tent with their intended research use: benchmark datasets are used for training, validation, or evalua- tion as appropriate, and held-out benchmark splits are used only for evaluation. We do not redistribute benchmark data or model weights as part of this submission. Any released artifacts will be limited to code, configuration files, and reproduction scripts. We will not release derivative datasets or redistribute model weights. These artifacts are intended only for research reproducibility and further academic study. A.2 Artifact Documentation Table 3 summarizes the main artifacts used in this work. All datasets and benchmarks are pub- licly available and are used for research purposes only. The language data used in our experiments is primarily English. The artifacts cover mathe- matical reasoning, scientific question answering, theorem-style reasoning, and code-generation tasks. They are not demographic or user-generated so- cial datasets, and they are not used to study de- mographic groups, dialectal variation, or sociolin- guistic phenomena. To the best of our knowledge, the benchmarks do not provide systematic demo- graphic annotations for authors or represented pop- ulations; therefore, our analysis does not make de- mographic claims. A.3 Dataset Statistics Table 4 reports the statistics of the datasets and benchmarks used in this work. We use the official splits whenever available. For benchmarks without a training split in our experiments, we use them only for evaluation. We do not collect new natural- language data. Synthetic reasoning traces or latent- operator training instances are generated only from the corresponding public training data and are used for research purposes. B Data Privacy and Content Safety We do not collect new user data or use private, per- sonally identifying, or sensitive information. All datasets used in this work are publicly available reasoning, science, theorem-proving, and code- generation benchmarks. These benchmarks are used only for research purposes, following their intended use and access conditions. To check for privacy and content risks, we re- viewed the dataset descriptions and manually in- spected representative examples from the training, validation, and evaluation data used in our experi- ments. We found no fields designed to identify indi- vidual people, such as names linked to real individ- uals, addresses, phone numbers, email addresses, ArtifactTypeDomainLanguage / Format GSM8KDatasetGrade-school math reasoningEnglish text MATH-500BenchmarkCompetition-level mathematicsEnglish text / equations GPQA-DiamondBenchmarkGraduate-level science QAEnglish text TheoremQABenchmarkTheorem-style reasoningEnglish text / equations HumanEvalBenchmarkCode-generation evaluationPython code and English prompts SmolLM3-3BModelGeneral-purpose language modelingText model Qwen3-4BModelGeneral-purpose language modelingText model Table 3: Documentation of the main artifacts used in this work, including their type, domain coverage, and language or format. Dataset / BenchmarkTrainDev / ValidationTest / Eval GSM8K7,473â1,319 MATH-500â500 GPQA-Diamondâ198 TheoremQAâ737 HumanEvalâ164 Table 4: Statistics of the main datasets and benchmarks used in this work. Dashes indicate that the corresponding split is not used in our experiments. account identifiers, or other personally identifying information. The benchmarks also do not target of- fensive, hateful, or abusive language generation. Therefore, no additional anonymization was re- quired. We do not redistribute the benchmark data or model weights as part of this submission. C Use of AI Assistants We used AI writing assistance tools only for lan- guage polishing, grammar checking, and improv- ing the clarity of author-written text. These tools were not used to generate research ideas, design the method, conduct experiments, analyze results, or produce conclusions. All AI-assisted edits were reviewed, verified, and revised by the authors, who take full responsibility for the content of the paper. D Additional Related Works Continual learning. Continual learning studies sequential adaptation under the risk of catastrophic interference, where learning a new task degrades performance on earlier tasks (McCloskey and Co- hen, 1989; De Lange et al., 2021). Representative strategies include regularizing important param- eters to preserve previous behavior (Kirkpatrick et al., 2017), distilling old-task predictions during new-task training (Li and Hoiem, 2017), replaying or generating samples from past tasks in lifelong language learning (Sun et al., 2019), and allocat- ing lightweight prompt parameters across a task stream (Razdaibiedina et al., 2023). These meth- ods primarily protect previously acquired behavior by constraining parameter updates, revisiting past data, or assigning task-specific capacity. Our eval- uation is complementary: it does not introduce a general continual-learning algorithm, but asks whether typed latent operators can serve as a low- interference adaptation interface during sequential reasoning-task updates. Multi-task learning. Multi-task learning im- proves transfer by training a shared model over multiple related objectives (Caruana, 1997; Ruder, 2017). In NLP, this idea has appeared in shared neu- ral architectures for multiple language-processing tasks (Collobert and Weston, 2008) and, more re- cently, in large-scale prompted task mixtures that induce zero-shot generalization (Sanh et al., 2021). Unlike multi-task training, the continual-learning protocol in Appendix H exposes tasks sequentially rather than as a joint mixture. TYLER is orthog- onal to both settings: instead of relying solely on a monolithic shared representation, it provides a small set of typed latent computation paths and learns when to route a reasoning trajectory through them. This makes the experiment a test of whether operator-mediated latent computation reduces in- terference while preserving cross-task transfer. E Experiment Details E.1 Training Data We use 15K problemâsolution traces sampled from OpenR1-Math (Hugging Face, 2025) to train TYLER. The same training pool is used for Stage 1 operator-conditioned latent-token synthesis and Stage 2 budgeted routing, while the backbone- specific SFT and GRPO baselines use the same data and prompt templates for controlled comparison. Evaluation benchmarks are used only for testing, and no test split is used for model selection. E.2 Benchmarks and Metrics Weevaluatefourreasoningbenchmarks. GSM8K (Cobbe et al., 2021) and MATH- 500 (Hendrycks et al., 2021) evaluate mathe- matical reasoning at different levels of symbolic complexity. GPQA-Diamond (Rein et al., 2023) evaluates graduate-level scientific reasoning. TheoremQA (Chen et al., 2023) evaluates theorem- oriented reasoning that requires applying formal concepts and structured solution patterns. All main results report Pass@1 accuracy under greedy decoding. The macro-average is computed as the unweighted average over GSM8K, MATH- 500, GPQA-Diamond, and TheoremQA. For all benchmarks, we require the model to wrap its final answer with . Outputs without a boxed final answer are judged as incorrect. For boxed out- puts, we extract the content inside and apply the benchmark-specific answer normalizer or verifier. E.3 Baselines and Budget Matching We compare against explicit-reasoning baselines, including CoT (Wei et al., 2022), SFT (Ouyang et al., 2022), and GRPO (Shao et al., 2024), and latent-reasoning baselines, including SoftCoT (Xu et al., 2025a), Soft-Thinking (Zhang et al., 2026), MemGen (Zhang et al., 2025), and SwiReason- ing (Shi et al., 2025).All baselines use the same backbone checkpoint, tokenizer, prompt tem- plate, and decoding setting whenever applicable. Baseline-specific hyperparameters follow the au- thorsâ recommended settings when available; other- wise, we tune them on the same development split used for TYLER. E.4 Implementation Details Table 5 summarizes the implementation configura- tion. E.5 Result Reporting. Unless otherwise specified, all results are reported as pass@1 accuracy on the official evaluation split of each benchmark. Each score is computed over all examples in the corresponding evaluation set, and the average score is the arithmetic mean across benchmarks. We report single-run results rather than the maximum over multiple random seeds or prompt trials. For training-based methods, we use a fixed random seed and keep the decoding and evaluation protocol identical across methods. We do not select the best result from repeated runs. F Training Details We train TYLER in two stages. Stage 1 learns typed latent operators while keeping the backbone LLM frozen. Stage 2 freezes the learned synthe- sizer and operator-specific components, and trains the backbone to decide when to invoke latent com- putation and which operator to select, under an explicit budget. Implementation hyperparameters are summarized in Appendix E.4. F.1 Stage 1: Latent Synthesis Optimization In Stage 1, the backbone LLM with parameters θis frozen, and we optimize the latent synthe- sizerĎtogether with the operator-specific com- ponentsQ k , Proj k O k âO . For brevity, we col- lect all Stage 1 trainable parameters asÎŚ = (Ď,Q k , Proj k O k âO ). For each supervised in- stance(q,y 1:T ), we construct a set of candidate boundaryâoperator pairsB(q,y)by parsing the tar- get sequence with structure-aware rules: ⢠O g is associated with answer starts: the first position immediately following the question, and any position following solution-onset cues such as âLet me solveâ, âSolution:â, or the analogous markers in code/math templates. ⢠O s is associated with reasoning-step bound- aries: positions following enumerated step markers (âStepi:â, âi. â) detected by a lightweight regex parser. ⢠O p is associated with structural boundaries: positions immediately before formula spans ($...$), fenced code blocks (```), or structured output schemata (e.g., JSON keys). For each training step, we sample a pair(b,k)âź B(q,y)and construct the prefix embedding se- quencex b from the question and the ground-truth prefixy <b . The selected operator produces latent tokensz k b = O k (x b )via Eqs.(8)â(9), which are then appended tox b following Eq.(7). We do not directly supervisez k b ; instead, the latent to- kens are trained only through their contribution to predicting subsequent visible tokens. Let Ěc t ConfigurationParameterStage 1Stage 2 Model BackbonesQwen2.5-1.5B-Instruct, SmolLM3-3B, Qwen3-4B PEFT MethodLoRALoRA LoRA rank88 LoRA alpha1616 LoRA dropout0.10.1 Target modules q_proj, v_proj q_proj, v_proj Latent operators Operator typesO g , O s , O p Synthesizer LoRA ParametersRandom initializationFrozen from Stage 1 Latent length N g 88 Latent length N s 44 Latent length N p 44 Training Training data15K OpenR1-Math traces Batch size88 Epochs / steps2 epochs1 epochs Learning rate 1Ă 10 â5 1Ă 10 â5 OptimizerAdamWAdamW SchedulerCosineCosine Warmup ratio0.10.1 Random seeds42 GRPO-Relative GRPO group size Gâ8 Clip ratio Îľâ0.2 KL coefficient βâ0.03 Latent-call budget B O â5 Budget penalty Îťâ0.1 Anchor weight Îąâ0.1 Success threshold Ď 0 âverifier success Evaluation DecodingGreedy decoding Max new tokens2048 Answer extractor parser with benchmark-specific normalization Table 5: Implementation configuration for TYLER. Stage 2 uses a per-trajectory latent-call budget ofB O = 5; task success is the benchmark-specific exact-match or verifier score. denote the latent-augmented context precedingy t (i.e., Ěc t = (x b ,z k b ,y b:tâ1 ) fort ⼠b, and the stan- dard prefix otherwise). The sampled boundary only determines where latent tokens are appended; the loss is applied to the entire target sequence so that gradients flow back throughz k b toÎŚfrom every downstream position, preventing the latent module from overfitting to local suffix prediction: L stage1 =â T X t=1 logp θ, ÎŚ (y t | Ěc t ),(13) where the gradient updates onlyÎŚsinceθis frozen. F.2 Stage 2: Operator Invocation Optimization Stage 2 learns a step-level operator invocation pol- icy that decides whether to emit a visible token or to invoke a typed latent operator. We freezeÎŚfrom Stage 1 and optimize the backbone parametersθ together with the extended head rowsĎintroduced in §3.3. Group-relative policy optimization. For each promptq, the current policy samples a group of tra- jectoriesG(q) =Ď i G i=1 . Each trajectory receives the same budget-aware reward used in the main text: R(Ď ) = R task (Ď )â ÎťP bud (Ď ),(14) where P bud (Ď ) = s(Ď )(n op (Ď )â B O ) + .(15) Here,s(Ď )â0, 1indicates task success,n op (Ď ) is the number of latent-computation calls inĎ, and B O is the per-trajectory call budget. The penalty is non-zero only on successful, over-budget trajecto- ries: failures contribute no budget penalty so that exploration on hard instances is not suppressed, and under-budget successes are free so that the model has no incentive to remove useful latent computa- tion. Let Ě R q andĎ q denote the mean and standard deviation of rewards inG(q). GRPO assigns each trajectory a group-relative advantage A i = R(Ď i )â Ě R q Ď q + Îľ .(16) For any visible-token or operator-invocation action a i,j at contextx i,j , define the importance-sampling ratio as r i,j = p θ,Ď (a i,j | x i,j ) p old (a i,j | x i,j ) .(17) Let Ěr i,j = clip(r i,j , 1âÎľ, 1 +Îľ)denote the clipped ratio. The clipped per-action surrogate is â clip i,j = min(r i,j A i , Ěr i,j A i ).(18) The clipped GRPO objective (Shao et al., 2024; Guo et al., 2025) is J GRPO (R) = 1 G G X i=1 1 |Ď i | X jâĎ i â clip i,j â β D KL (p θ,Ď âĽp ref ), (19) and the minimized GRPO loss isL GRPO (R) = âJ GRPO (R). Operator-anchored supervision. The GRPO loss applies the same trajectory-level advantage across all actions in a sampled response. This is sufficient for task-level learning, but operator invo- cations are sparse relative to visible-token actions, so their selection gradients can be diluted. We therefore add an operator-anchored auxiliary objec- tive that applies the same group-relative advantage directly to operator invocations. For each sampled trajectory Ď i , let M O (Ď i ) =j | a i,j âO(20) be the set of positions where the policy invokes a latent operator, and letN O = P i |M O (Ď i )|. The auxiliary loss is L anch =â 1 N O G X i=1 X jâM O (Ď i ) â clip i,j . (21) WhenN O = 0, we setL anch = 0. This term reuses the GRPO advantage rather than introducing extra intervention rollouts, and concentrates additional gradient on the operator invocations that trigger typed latent operators. Combined objective.The Stage 2 loss combines the standard GRPO loss with the operator-anchored auxiliary term: min θ,Ď L stage2 =L GRPO (R) + ÎąL anch ,(22) whereÎącontrols the auxiliary weight. We tune (Îť,B O ,Îą,G) on the development split. G Results on Qwen2.5-1.5B-Instruct We report the full evaluation on Qwen2.5-1.5B- Instruct (Yang et al., 2024) in this appendix because the 1.5B regime exposes several small-model fail- ure modes for prior latent-reasoning methods that are absent or weaker on the SmolLM3-3B/Qwen3- 4B backbones used in the main paper. Setup, base- lines, and metrics follow §5.1; all latent baselines are budget-matched to withinÂą10%of TYLERâs total visible + latent token count, and all numbers are Pass@1 under greedy decoding. Small-model regime exposes latent-baseline brit- tleness. At 1.5B, three patterns emerge that mo- tivate the design of TYLER. First, the implicit latent baselines do not transfer down: SoftCoT collapses to31.62on the macro-average (â6.55 vs. CoT), and Soft-Thinking matches CoT on av- erage but loses6.06points on GPQA-Diamond. This is consistent with the original SoftCoT re- port (Xu et al., 2025a) that the assistant-generated soft thoughts require a sufficiently expressive back- bone to be consumed productively. Second, the hy- brid baselines are uneven: MemGen becomes the strongest prior latent baseline with a+2.89macro- average gain over CoT, but entropy-based switch- ing with SwiReasoning still falls below CoT. Third, RL alone (GRPO,+1.99over CoT) wins GSM8K, MATH-500, and TheoremQA among prior base- lines, but its GPQA-Diamond accuracy (12.12) re- gresses below CoT, suggesting that the policy im- provements concentrate on the mathematical subset on which the reward is trained. TYLER dominates the macro-average and the knowledge-intensive split.TYLER (Stage 1) at- tains a strong macro-average (41.65), exceeding the strongest prior baseline MemGen by+0.59 points and CoT by+3.48. On GPQA-Diamond, TYLER reaches21.21, matching MemGen and im- proving over GRPO by+9.09points. On the re- maining three benchmarks TYLER is within0.40â 1.80points of the best prior baseline. The Stage 2 row further raises the average to44.05after adding MethodGSM8K MATH-500 GPQA-Diamond TheoremQA Average â CoT CoT64.6752.8017.1718.0738.17â SFT66.4947.2019.7015.9337.33 â0.84 GRPO74.3054.8012.1219.4140.16+1.99 SoftCoT51.5541.8019.1913.9231.62 â6.55 Soft-Thinking68.9251.6011.1116.8737.13 â1.04 MemGen71.1953.2021.21 18.6241.06+2.89 SwiReasoning61.7143.6011.1117.6233.51 â4.66 TYLER (Ours) + Stage 173.3953.0021.2119.0141.65+3.48 + Stage 275.2857.6023.2320.0844.05+5.88 Table 6: Pass@1 (%, greedy decoding) on Qwen2.5-1.5B-Instruct. Best andsecond-bestamong complete rows; â CoT is the macro-average gain over CoT. All latent baselines budget-matched to withinÂą10% of TYLER. budget-aware routing and operator-anchored super- vision. H Continual-Learning Evaluation This appendix presents a fixed-order continual- learning evaluation to examine whether synthetic latent tokens provide a low-interference interface for sequential adaptation. We use Qwen2.5-1.5B- Instruct as the backbone and adapt each method se- quentially across four task families: code-style rea- soning evaluated on HumanEval (Chen et al., 2021) âGPQA-style science reasoningâGSM8K arith- metic reasoningâTheoremQA-style theorem rea- soning. After each adaptation stage, the resulting model is evaluated on all four benchmarks, includ- ing both the newly adapted domain and previously observed domains. For each stage, adaptation uses training or development traces from the correspond- ing task family, while the held-out benchmark splits are used exclusively for evaluation. This setup provides a controlled evaluation of sequential in- terference under a fixed task order, rather than an exhaustive continual-learning benchmark over all possible task permutations. We report the macro-average over the four eval- uation benchmarks and the stage-wise forgetting score: F t = 1 |S t | X iâS t max sâ¤t A s,i â A t,i ,(23) whereS t denotes the set of task families observed up to staget, andA t,i is the accuracy on task family iafter thet-th adaptation stage. Lower values ofF t indicate stronger retention of previously acquired capabilities. Since the newly introduced task at a given stage contributes zero forgetting by construc- tion, the forgetting score at stage 1 is trivially zero for all methods. Improved Adaptation under Sequential Train- ing. Across the four-stage adaptation sequence, TYLER achieves the highest macro-average af- ter every stage. Its advantage over the strongest baseline increases from+1.40points after code- style adaptation to+3.48points after the fi- nal TheoremQA-style adaptation, where TYLER reaches39.83compared with36.35for MemGen, 34.08for GRPO, and28.23for SFT. Under this fixed task order, the performance gap becomes larger as more adaptation stages are applied, sug- gesting that TYLER maintains stronger overall per- formance during sequential adaptation. Reduced Forgetting on Previously Observed Tasks.TYLER also obtains the lowest forget- ting score throughout the sequence. At stage 2, it achievesF = 1.15, slightly below MemGen at1.35and below GRPO and SFT at1.85and 3.85, respectively. The gap becomes more pro- nounced in later stages. After the final adaptation stage, TYLER obtainsF = 2.27, reducing for- getting by1.36points relative to MemGen,4.21 points relative to GRPO, and9.63points relative to SFT. These results suggest that operator-based latent adaptation can reduce interference with pre- viously acquired capabilities compared with direct SFT or policy optimization alone. A Better StabilityâPlasticity Trade-Off. After the final TheoremQA-style adaptation, TYLER HumanEval GPQA GSM8K TheoremQA 0 20 40 60 80 Accuracy (%) (a) Stage 1: Code-style 41.3 18.0 65.2 18.5 HumanEval GPQA GSM8K TheoremQA 0 20 40 60 80 (b) Stage 2: GPQA-style 39.0 25.4 65.0 19.0 HumanEval GPQA GSM8K TheoremQA 0 20 40 60 80 Accuracy (%) (c) Stage 3: GSM8K 38.2 23.1 75.4 19.4 HumanEval GPQA GSM8K TheoremQA 0 20 40 60 80 (d) Stage 4: TheoremQA-style 37.0 22.6 73.4 26.3 CodeGPQAGSM8KTheoremQA 30 35 40 Avg. accuracy (%) (e) Macro-average across stages CodeGPQAGSM8KTheoremQA 0 5 10 Forgetting F (f) Retention after sequential adaptation SFTGRPOMemGenTYLERBase CoT Figure 6: Fixed-order continual-learning evaluation on Qwen2.5-1.5B-Instruct. Panels (a)â(d) show benchmark performance after each sequential adaptation stage, with tasks on the horizontal axis and methods grouped by color. The dashed gray line denotes the base Vanilla CoT model. Panels (e)â(f) summarize the macro-average and the stage-wise forgetting scoreF . LowerF indicates stronger retention of previously observed task capabilities. achieves the best score on all four benchmarks: 37.00on HumanEval,22.60on GPQA,73.40on GSM8K, and26.30on TheoremQA. Compared with MemGen, the gains are+4.10,+3.60,+4.80, and+1.40points, respectively. SFT shows sub- stantial improvement on the currently adapted TheoremQA-style task but suffers severe degra- dation on previously adapted domains, leading to the highest final forgetting score of11.90. GRPO and MemGen mitigate this degradation to some ex- tent, while TYLER achieves both the highest final macro-average and the lowest final forgetting score. This indicates a stronger stabilityâplasticity trade- off in the tested sequential adaptation setting. I Computational Efficiency Analysis I.1 Experimental Settings We report end-to-end per-example inference time together with task performance. All methods are evaluated with greedy decoding, batch size 1, iden- tical prompt templates, the same maximum genera- tion length, and the same Qwen3-4B backbone. La- tency is measured after tokenization and excludes data loading, answer extraction, verifier execution, and logging. For each method, we record visible generated tokens and latent tokens. The total token budget is the sum of visible and latent tokens, so la- tent computation is accounted for explicitly rather than treated as free computation. Stageâ Adapted Domain MethodHumanEval GPQA GSM8K TheoremQA Avg. F â âBaseVanilla CoT31.1017.1764.6718.0732.75â 1HumanEval SFT40.2014.9060.3015.4032.70 0.00 GRPO38.5016.1063.4016.8033.70 0.00 MemGen39.6016.7063.8017.3034.35 0.00 TYLER (Ours)41.3018.0065.2018.5035.75 0.00 2GPQA SFT32.5022.2058.7014.8032.05 3.85 GRPO34.8023.7062.2016.2034.23 1.85 MemGen36.9023.2063.3017.8035.30 1.35 TYLER (Ours)39.0025.4065.0019.0037.10 1.15 3GSM8K SFT26.1012.9073.6013.5031.52 7.80 GRPO31.2018.6074.9015.7035.10 4.13 MemGen34.8020.2072.2017.5036.17 2.60 TYLER (Ours)38.2023.1075.4019.4039.03 1.80 4TheoremQA SFT22.408.8057.2024.5028.23 11.90 GRPO28.6014.8067.8025.1034.08 6.48 MemGen32.9019.0068.6024.9036.35 3.63 TYLER (Ours)37.0022.6073.4026.3039.832.27 Table 7: Fixed-order continual-learning evaluation on Qwen2.5-1.5B-Instruct. The downward arrow in the Stage column indicates the top-to-bottom sequential adaptation order. The macro-average is computed over all four evaluation benchmarks at every stage. The forgetting scoreFis computed over task families observed up to the current stage, with lower values indicating better retention. I.2 AccuracyâLatency Tradeoff Figure 7 summarizes the accuracyâefficiency trade- off across GSM8K, MATH-500, TheoremQA, and GPQA-Diamond. The left panel reports macro- average Pass@1 against per-example latency, with marker area proportional to the total generated- token budget. The right panel decomposes the same budget into visible and latent tokens. TYLER reaches the highest average accuracy while staying within a compact compute budget. Compared with CoT, TYLER improves average Pass@1 from56.56to65.78while reducing la- tency from8.42s to6.90s and reducing the total token budget from1050.1to628.4tokens. Com- pared with the strongest prior baseline by accuracy, GRPO, TYLER gains+3.13points with a modest 0.32s latency increase. Compared with MemGen, TYLER is both more accurate and faster: it im- proves average Pass@1 by+4.50points, reduces latency by0.30s, and uses fewer total tokens (628.4 vs. 652.4). I.3 Per-Benchmark Overhead Table 8 breaks down TYLER latency by bench- mark, ordered from easier to harder tasks. The Benchmark Total (s) Synth. (s) Synth. Share (%) GSM8K4.900.387.8 MATH6.300.497.8 Theorem7.490.547.2 GPQA8.900.586.5 Table 8: Per-benchmark latency breakdown for TYLER on Qwen3-4B. Synth. denotes wall-clock time spent in latent reasoning. total latency increases with task difficulty, from GSM8K to GPQA-Diamond, while the wall-clock time spent in latent synthesis remains a small frac- tion of the overall inference time. The synthesis overhead remains stable across benchmarks: latent reasoning accounts for6.5â 7.8%of total inference time. The larger latency on TheoremQA and GPQA-Diamond is therefore driven primarily by longer visible reasoning traces rather than an uncontrolled growth in the latent synthesis module. This behavior matches the in- tended design of TYLER: the router allocates a small number of typed latent computations while the base decoder remains responsible for producing the final visible answer. 6.06.57.07.58.08.5 Latency per example (s) 54 56 58 60 62 64 66 Pass@1 accuracy (%) CoT SFT GRPO SoftCoT Soft-Thinking MemGen SwiReasoning TYLER (a) Accuracy-latency tradeoff 02004006008001000 Average generated tokens CoT SFT GRPO SoftCoT Soft-Thinking MemGen SwiReasoning TYLER 1050.1 495.3 612.9 584.6 850.6 652.4 843.5 628.4 (b) Token budget accounting Figure 7: Computational efficiency on Qwen3-4B, averaged across GSM8K, MATH-500, TheoremQA, and GPQA- Diamond. Each method uses a fixed color across panels. In the token accounting panel, lighter bar segments denote visible tokens and hatched saturated caps denote latent tokens. B O Accuracy (%)Latency (s)Latent Tokens 060.116.350 162.446.627 264.086.8513 565.786.9028 865.957.8544 Table 9: Budget sweep for TYLER on Qwen3-4B, av- eraged across GSM8K, MATH-500, TheoremQA, and GPQA-Diamond. I.4 Budget Sweep Table 9 varies the latent budget on Qwen3-4B. The sweep tests whether TYLER benefits from addi- tional latent computation and whether the gains saturate after a small budget. Most of the gain appears under a small latent budget. Moving fromB O = 0toB O = 2im- proves accuracy by+3.97points with only0.50s additional latency. The full budgetB O = 5fur- ther improves accuracy to65.78, yielding a+5.67 point gain over no latent routing. Increasing the budget toB O = 8adds16latent tokens and0.95s latency but improves accuracy by only0.17points, indicating that the accuracy benefit saturates once the router has enough budget to invoke the most useful latent operators.