Paper deep dive
TED: Training-Free Experience Distillation for Multimodal Reasoning
Shuozhi Yuan, Jinqing Wang, Zihao Liu, Miaomiao Yuan, Haoran Peng, Jin Zhao, Bingwen Wang, Haoyi Wang
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 3/31/2026, 1:30:03 AM
Summary
TED (Training-Free Experience Distillation) is a novel framework for multimodal reasoning that replaces traditional parameter-based knowledge distillation with a context-based approach. Instead of updating model weights, TED extracts generalized reasoning experiences from teacher-student trajectory comparisons and injects them into the student's prompt. It features a teacher-guided compression mechanism to manage experience utility and prevent context bloat, achieving performance competitive with parameter-based methods while reducing training costs by over 20x.
Entities (5)
Relation Signals (3)
TED → utilizes → Experience Compression
confidence 98% · TED addresses this with an experience compression mechanism that tracks usage statistics
TED → improvesperformanceon → MathVision
confidence 95% · Experiments on multimodal reasoning benchmarks MathVision and VisualPuzzles show that TED consistently improves performance.
TED → replaces → Parameter-based Knowledge Distillation
confidence 95% · TED reformulates knowledge distillation from parameter updates to contextual experience reuse.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Knowledge distillation is typically realized by transferring a teacher model's knowledge into a student's parameters through supervised or reinforcement-based optimization. While effective, such approaches require repeated parameter updates and large-scale training data, limiting their applicability in resource-constrained environments. In this work, we propose TED, a training-free, context-based distillation framework that shifts the update target of distillation from model parameters to an in-context experience injected into the student's prompt. For each input, the student generates multiple reasoning trajectories, while a teacher independently produces its own solution. The teacher then compares the student trajectories with its reasoning and the ground-truth answer, extracting generalized experiences that capture effective reasoning patterns. These experiences are continuously refined and updated over time. A key challenge of context-based distillation is unbounded experience growth and noise accumulation. TED addresses this with an experience compression mechanism that tracks usage statistics and selectively merges, rewrites, or removes low-utility experiences. Experiments on multimodal reasoning benchmarks MathVision and VisualPuzzles show that TED consistently improves performance. On MathVision, TED raises the performance of Qwen3-VL-8B from 0.627 to 0.702, and on VisualPuzzles from 0.517 to 0.561 with just 100 training samples. Under this low-data, no-update setting, TED achieves performance competitive with fully trained parameter-based distillation while reducing training cost by over 5x, demonstrating that meaningful knowledge transfer can be achieved through contextual experience.
Tags
Links
- Source: https://arxiv.org/abs/2603.26778v1
- Canonical: https://arxiv.org/abs/2603.26778v1
Trouble viewing inline? Open PDF directly →
Full Text
61,087 characters extracted from source content.
Expand or collapse full text
TED: Training-Free Experience Distillation for Multimodal Reasoning Shuozhi Yuan , Jinqing Wang , Zihao Liu yuansz@chinatelecom.cn China Telecom Digital Intelligence Technology Co.,Ltd.BeijingChina , Miaomiao Yuan Institute of Computing Technology, Chinese Academy of SciencesBeijingChina , Haoran Peng , Jin Zhao , Bingwen Wang and Haoyi Wang China Telecom Digital Intelligence Technology Co.,Ltd.BeijingChina (2026) Abstract. Knowledge distillation (KD) is typically realized by transferring a teacher model’s knowledge into a student’s parameters through supervised or reinforcement-based optimization. While effective, such approaches require repeated parameter updates and large-scale training data, limiting their applicability in resource-constrained environments. In this work, we propose TED, a training-free, context-based distillation framework that shifts the update target of distillation from model parameters to an in-context experience injected into the student’s prompt. For each input, the student generates multiple reasoning trajectories, while a teacher independently produces its own solution. The teacher then compares the student trajectories with its reasoning and the ground-truth answer, extracting generalized experiences that capture effective reasoning patterns. These experiences are continuously refined and updated over time. A key challenge of context-based distillation is unbounded experience growth and noise accumulation. TED addresses this with an experience compression mechanism that tracks usage statistics and selectively merges, rewrites, or removes low-utility experiences. Experiments on multimodal reasoning benchmarks MathVision and VisualPuzzles show that TED consistently improves performance. On MathVision, TED raises the performance of Qwen3-VL-8B from 0.627 to 0.702, and on VisualPuzzles from 0.517 to 0.561 with just 100 training samples. Under this low-data, no-update setting, TED achieves performance competitive with fully trained parameter-based distillation while reducing training cost by over 20×, demonstrating that meaningful knowledge transfer can be achieved through contextual experience. Knowledge distillation; Multimodal reasoning; In-context learning; Training-free learning †copyright: acmlicensed†journalyear: 2026†doi: X.X†conference: Make sure to enter the correct conference title from your rights confirmation email; June 03–05, 2026; Rio de Janeiro, Brazil†isbn: 978-1-4503-X-X/2018/06†ccs: Computing methodologies Knowledge representation and reasoning 1. Introduction Figure 1. TED reformulates knowledge distillation from parameter updates to contextual experience reuse. Knowledge distillation (KD) has become a standard approach for transferring capabilities from multimodal large language models (MLLMs) to smaller ones (Hinton et al., 2015; Liu et al., 2023). Most existing knowledge distillation methods adopt a parameter-based strategy, where the student learns by fine-tuning on large-scale data generated by a teacher, such as soft labels (Taori et al., 2023), rationales (Liao et al., 2025), or reasoning trajectories (Guo et al., 2025). Although effective, these approaches usually rely on gradient-based optimization and repeated parameter updates, which require substantial computational cost (Wang et al., 2023; Chen et al., 2024) and large amounts of training data, limiting their practicality in many resource-constrained or rapidly evolving environments. For real-world use, especially on edge devices (Fang et al., 2026) or black-box APIs (Biggs et al., 2021), updating model parameters is impractical or even impossible. In such cases, efficient adaptation without retraining becomes crucial. This raises an important question: Can knowledge distillation be achieved without updating model parameters? In this work, we answer this question through TED, an alternative formulation of distillation that operates entirely in the model’s context rather than its parameters. As illustrated in Figure 1, unlike traditional distillation methods that encode teacher knowledge into student parameters through optimization, TED reformulates distillation as the continual extraction, abstraction, and reuse of transferable reasoning experiences. These experiences serve as distilled knowledge that guides future inference, enabling the student to improve without any parameter updates. A key distinction between TED and existing memory-based methods is what gets stored and updated. Prior methods such as Reflexion(Shinn et al., 2023) and Memento(Zhou et al., 2025) typically reuse instance-level trajectories, demonstrations, or verbal feedback from previous attempts. In contrast, TED does not treat experience as a cache of past solutions. Instead, it uses teacher supervision to extract abstract, reusable reasoning experiences—such as transferable strategies, common failure patterns, and correction rules—that generalize across inputs. In this sense, TED distills not example-specific traces, but higher-level reasoning guidance. For each input, the student model generates multiple reasoning trajectories in parallel, while a teacher model independently produces its own reasoning process. The teacher then jointly evaluates the student trajectories, its own reasoning, and the ground-truth, and abstracts generalized experiences that capture effective reasoning patterns, common failure modes, and correction strategies. Crucially, these experiences are not task-specific exemplars or raw demonstrations, but compact and reusable reasoning principles distilled under teacher supervision. These experiences are accumulated across training samples and iteratively refined, forming a persistent experience that evolves over time. During inference, the learned experience is directly injected into the system prompt, allowing the student model to benefit from distilled knowledge without any parameter updates. This formulation enables TED to operate under strict constraints on training cost and model scale, while remaining compatible with standard black-box APIs. A key challenge in context-based distillation is that naively accumulating experiences leads to unbounded context growth and low-utility information. TED addresses this challenge through a teacher-guided experience compression mechanism that explicitly models experience utility. Instead of performing simple summarization or heuristic pruning, TED tracks the usage frequency of individual experience items and retains high-utility experiences while selectively merging, rewriting, or removing others under teacher supervision. This compression process abstracts higher-level reasoning patterns from frequently co-occurring experiences and eliminates obsolete or noisy information, ensuring that the in-context experience remains compact, informative, and scalable over long training iterations. We evaluate TED on multimodal mathematical reasoning and logic benchmarks (Zhang et al., 2024; Wang et al., 2024b; Song et al., 2025; Xiao et al., 2024; Math-AI, 2024; Zhang and Team, 2025) using open-source vision-language models (Bai et al., 2025; Team et al., 2026). Despite performing no parameter updates and using only 100 training samples, TED achieves substantial performance improvements over direct inference. In particular, TED provides a strong performance-cost trade-off in low-data settings, approaching the gains of conventional parameter-based distillation while reducing training cost by more than 20×. These results demonstrate that effective knowledge transfer can be realized through contextual experience, offering a lightweight and practical alternative to traditional parameter-based distillation. Our main contributions in this paper are as follows: • We propose TED, a training-free, context-based knowledge distillation framework that enables effective knowledge transfer without any parameter updates. • TED introduces a teacher-guided experience generation and compression mechanism that distills reusable reasoning principles and maintains a compact, high-utility in-context experience. • Experiments on multimodal and textual reasoning benchmarks show that TED substantially improves model performance in low-data settings. Using only 100 training samples, TED achieves performance competitive with conventional distillation while reducing training cost by more than 20×. 2. Related Work In this section, we provide an overview of related work on knowledge distillation, in-context learning and other training-free distillation approaches, highlighting their relevance and main differences to our proposed method. 2.1. Knowledge Distillation Knowledge distillation, as pioneered by (Hinton et al., 2015), has become a basic approach for transferring the capability from a large teacher model into a compact student model. In the area of large language models, numerous approaches are proposed to address the task. For instance, instruction-based approaches like Self-Instruct(Wang et al., 2023) and Alpaca (Taori et al., 2023) use teacher models to generate large-scale synthetic datasets for student fine-tuning. Furthermore, reasoning-based methods like Distilling Step-by-Step (Hsieh et al., 2023) extract rationales from the teacher to guide the student’s learning process. Recent reasoning-focused frameworks, such as Beyond Answers (Tian et al., 2024) and NesyCD(Liao et al., 2025) , have further improved the quality of rationales by incorporating multi-teacher feedback or symbolic knowledge. Additionally, methods like DeepSeek-R1(Guo et al., 2025) demonstrate that distilling long-chain reasoning patterns can significantly boost the performance of smaller open-source models. From the analysis of existing knowledge distillation methods, it becomes clear that most approaches transfer knowledge by updating student model parameters through large-scale optimization, relying on extensive training data and computational resources. Such parameter-centric designs limit their applicability in black-box, resource-constrained, or rapidly evolving settings. In contrast, our core motivation is to enable effective knowledge distillation without any parameter updates. To this end, we propose TED, which shifts distillation from parameter optimization to context-level experience accumulation, allowing knowledge to be distilled, compressed, and reused entirely through prompts. 2.2. Multimodal Knowledge Distillation With the rise of multimodal large language models (MLLMs), knowledge distillation has extended from pure text to cross-modal reasoning. Early works like MiniGPT-4 (Zhu et al., 2023) and LLaVA (Liu et al., 2023) focus on aligning visual features with language spaces using teacher-generated data. Recently, more advanced methods attempt to distill specialized capabilities. For instance, Vigstandard (Wang et al., 2024a) explores distilling visual grounding capabilities. Similar to the challenges in text-only distillation, MLLM distillation often faces high computational costs due to the large scale of vision-language projectors and encoders. Recent efforts like ShareGPT4V (Chen et al., 2024) emphasize the quality of teacher-generated captions and rationales to improve student performance with less data. However, most of these MLLM distillation methods still rely on fine-tuning parameters. Our work, TED, offers a potential paradigm shift by demonstrating that multimodal reasoning experiences could also be distilled and accumulated at the context level, potentially bypassing the need for expensive cross-modal fine-tuning. 2.3. In-context Learning In-context learning allows models to perform new tasks by providing a few additional inputs in the prompt without updating any parameters(Brown et al., 2020). To improve reasoning performance, Chain-of-Thought (Wei et al., 2022) and retrieval-based methods like ERP (Rubin et al., 2022) have been proposed to provide reasoning steps or relevant demonstrations. Recent advances, such as Reflexion (Shinn et al., 2023) and Long-context ICL (Bertsch et al., 2025), further use iterative feedback or larger context windows to improve performance. These studies suggest that in-context learning is a practical way to adapt models without parameter updates. However, most existing methods focus on improving prompt design for individual inputs, such as selecting demonstrations or adding feedback, and do not explicitly model how knowledge can be accumulated across examples. In contrast, TED builds on in-context learning but focuses on experience accumulation. By distilling and reusing reasoning experiences under teacher guidance, TED enables knowledge transfer across inputs in a parameter-free manner. 2.4. Training-free Distillation To further reduce the cost of knowledge transfer, recent research has explored training-free distillation and memory-based learning. For instance, AHA(Li et al., ) and AgentDistill (Qiu et al., 2025) facilitate knowledge transfer by collecting successful trajectories and reusing them in the inference stage without any weight updates. More recently, Memento (Zhou et al., 2025) introduces a paradigm that allows models to ”learn from experience” by storing past successes and failures in an external mental filing cabinet. To address the efficiency issues of large memories, methods like MemCom (Khatri et al., 2025) have been proposed to compress many-shot demonstrations into compact representations. However, many training-free distillation and memory-based methods mainly reuse raw examples or fixed past trajectories at inference time. When knowledge is treated as a set of instance-level demonstrations, the memory can become noisy and does not generalize well across different inputs. In contrast, TED runs an on-policy-like distillation loop: for each training input, the student samples multiple reasoning trajectories, and the teacher scores them based on the teacher’s own solution and the ground-truth supervision. This trajectory-level comparison allows TED to extract and store abstract experiences (i.e., reusable reasoning tips and common failure patterns), instead of keeping example-specific traces. As a result, TED maintains a compact experience that is continuously updated and is more robust than standard many-shot retrieval when facing noisy or hard cases. Figure 2. Overview of TED. Our proposed method includes three stages: trajectory generation, experience generation, and experience compression. The student first samples multiple reasoning trajectories, which the teacher critiques against its own reasoning and the ground truth to distill generalized experiences. These experiences are then compressed and injected into the system prompt for iterative, parameter-free improvement. 3. Formulation We formulate knowledge distillation with a shared on-policy sampling and teacher judging protocol(Agarwal et al., 2024). The difference lies in the update target: vanilla KD updates parameters, while TED updates an in-context experience. 3.1. On-policy distillation protocol Considering supervised examples (x,y)(x,y), where x is the input and y is the ground-truth. Let S denote the student model and T the teacher model. For each input x, the student samples K reasoning trajectories τii=1K\ _i\_i=1^K, where each trajectory τ contains intermediate reasoning and a final answer y^(τ) y(τ). Independently, the teacher generates its own trajectory τT _T. A teacher judging module then produces trajectory-level feedback which may incorporate correctness w.r.t. y and teacher preference. (1) ri=Judge(τi,τT,y),r_i= Judge ( _i, _T,y ), This sampling-and-judging step is shared by both vanilla KD and our parameter-free approach. 3.2. Vanilla KD In vanilla knowledge distillation, the student has trainable parameters θ, and the teacher feedback is converted into a learning signal to optimize θ. A generic on-policy KD objective can be written as (2) minθ(x,y)∼τ∼Sθ(⋅∣x)[ℒKD(θ;x,τ,τT,y)], _θ\ E_(x,y) \ E_τ S_θ(· x) [L_KD (θ;\ x,τ, _T,y ) ], where ℒKDL_KD denotes the distillation objective, which can be instantiated as maximizing the likelihood of the best-scored trajectory, preference-based ranking, or reinforcement-style objectives using r(τ)r(τ).Training proceeds via repeated gradient updates can be described as: (3) θ←θ−η∇θℒKD.θ←θ-η _θL_KD. While effective, this approach requires parameter updates and typically large-scale optimization. 3.3. TED TED freezes model parameters and performs distillation by updating a contextual experience E that is injected into the student’s prompt. We denote the prompted context by (4) p(x;E)=[psys;E;x],p(x;E)=[p_sys;\ E;\ x], where psysp_sys is a fixed system instruction and E are experience items in the textual prefix. The student then samples on-policy trajectories conditioned on this context: (5) τi∼S(⋅∣p(x;E)). _i S(· p(x;E)). Instead of optimizing θ, TED updates the experience using teacher feedback: (6) E←Update(E;x,y,τii=1K,τT,rii=1K),E← Update (E;\ x,y,\ _i\_i=1^K, _T,\r_i\_i=1^K ), where Update extracts generalized experience items (reusable reasoning tips and common failure modes) from the comparison among student trajectories, the teacher trajectory, and the ground-truth, and incorporates them into E. Specifically, Update is realized as a set of actions generated by teacher model. At inference time, experience transfer is achieved purely through prompting: (7) τ∼S(⋅∣p(x;E)),y^=y^(τ) \ aligned τ& S(· p(x;E)),\\ y&= y(τ) aligned . 3.4. Core difference Despite sharing the same on-policy sampling and teacher-judging protocol, the two approaches differ in the optimization variable. Vanilla KD updates student parameters via gradient-based optimization, whereas TED freezes parameters and updates a persistent in-context experience serialized into the prompt for subsequent rollouts and inference. (8) KD: θ←θ−η∇θℒTED: E←Update(E;⋅) \ aligned KD: &θ←θ-η _θL\\ TED: &E← Update(E;·) aligned . 4. TED Framework As shown in Figure 2, the TED framework consists of three key steps: reasoning trajectory generation, experience generation, and experience compression. Reasoning trajectory generation allows both the student and teacher models to generate their respective reasoning trajectories. Experience generation creates abstract, reusable experience templates based on the teacher model’s reasoning path, the student’s multiple reasoning paths, and the ground truth. Experience compression further compresses and refines these experiences to prevent context explosion and excessive noise introduction. A detailed explanation of each step is provided in the subsequent section. 4.1. Reasoning Trajectory Generation Given an input–label pair (x,y)(x,y), TED performs on-policy reasoning trajectory generation for both the student and the teacher models. The student model S samples N reasoning trajectories in parallel: (9) τ~ii=1N∼S(⋅∣p(x;E)),\ τ_i\_i=1^N S(· p(x;E)), where each raw trajectory τ~ τ contains intermediate reasoning traces and a final answer. In parallel, the teacher model T generates its own raw reasoning trajectory: (10) τ~T∼T(⋅∣x). τ_T T(· x). 4.1.1. Trajectory compression Raw reasoning traces from the student and teacher models often contain redundant or noisy content, such as verbose explanations, self-corrections, or exploratory detours. To make the reasoning paths more concise and reusable, we apply a self-condensation step to each trajectory. Specifically, for any τ~ τ, we ask the same model to rewrite the reasoning into a concise trajectory through prompt engineering. (11) τ=Condense(τ~),τ= Condense( τ), where the condensed trajectory τ is required to follow a same structured format: Premises→Step 1→Step 2→⋯→Conclusion.Premises\;→\;Step 1\;→\;Step 2\;→\;·s\;→\;Conclusion. This process removes unnecessary content while keeping the key reasoning steps that lead to the final answer. We apply this step to all student trajectories τ~ii=1N τii=1^N and the teacher trajectory τ~T τT, resulting in τii=1N _ii=1^N and τT _T. 4.1.2. Teacher trajectory filtering. To ensure reliable teacher guidance, we only retain teacher trajectories that correctly derive the ground-truth answer. Formally, a teacher trajectory τT _T is considered valid if (12) y^(τT)=y. y( _T)=y. For samples where the teacher fails to produce a correct reasoning trajectory, we treat them as negative cases and use them to construct critique experience. Through parallel student sampling, structured trajectory condensation, and teacher filtering, TED produces a set of clean and comparable reasoning trajectories. These trajectories serve as the foundation for subsequent experience generation and compression. Figure 3. Overview of the Experience Compression module in TED. When the experience exceeds the context budget, TED estimates each experience’s utility and tracks its usage frequency. The teacher then compresses the experience by merging, rewriting, deleting, or retaining experiences, producing a compact system prompt that preserves high-utility knowledge for efficient, parameter-free iterative improvement. 4.2. Experience Generation Based on the compressed reasoning trajectories, TED constructs and updates a reusable experience through teacher-driven critique. Given the student trajectories τii=1N\ _i\_i=1^N, the teacher’s valid trajectory τT _T, and the ground-truth label y, the teacher model analyze differences between correct and incorrect reasoning paths and extract generalized experience. 4.2.1. Teacher critique. The teacher jointly considers (i) multiple student reasoning trajectories, (i) its own correct reasoning trajectory, and (i) the ground-truth answer, and produces critiques that identify effective reasoning patterns, common failure modes, and corrective guidance. Formally, we denote the critique process as (13) =Critique(τii=1N,τT,y),C= Critique (\ _i\_i=1^N, _T,y ), where C represents a set of candidate experience statements expressed in natural language. 4.2.2. Experience update actions. TED maintains experience E=ejj=1|E|E=\e_j\_j=1^|E|, where each item e encodes a reusable reasoning guideline or error pattern. Instead of updating model parameters, TED updates E by allowing the teacher to perform one of four discrete actions on the experience: • Add: generate a new experience item and insert it into E; • Modify: revise an existing experience item to improve correctness or generality; • Delete: remove an obsolete or harmful experience item from E; • None: take no action and keep E unchanged. 4.2.3. Positive-negative sample balance. To ensure stable experience generation, we control the balance between positive and negative student trajectories. For each input x, the N student-generated trajectories are divided into correct and incorrect sets according to their final answers. We require the number of correct trajectories to be no smaller than the number of incorrect ones: (14) |τi∣y^(τi)=y|≥|τi∣y^(τi)≠y|. |\ _i y( _i)=y\ |\;≥\; |\ _i y( _i)≠ y\ |. If no correct trajectory is produced, we keep only one negative trajectory to generate a critical experience. Through teacher critique, experience updates, and iterative refinement on balanced samples, TED builds an evolving experience that replaces parameter updates as the main mechanism for knowledge distillation. 4.3. Experience Compression As training proceeds, the experience set E may grow beyond the context limit and accumulate redundant or noisy items. TED therefore compresses E to keep it compact while retaining useful information. 4.3.1. Compression trigger. Let B denote the maximum context budget measured in tokens, and let ℓ(e) (e) be the serialized length of an experience item e. Compression is triggered whenever (15) ∑e∈Eℓ(e)>B|E|>Bitem cases _e∈ E (e)>B\\ |E|>B_item cases where BitemB_item denotes the maximum number of experience items. 4.3.2. Usage statistics and utility score. TED maintains usage statistics for each experience item across training. Let ut(e)∈ℝ≥0u_t(e) _≥ 0 denote the accumulated usage frequency of item e up to step t. After processing sample (xt,yt)(x_t,y_t), the usage counter is updated as (16) ut(e)=ut−1(e)+[e∈U(E;xt)],u_t(e)=u_t-1(e)+I [e∈ U(E;x_t) ], where U(E;xt) U(E;x_t) denotes the subset of experience items injected for input xtx_t, and [⋅]I[·] is the indicator function. During each forward inference, the model reports the IDs of the experience items it uses. We then count how many times each item is used. We define a utility score st(e)s_t(e), (17) st(e)=log(1+ut(e)).s_t(e)= (1+u_t(e)). 4.3.3. Teacher-guided compression. At compression time, the teacher summarizes the experience into a smaller set E E. For a group of experience items, the teacher selects one of the following actions: • Merge: replace a set of redundant items with a single higher-level experience; • Rewrite: rephrase an item to improve generality and applicability; • Delete: remove obsolete, noisy, or harmful items; • None: retain unchanged. 4.3.4. Utility-aware selection. During training, TED maintains usage statistics for each experience item. At compression time, the teacher performs utility-aware selection based on the accumulated usage frequency. Specifically, only the top-R most frequently used experiences are retained, while the remaining experiences are either merged with similar items or removed. 5. Experiments To evaluate the performance of our TED, we present the implementation details, explain the experiments results, and offer a thorough analysis. 5.1. Datasets We conducted experimental evaluations on multimodal mathematical reasoning benchmarks and visual logic benchmarks, including MathVision(Wang et al., 2024b) and VisualPuzzles(Song et al., 2025). In addition, we performed experiments on purely textual mathematical reasoning datasets. To ensure the reliability and robustness of our results, each problem was independently evaluated five times. We report the average score as Mean@5. (18) Mean@5=1N∑i=1N(15∑j=15si,j)Mean@5= 1N _i=1^N ( 15 _j=1^5s_i,j ) where N denotes the total number of problems, and si,js_i,j is the score obtained on the i-th problem in the j-th independent evaluation. 5.2. Base Models In this paper, we adopt the Qwen3-VL (Bai et al., 2025) series as our student model and Kimi-K2.5(Team et al., 2026) as our teacher model, given the leading performance in the field of reasoning. We evaluate the effectiveness of our framework across multiple model sizes, including 8B and 235B, to demonstrate its ability to enhance models. To further explore the abilities of pure language models, we adopt Qwen3(Yang et al., 2025) series as student model and Kimi-k2.5 as teacher model. 5.3. Hyper-parameters In order to ensure the stability of our experiment results, we standardized the hyper-parameters as follows. The temperature is fixed at 0.7, the top-p parameter is set to 1.0, and the max-token length is 32768. The max experience item is set to 15 and max context budget is 4000. 5.4. Experimental Results Across all benchmarks, TED consistently improves over direct inference. Although fully trained knowledge distillation achieves the best overall performance, TED still obtains strong results with only a few hundred training samples and without updating model parameters. This makes TED a lightweight and practical alternative in low-data or resource-constrained settings. The results of all other baseline methods are obtained using their publicly available code. 5.4.1. Results on the Multimodal Mathematical Reasoning We randomly sample 100 examples from MathVerse for training and evaluate on MathVision. The learning process runs for 3 epochs with a batch size of 5 and a group size of 5. For comparison, the Naive-KD baseline is trained on the full 3940-sample MathVerse set. All models are evaluated in thinking mode. As shown in Table 1, TED consistently improves over direct inference despite using only a small number of training samples. For Qwen3-VL-8B, TED improves accuracy from 0.627 to 0.702, and for Qwen3-VL-235B, from 0.746 to 0.762. Although fully trained Naive-KD achieves higher absolute accuracy, TED remains competitive without parameter updates and with only 100 training examples. This suggests that distilled experiences stored in context can effectively transfer knowledge from teacher to student, especially for smaller models with limited capacity. Overall, TED offers a lightweight and data-efficient alternative to traditional KD, achieving substantial gains without expensive retraining. Table 2 further compares TED and Naive-KD under the same training data budgets using Qwen3-VL-8B as the student model. TED already performs well with 100 samples (0.702) and improves only slightly as more data is added, suggesting that it can learn useful experiences even in low-data settings. In contrast, Naive-KD depends more on larger training sets, improving from 0.629 with 100 samples to 0.764 with 3000 samples. These results suggest that TED works better in low-data or resource-constrained settings, while Naive-KD benefits more from larger datasets and eventually surpasses TED. Table 1. Results on the MathVision benchmark. Method Train Set Student MathVision Direct – Qwen3-VL-8B 0.627 Direct – Qwen3-VL-235B 0.746 RAG (Rubin et al., 2022) – Qwen3-VL-8B 0.639 RAG – Qwen3-VL-235B 0.751 Few-shot – Qwen3-VL-8B 0.631 Few-shot – Qwen3-VL-235B 0.744 Naive-KD (Agarwal et al., 2024) MathVerse Qwen3-VL-8B 0.729 Naive-KD MathVerse Qwen3-VL-235B 0.795 Reflexion(Shinn et al., 2023) MathVerse Qwen3-VL-8B 0.662 Reflexion MathVerse Qwen3-VL-235B 0.751 Memento (Zhou et al., 2025) MathVerse Qwen3-VL-8B 0.674 Memento MathVerse Qwen3-VL-235B 0.758 MemCom (Khatri et al., 2025) MathVerse Qwen3-VL-8B 0.646 MemCom MathVerse Qwen3-VL-235B 0.741 TED MathVerse Qwen3-VL-8B 0.702 TED MathVerse Qwen3-VL-235B 0.762 Table 2. Comparison of different training data size Method 100 500 1000 3000 TED 0.702 0.707 0.710 0.725 Naive-KD 0.629 0.714 0.722 0.764 5.4.2. Results on the Multimodal Visual Logic To evaluate the generality of our method, we further conduct experiments on multimodal visual logic tasks under the same controlled setup. We randomly sample 100 training examples and evaluate on the VisualPuzzles benchmark, following the same learning setting as in the multimodal mathematical reasoning experiments. As shown in Table 3, TED consistently improves over direct inference on this benchmark. For Qwen3-VL-8B, TED improves performance from 0.517 to 0.561, and for Qwen3-VL-235B from 0.572 to 0.579. Although fully trained Naive-KD remains slightly stronger in absolute performance, TED achieves competitive results without parameter updates and with only a small number of training samples. This shows that context-based knowledge transfer can be a practical and data-efficient option for multimodal reasoning tasks, especially when gradient-based retraining is not preferred or not possible. Table 3. Results on the VisualPuzzles benchmark. Method Train Set Student VisualPuzzles Direct – Qwen3-VL-8B 0.517 Direct – Qwen3-VL-235B 0.572 Naive-KD LogicVista Qwen3-VL-8B 0.566 Naive-KD LogicVista Qwen3-VL-235B 0.582 Reflexion(Shinn et al., 2023) LogicVista Qwen3-VL-8B 0.524 Reflexion LogicVista Qwen3-VL-235B 0.574 TED LogicVista Qwen3-VL-8B 0.561 TED LogicVista Qwen3-VL-235B 0.579 5.4.3. Results on the language only benchmark. We randomly sample 100 training instances from DAPO-Math-17k (Yu et al., 2025) and evaluate on AIME25(Zhang and Team, 2025). The student models are from the Qwen3 series, with Kimi-K2.5 as the teacher. Training runs for 3 epochs with a batch size of 5, using a temperature of 0.7 and a group size of 5 during learning. All hyperparameters are the same as in the multimodal experiments, and Naive-KD is implemented under the same training schedule. All models are evaluated in thinking mode. As shown in Table 4, TED consistently improves over direct inference in the language-only setting. For Qwen3-8B, accuracy increases from 0.673 to 0.733, and for Qwen3-235B from 0.815 to 0.846. This indicates that distilled experience remains effective in pure textual settings without any visual modality. Although Naive-KD achieves the highest absolute performance, TED remains competitive without gradient-based optimization, showing that contextual experience alone can provide meaningful gains in textual mathematical reasoning. The larger improvement on the smaller model further suggests that context-based knowledge transfer is especially beneficial for capacity-limited models. Table 4. Results on the textual AIME25 benchmark. Method Train Set Student Teacher AIME25 Direct – Qwen3-8B – 0.673 Direct – Qwen3-235B – 0.815 Naive-KD DAPO-Math Qwen3-8B Kimi-K2.5 0.792 Naive-KD DAPO-Math Qwen3-235B Kimi-K2.5 0.861 TED DAPO-Math Qwen3-8B Kimi-K2.5 0.733 TED DAPO-Math Qwen3-235B Kimi-K2.5 0.846 5.4.4. Analysis of training costs Table 5. Training cost comparison on MathVerse under the same training budget (100 samples, N=5N=5). Method GPU Hours Monetary Cost ($) Reduction Naive-KD 576 288.0 - TED – 12.6 22.9× We compare the training costs of Naive-KD and TED on MathVerse under the same training budget, using 100 training samples and the same on-policy sampling setting (N=5N=5). For Naive-KD, training is conducted on 8 NVIDIA A800 GPUs for 3 days, resulting in approximately 576 GPU-hours in total. Assuming a rental price of $0.5 per GPU-hour, the overall training cost is about $288. By contrast, TED is training-free and only requires experience updates over the same 100 samples for 3 epochs. In our setting, the entire process finishes within 8 hours. During this procedure, the student model consumes approximately 21 million tokens, while the teacher model consumes about 6 million tokens. Based on the official pricing of Qwen3-VL and Kimi-K2.5, the total cost is only about $12.6. Overall, TED reduces the training cost by more than one order of magnitude compared with Naive-KD, achieving a cost reduction of approximately 22.9×22.9×. These results demonstrate that TED is highly cost-effective, as it avoids expensive gradient-based optimization while still delivering strong performance. (a) Experience Items Experiment (b) Trajectory Nums Experiment (c) Teacher Models Experiment Figure 4. Hyperparameter ablation of TED on MathVision. Performance is affected by the number of experience items, the number of sampled trajectories, and the choice of teacher model. TED performs best with a moderate experience size, more diverse trajectories, and stronger teachers. 5.5. Ablation study To evaluate the effectiveness of our proposed method, we perform several ablation studies using Qwen3-VL-8B and MathVision benchmark. All other settings are kept unchanged. 5.5.1. Effect of Teacher-Guided Experience Table 6. Ablation Study of Teacher-Guided Experience Method Train Set Teacher MathVision Direct – – 0.627 Successful few-shot MathVerse - 0.631 TED MathVerse Qwen3-VL-8B 0.656 TED MathVerse Kimi-K2.5 0.702 As shown in Table 6, successful few-shot yields only a marginal improvement over direct inference (0.627 → 0.631), suggesting that simply retrieving successful examples is not sufficient to substantially enhance reasoning. In contrast, TED with the same student model as teacher (Qwen3-VL-8B) improves performance to 0.656, showing that the gain mainly comes from the experience learning mechanism—iterative critique, refinement, and experience accumulation—rather than from few-shot examples alone. Using a stronger teacher (Kimi-K2.5) further boosts performance to 0.702, indicating that better feedback can produce higher-quality experience and lead to stronger generalization. 5.5.2. Effect of Experience Compression Table 7. Ablation Study of Experience Compression Method Teacher MathVision Direct – 0.627 TED (Full) Kimi-K2.5 0.702 TED W/o Compression Kimi-K2.5 0.594 TED naive cut Kimi-K2.5 0.648 TED random choose Kimi-K2.5 0.632 As shown in Table 7, experience compression is essential for effective experience learning. Without compression, performance drops sharply from 0.702 to 0.594, even below direct inference, showing that simply accumulating more experiences does not help and can instead hurt reasoning due to redundancy and noise. Naive cut (0.648) and random choose (0.632) both recover part of the performance by reducing experience length, but they remain clearly worse than full TED. In contrast, the full compression mechanism produces a compact and informative experience, achieving the best result of 0.702. These results verify the effectiveness of experience compression in making context-based distillation both stable and scalable. 5.5.3. Cross-Modal Experience Transfer Table 8. Cross-modal generalization of experience. Experience source MathVision (Qwen-VL) AIME25 (Qwen) Direct 0.627 0.673 MathVerse 0.702 0.686 DAPO-Math 0.692 0.733 As shown in Table 8, TED demonstrates effective cross-modal transfer. Experience learned from multimodal MathVerse not only improves MathVision (0.627 → 0.702) but also brings gains on the text-only AIME25 benchmark (0.673 → 0.686). Similarly, experience learned from text-only DAPO-Math improves AIME25 more substantially (0.673 → 0.733) and also transfers well to multimodal MathVision (0.627 → 0.692). Although same-modality transfer yields the largest gains, the consistently positive cross-modal results show that TED captures transferable reasoning knowledge beyond modality-specific patterns. 5.5.4. Detailed ablation study We further analyze three key factors of TED on MathVision, as shown in Figure 4. First, increasing the number of experience items consistently improves performance from 0.673 to 0.711 as the number of experience items grows from 5 to 30, showing that richer experience provides more useful reasoning guidance. When the number of experience items is further expanded to 50, performance slightly drops to 0.704, suggesting that overly long experience introduces redundancy and reduces context efficiency. Therefore, to balance cost, context length, and overall performance, we choose 15 experience items as the default setting. Second, increasing the number of sampled trajectories steadily improves performance from 0.664 to 0.716. Even a single trajectory already brings gains, indicating that teacher critique alone can refine reasoning to some extent. However, multiple trajectories provide more diverse correct and incorrect reasoning paths, enabling the teacher to extract more generalizable experience knowledge. Third, TED also benefits from stronger teacher models. Using the student itself as teacher already achieves 0.656, while stronger teachers further improve performance from 0.681 (DeepSeek) to 0.702 (Kimi2.5) and 0.719 (ChatGPT5.2(OpenAI, 2025)). This trend shows that better teachers provide higher-quality supervision for experience extraction, leading to more informative and transferable experience. Overall, these results show that TED is robust to different design choices, and its performance is jointly determined by experience capacity, trajectory diversity, and teacher quality. 6. Conclusion In this paper, we present TED, a parameter-free and context-based knowledge distillation framework that transfers knowledge through contextual experience accumulation rather than gradient-based optimization. By distilling teacher-guided reasoning trajectories into compact and reusable experiences, TED enables student models to continually improve without updating their parameters. Extensive experiments on multimodal reasoning and textual mathematical benchmarks demonstrate that TED consistently improves model performance in low-data settings while requiring only a small number of training samples. Across both multimodal and textual tasks, TED provides a strong performance-cost trade-off and achieves results competitive with conventional parameter-based distillation, while reducing training cost by more than 20× and avoiding parameter optimization. The proposed framework also shows encouraging generalization across different modalities and model scales. At the same time, TED is not intended to replace gradient-based distillation in large-scale settings with abundant data and sufficient resources, where full parameter updates can still achieve stronger performance. These results suggest that substantial knowledge transfer can be achieved through contextual experience injection, making TED a lightweight, data-efficient, and practical alternative for scenarios where conventional retraining is costly or infeasible. References R. Agarwal, N. Vieillard, Y. Zhou, P. Stanczyk, S. R. Garea, M. Geist, and O. Bachem (2024) On-policy distillation of language models: learning from self-generated mistakes. In The twelfth international conference on learning representations, Cited by: §3, Table 1. S. Bai, Y. Cai, R. Chen, K. Chen, X. Chen, Z. Cheng, L. Deng, W. Ding, C. Gao, C. Ge, W. Ge, Z. Guo, Q. Huang, J. Huang, F. Huang, B. Hui, S. Jiang, Z. Li, M. Li, M. Li, K. Li, Z. Lin, J. Lin, X. Liu, J. Liu, C. Liu, Y. Liu, D. Liu, S. Liu, D. Lu, R. Luo, C. Lv, R. Men, L. Meng, X. Ren, X. Ren, S. Song, Y. Sun, J. Tang, J. Tu, J. Wan, P. Wang, P. Wang, Q. Wang, Y. Wang, T. Xie, Y. Xu, H. Xu, J. Xu, Z. Yang, M. Yang, J. Yang, A. Yang, B. Yu, F. Zhang, H. Zhang, X. Zhang, B. Zheng, H. Zhong, J. Zhou, F. Zhou, J. Zhou, Y. Zhu, and K. Zhu (2025) Qwen3-vl technical report. External Links: 2511.21631, Link Cited by: §1, §5.2. A. Bertsch, M. Ivgi, E. Xiao, U. Alon, J. Berant, M. R. Gormley, and G. Neubig (2025) In-context learning with long-context models: an in-depth exploration. In Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers), p. 12119–12149. Cited by: §2.3. M. Biggs, W. Sun, and M. Ettl (2021) Model distillation for revenue optimization: interpretable personalized pricing. In International conference on machine learning, p. 946–956. Cited by: §1. T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. (2020) Language models are few-shot learners. Advances in neural information processing systems 33, p. 1877–1901. Cited by: §2.3. L. Chen, J. Li, X. Dong, P. Zhang, C. He, J. Wang, F. Zhao, and D. Lin (2024) Sharegpt4v: improving large multi-modal models with better captions. In European Conference on Computer Vision, p. 370–387. Cited by: §1, §2.2. L. Fang, X. Yu, J. Cai, Y. Chen, S. Wu, Z. Liu, Z. Yang, H. Lu, X. Gong, Y. Liu, et al. (2026) Knowledge distillation and dataset distillation of large language models: emerging trends, challenges, and future directions. Artificial Intelligence Review 59 (1), p. 17. Cited by: §1. D. Guo, D. Yang, H. Zhang, J. Song, R. Zhang, R. Xu, Q. Zhu, S. Ma, P. Wang, X. Bi, et al. (2025) Deepseek-r1: incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948. Cited by: §1, §2.1. G. Hinton, O. Vinyals, and J. Dean (2015) Distilling the knowledge in a neural network. Computer Science 14 (7), p. 38–39. Cited by: §1, §2.1. C. Hsieh, C. Li, C. Yeh, H. Nakhost, Y. Fujii, A. Ratner, R. Krishna, C. Lee, and T. Pfister (2023) Distilling step-by-step! outperforming larger language models with less training data and smaller model sizes. In Findings of the Association for Computational Linguistics: ACL 2023, p. 8003–8017. Cited by: §2.1. D. Khatri, P. Kulkarni, N. Gupta, Y. Varun, L. Peng, J. Yagnik, P. Netrapalli, C. Hsieh, A. Go, I. S. Dhillon, et al. (2025) Compressing many-shots in in-context learning. arXiv preprint arXiv:2510.16092. Cited by: §2.4, Table 1. [12] J. Li, J. Williams, N. McKenna, A. Askari, N. Wilson, and R. Cheng Agents help agents: exploring training-free knowledge distillation for small language models in data science code generation. Cited by: §2.4. H. Liao, S. He, Y. Xu, Y. Zhang, K. Liu, and J. Zhao (2025) Neural-symbolic collaborative distillation: advancing small language models for complex reasoning tasks. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 24567–24575. Cited by: §1, §2.1. H. Liu, C. Li, Q. Wu, and Y. J. Lee (2023) Visual instruction tuning. Advances in neural information processing systems 36, p. 34892–34916. Cited by: §1, §2.2. Math-AI (2024) American invitational mathematics examination (aime) 2024. Note: Hugging Face dataset Cited by: §1. OpenAI (2025) Introducing gpt-5.2. Note: https://openai.com/index/introducing-gpt-5-2/Accessed: 2026 Cited by: §5.5.4. J. Qiu, X. Juan, Y. Wang, L. Yang, X. Qi, T. Zhang, J. Guo, Y. Lu, Z. Yao, H. Wang, et al. (2025) AgentDistill: training-free agent distillation with generalizable mcp boxes. arXiv preprint arXiv:2506.14728. Cited by: §2.4. O. Rubin, J. Herzig, and J. Berant (2022) Learning to retrieve prompts for in-context learning. In Proceedings of the 2022 conference of the North American chapter of the association for computational linguistics: human language technologies, p. 2655–2671. Cited by: §2.3, Table 1. N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao (2023) Reflexion: language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems 36, p. 8634–8652. Cited by: §1, §2.3, Table 1, Table 3. Y. Song, T. Ou, Y. Kong, Z. Li, G. Neubig, and X. Yue (2025) Visualpuzzles: decoupling multimodal reasoning evaluation from domain knowledge. arXiv preprint arXiv:2504.10342. Cited by: §1, §5.1. R. Taori, I. Gulrajani, T. Zhang, Y. Dubois, X. Li, C. Guestrin, P. Liang, and T. B. Hashimoto (2023) Stanford alpaca: an instruction-following llama model. GitHub. Note: https://github.com/tatsu-lab/stanford_alpaca Cited by: §1, §2.1. K. Team, T. Bai, Y. Bai, Y. Bao, S. Cai, Y. Cao, Y. Charles, H. Che, C. Chen, G. Chen, et al. (2026) Kimi k2. 5: visual agentic intelligence. arXiv preprint arXiv:2602.02276. Cited by: §1, §5.2. Y. Tian, Y. Han, X. Chen, W. Wang, and N. V. Chawla (2024) Beyond answers: transferring reasoning capabilities to smaller llms using multi-teacher knowledge distillation. External Links: 2402.04616, Link Cited by: §2.1. B. Wang, F. Wu, X. Han, J. Peng, H. Zhong, P. Zhang, X. Dong, W. Li, W. Li, J. Wang, et al. (2024a) Vigc: visual instruction generation and correction. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 38, p. 5309–5317. Cited by: §2.2. K. Wang, J. Pan, W. Shi, Z. Lu, H. Ren, A. Zhou, M. Zhan, and H. Li (2024b) Measuring multimodal mathematical reasoning with math-vision dataset. Advances in Neural Information Processing Systems 37, p. 95095–95169. Cited by: §1, §5.1. Y. Wang, Y. Kordi, S. Mishra, A. Liu, N. A. Smith, D. Khashabi, and H. Hajishirzi (2023) Self-instruct: aligning language models with self-generated instructions. External Links: 2212.10560, Link Cited by: §1, §2.1. J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V. Le, D. Zhou, et al. (2022) Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems 35, p. 24824–24837. Cited by: §2.3. Y. Xiao, E. Sun, T. Liu, and W. Wang (2024) Logicvista: multimodal llm logical reasoning benchmark in visual contexts. arXiv preprint arXiv:2407.04973. Cited by: §1. A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv, et al. (2025) Qwen3 technical report. arXiv preprint arXiv:2505.09388. Cited by: §5.2. Q. Yu, Z. Zhang, R. Zhu, …, and M. Wang (2025) DAPO: an open-source llm reinforcement learning system at scale. External Links: 2503.14476 Cited by: §5.4.3. R. Zhang, D. Jiang, Y. Zhang, H. Lin, Z. Guo, P. Qiu, A. Zhou, P. Lu, K. Chang, Y. Qiao, et al. (2024) Mathverse: does your multi-modal llm truly see the diagrams in visual math problems?. In European Conference on Computer Vision, p. 169–186. Cited by: §1. Y. Zhang and M. Team (2025) American invitational mathematics examination (aime) 2025. Note: Hugging Face dataset Cited by: §1, §5.4.3. H. Zhou, Y. Chen, S. Guo, X. Yan, K. H. Lee, Z. Wang, K. Y. Lee, G. Zhang, K. Shao, L. Yang, et al. (2025) Memento: fine-tuning llm agents without fine-tuning llms. arXiv preprint arXiv:2508.16153. Cited by: §1, §2.4, Table 1. D. Zhu, J. Chen, X. Shen, X. Li, and M. Elhoseiny (2023) Minigpt-4: enhancing vision-language understanding with advanced large language models. arXiv preprint arXiv:2304.10592. Cited by: §2.2. Appendix A Limitation and discussion Despite the promising results, TED also has several limitations. The proposed framework is particularly suitable for scenarios with limited training data, restricted computational resources, or black-box APIs, where gradient-based optimization is impractical or unavailable. By operating entirely in the context space, TED avoids parameter updates and significantly reduces training cost. However, in settings with large-scale datasets and sufficient computational resources, gradient-based distillation or fine-tuning methods are still likely to achieve stronger performance, as they can fully update model parameters and exploit larger training signals. From a qualitative perspective, the effectiveness of TED may stem from its ability to reduce the reasoning search space for smaller models. When solving complex problems, small models often face a large and inefficient reasoning search space during the thinking process. The trajectory-based framework of TED iteratively collects reasoning paths and leverages teacher critiques together with positive and negative trajectory comparisons, which gradually constrain the exploration space and guide the model toward more effective reasoning strategies. As a result, even self-distillation or relatively weak teacher models can still provide useful signals that improve performance. When stronger teacher models are used, their reasoning trajectories tend to be more accurate and efficient, leading to higher-quality experience extraction and larger performance gains. In practice, the distilled experiences often function as high-level reasoning patterns or thinking templates, which help smaller models adopt more structured and effective problem-solving strategies. Appendix B Details of prompts This section reports the exact prompts used in our experiments. Inference with experience Please solve the problem in the figure: problem When solving problems, you MUST first carefully read and understand the helpful instructions and experiences: experiences Final answer should be start with Answer for example: Answer: A/B/C/D Inference of teacher Please solve the problem: problem Final answer should be start with <Answer> for example: <Answer:> A/B/C/D Prompt of teacher critique You are given: (1) a problem, (2) multiple solution trajectories generated by a student network, (3) one or more trajectories generated by a teacher network. The objective is to extract generalizable reasoning experiences from the teacher trajectories that can guide and correct the student network in future attempts on structurally similar problems. Student trajectories are labeled with binary rewards: - POSITIVE (reward = 1): successful solutions - NEGATIVE (reward = 0): failed solutions. You must perform a structured comparative analysis before updating experiences. 1. Comparative Trajectory Analysis Teacher Trajectories: - Identify the key strategic decisions and pivotal reasoning steps. - Analyze how critical decision points, ambiguities, and potential pitfalls are resolved. - Distill recurring reasoning patterns that contribute to correctness. Student Trajectories: Positive Trajectories (reward = 1): - Identify strategies that directly contributed to success. - Analyze alignment with the teacher’s reasoning patterns. - Determine which reasoning components are transferable. Negative Trajectories (reward = 0): - Identify divergence points from successful reasoning paths. - Categorize error patterns, such as: • misapplied principles, • overlooked constraints, • incorrect assumptions, • premature simplifications, • local optimization traps. - Extract partially correct but incomplete reasoning components. Cross Comparison: - Identify decisive differences between positive and negative trajectories. - Determine reasoning strategies consistently applied by the teacher but absent in failed student attempts. 2. Updating the Experience Set Teacher trajectories may include both correct and incorrect reasoning paths. Only extract experiences that reliably promote correct strategic reasoning. You may perform one of the following operations: - "modify": refine an existing experience to improve clarity or correctness. - "add": introduce a new generalizable experience. - "delete": remove an incorrect or misleading experience. - "nan": make no updates if the experience set is already sufficient. 3. Experience Formulation Requirements Each experience must: - Begin with a concise description of the general problem context. - Emphasize strategic reasoning patterns rather than specific computations. - Highlight reusable decision points applicable across similar tasks. - Avoid referencing specific numeric values or problem-dependent details. Prompt of Trajectory compression You are given a problem, and the following rollouts to solve the given problem. Please summarize the trajectory step-by-step: For each step, describe **what action is being taken**. Only the abstract experiences. <problem> problem <problem> <rollouts> rollouts </rollouts> only return the summary of each step, e.g., 1. what happened in the first step and the core outcomes 2. what happened in the second step and the core outcomes Prompt of Experience compression An agent system maintains a set of reasoning experiences. Currently, there are some experiences, which introduces redundancy and weakens strategic clarity. Your objective is to perform experience compression under the FREE framework by consolidating overlapping reasoning patterns and removing duplication. The final number of experiences must not exceed 15. Each resulting experience must satisfy the following criteria: 1. It must express a clear and generalizable strategic lesson, within 32 words. 2. It must begin with a concise general background context. 3. It must focus on reasoning strategies rather than specific computations. 4. It must emphasize transferable decision points applicable to similar problems. 5. It must avoid semantic overlap with other retained experiences. You are provided with: experiences Compression Procedure: 1. Redundancy Analysis - Identify experiences expressing similar strategic principles. - Detect overlap in decision logic, structural reasoning, or error prevention themes. - Group experiences that differ superficially but share core reasoning patterns. 2. Strategic Abstraction - Generalize grouped experiences into a higher-level strategic principle. - Remove problem-specific language. - Preserve critical decision-point structure. 3. Compression Operations You may use the following update operations: - "modify": refine an existing experience to improve abstraction and generality. - "merge": combine multiple similar experiences into one more general and strategically expressive experience. (Merge is the primary mechanism for reducing count.) Appendix C Some examples of experience Some examples of experience E1: For signed quantities with unknown signs, introduce sign variables, enumerate cases systematically, and optimize. Extrema often emerge when sign groups oppose each other. E2: For optimization, push variables to constraints to find bounds, verify attainability. For maximin problems, identify the most restrictive objective to bound the optimum, then ensure others can meet it. E3:For random walk hitting probabilities: model as renewal process, derive first-step recurrence, encode as generating function, analyze dominant singularity for limiting behavior. E4: Geometric algebra: Use mass points with scaled vertex masses for ratios. Or translate to coordinates/vectors, exploit symmetry, compute via formulas, and identify linear relations. E5:Geometry properties: For angle bisectors, use excenter relationships and half-angle formulas. For circle tangents, exploit perpendicularity to form right triangles and apply trigonometric ratios. ...... Appendix D Details of algorithm Input: input–label pair (x,y)(x,y), student model S, teacher model T, experience E, trajectory number N Output: condensed student trajectories τii=1N\ _i\_i=1^N, teacher trajectory τT _T, teacher-validity flag 1 2Construct the prompted context p(x;E)=[psys;E;x]p(x;E)=[p_sys;E;x]; 3 4Sample N student raw trajectories in parallel: τ~ii=1N∼S(⋅∣p(x;E))\ τ_i\_i=1^N S(· p(x;E)); 5 6Generate the teacher raw trajectory: τ~T∼T(⋅∣x) τ_T T(· x); 7 8for i←1i← 1 to N do 9 τi←Condense(τ~i) _i ( τ_i); 10 11τT←Condense(τ~T) _T ( τ_T); 12 13Enforce the structured format: Premises → Step 1 → Step 2 →⋯→·s→ Conclusion; 14 15if y^(τT)=y y( _T)=y then 16 mark τT _T as valid; 17 18else 19 mark τT _T as invalid and treat this sample as a negative case for later critique; 20 21 22return τii=1N,τT\ _i\_i=1^N, _T; Algorithm 1 Reasoning Trajectory Generation in TED Input: student trajectories τii=1N\ _i\_i=1^N, teacher trajectory τT _T, ground-truth label y, experience E Output: updated experience E 1 2Partition student trajectories into +=τi∣y^(τi)=yT^+=\ _i y( _i)=y\ and −=τi∣y^(τi)≠yT^-=\ _i y( _i)≠ y\; 3 4if |+|<|−||T^+|<|T^-| then 5 down-sample −T^- until |+|≥|−||T^+|≥|T^-|; 6 7 8if |+|=0|T^+|=0 then 9 keep only one negative trajectory in −T^-; 10 11 12Generate teacher critique: C=Critique(τii=1N,τT,y)C=Critique(\ _i\_i=1^N, _T,y); 13 14Teacher selects one action from Add,Modify,Delete,None\Add,Modify,Delete,None\; 15 16switch selected action do 17 case AddAdd do 18 insert a new experience item into E; 19 20 case ModifyModify do 21 revise an existing experience item in E; 22 23 case DeleteDelete do 24 remove an obsolete or harmful experience item from E; 25 26 case NoneNone do 27 keep E unchanged; 28 29 30 31return E; Algorithm 2 Experience Generation in TED Input: experience E=ejj=1|E|E=\e_j\_j=1^|E|, context budget B, item budget BitemB_item, step t, current sample (xt,yt)(x_t,y_t) Output: compressed experience E E 1 2foreach e∈U(E;xt)e∈ U(E;x_t) do 3 ut(e)←ut−1(e)+[e∈U(E;xt)]u_t(e)← u_t-1(e)+I[e∈ U(E;x_t)]; 4 st(e)←log(1+ut(e))s_t(e)← (1+u_t(e)); 5 6 7if ∑e∈Eℓ(e)>B _e∈ E (e)>B or |E|>Bitem|E|>B_item then 8 retain only the top-R most frequently used / highest-utility experiences; 9 10 Teacher summarizes E into a smaller set E E; 11 12 foreach candidate item or item group in E do 13 select one action from Merge,Rewrite,Delete,None\Merge,Rewrite,Delete,None\; 14 15 switch selected action do 16 case MergeMerge do 17 replace redundant items with one higher-level experience; 18 19 case RewriteRewrite do 20 rephrase an item to improve generality and applicability; 21 22 case DeleteDelete do 23 remove obsolete, noisy, or harmful items; 24 25 case NoneNone do 26 retain the item unchanged; 27 28 29 30 31else 32 E^←E E← E; 33 34 35return E E; Algorithm 3 Experience Compression in TED