Trace2Tower: Transition-Aware EigenTrace Induction of Multi-Level Skills for LLM Agents Jiazheng Sun∗1 , Boyu Yang∗1 , Binhao Yuan1 , Mingxuan Li1 , Xin Peng1 1
College of Computer Science and Artificial Intelligence, Fudan University Shanghai 200433, China
arXiv:2609.05261v1 [cs.AI] 4 Sep 2026
Abstract Large language model agents increasingly rely on execution traces to master complex interactive tasks. However, current paradigms are bottlenecked by shallow trajectory retrieval and flat skill summarization, fundamentally ignoring the temporal dependencies and outcome-conditioned topology of agent behavior. We introduce Trace2Tower, a transition-aware EigenTrace framework that distills raw trajectories into a robust skill hierarchy. Trace2Tower abstracts step-level interactions into canonical events, constructing a unified graph governed by semantic compatibility, transition dynamics, and outcome evidence. Through a novel contrastive spectral decomposition, it isolates stable, success-aligned behavioral modes while rigorously suppressing failure-prone shortcuts. These modes organically populate a dynamic skill tower of action templates, procedural routines, and overarching task strategies, continuously refined via verifier-guided feedback. On ALFWorld, Trace2Tower achieves 87.31% success requiring only 10.35 steps and 0.26 invalid actions; on WebShop, it reaches 50.67% exact success. Across both benchmarks, Trace2Tower significantly outperforms existing baselines in task mastery and context-efficient experience reuse.
Code — https://github.com/FudanSELab/Trace2Tower
Introduction LLM agents are increasingly expected to improve through continued interaction rather than address each task in isolation (Song et al. 2024b; Wang et al. 2026b). In interactive environments, agent behavior develops through a sequence of observations, actions, state changes, and feedback signals (Hu et al. 2025). The value of an action therefore depends not only on its immediate effect, but also on how it shapes later decisions and the final outcome. Historical trajectories preserve this decision process and provide a rich source of behavioral knowledge beyond the pretrained model (Song et al. 2024a). They reveal effective action patterns, useful intermediate states, recovery procedures, and long-term strategies that support successful execution (Fu et al. 2024; Agashe et al. 2024). However, raw trajectories are difficult to reuse directly. They are often lengthy, redundant, and closely tied to specific tasks (Hu et al. 2025; Yang et al. 2025). They may also contain unnecessary exploration and unsuccessful behavioral branches that should not be reused indiscriminately (Song et al. 2024b). The central challenge is therefore ∗
These authors contributed equally.
to transform diverse execution traces into compact and reliable behavioral structures that retain decision patterns while removing task-specific noise and failure-related shortcuts. Existing studies mainly address this challenge through experience reuse and skill construction. Experience-based methods preserve interactions as demonstrations, memories, guidelines, or retrieved experiences and use them to guide future execution (Fu et al. 2024; Agashe et al. 2024; Yang et al. 2025). Skill-based methods further convert accumulated experience into persistent and reusable capabilities organized in skill libraries (Wang et al. 2026b). These directions have shown that historical interactions can improve task success, adaptation, and execution efficiency (Fu et al. 2024; Wang et al. 2026b). Nevertheless, most existing representations remain centered on the content or organization of individual experiences, guidelines, plans, or skills (Fu et al. 2024; Yang et al. 2025; Wang et al. 2026b). They focus primarily on what information should be retained and reused, while behavioral relations among these units remain implicit. Events with similar descriptions may serve different functions during execution, whereas events with different surface forms may support the same procedure (Pysklo, Zhuravel, and Watson 2026). Such representations do not explicitly distinguish reliable execution transitions from failure-related shortcuts or explain how local behaviors compose into success-aligned procedures and task-level strategies (Yu et al. 2026). These limitations have gradually shifted research from the reuse of complete trajectories toward the construction of more general and persistent skills. ExpeL extracts transferable insights from accumulated experience and combines them with relevant demonstrations to support future tasks (Zhao et al. 2024). SkillX organizes reusable capabilities at multiple levels of abstraction for long-term agent learning (Wang et al. 2026a). Trace2Skill further uses both successful and failed executions to extract trajectory-level lessons and consolidate them into reusable skill directories (Ni et al. 2026). This progression from raw experience to structured skill artifacts is reflected in Figure 1. Although these methods improve the organization and reuse of experience, the behavioral structure that supports skill formation remains largely implicit. They do not explicitly identify stable functional groups, reliable execution transitions, or recurring patterns that are associated with success rather than failure. They also provide limited support for modeling how local skills form
ExpeL etc.
Raw trajectories
SkillX etc.
Insight Note
(Skill)
Hierarchical Skills
Atomic Skills Functional Skills Planning Skills
Trace2Skill etc. Success / Fail trajectories
Skill Folder
Skill.md Script.py
Experience transfers BUT structure is missing
What is still missing ? Relations | Which behaviors belong together?
Skills become hierarchical, BUT semantics drive their organization Traces become reusable skills BUT relations remain implicit
Transitions | Which behaviors should follow others? Outcomes | Which patterns lead to success rather than failure?
Composition | How do local skills form procedures and strategies?
Trace2Tower integrates semantic, transition, and outcome evidence to recover success-aligned behavioral structure for reliable skill reuse and composition
Raw Steps
Semantic
...
Symmetrized Weight Matrix Transition
Strategy
Event Segments
...
Procedure
Outcome
Canonical Types
Eigengap Selection & Embedding
Action
Figure 1: From experience reuse to behavioral structure induction. Existing methods transform trajectories into reusable insights or skills, but the underlying behavioral relations remain implicit. Trace2Tower recovers success-aligned behavioral structures through semantic, transition, and outcome-aware EigenTrace induction.
reusable procedures and higher-level strategies. These limitations motivate a structure-aware method that jointly captures semantic relations, execution transitions, task outcomes, and hierarchical composition. To address this problem, we propose Trace2Tower, a transition-aware EigenTrace framework that transforms raw LLM agent trajectories into structured multi-level skills. Trace2Tower abstracts executions into canonical events, constructs an outcome-aware transition graph, and applies contrastive spectral decomposition to discover success-aligned behavioral modes. These modes are organized into an action-, procedure-, and strategy-level skill tower with verifier-guided refinement. Experiments on ALFWorld and WebShop show that Trace2Tower achieves 87.31% task success and 50.67% exact success, while reducing ALFWorld execution steps to 10.35 and invalid actions to 0.26. The main contributions of this paper are summarized as follows: • We propose Trace2Tower, a framework that transforms LLM agent trajectories into structured skills by explicitly capturing behavioral relations, execution dependencies, and outcome information beyond conventional skill extraction and experience accumulation approaches. • We introduce transition-aware EigenTrace induction, which integrates semantic compatibility, transition dynamics, and success/failure evidence into a unified graph and employs contrastive spectral decomposition to uncover stable outcome-aligned behavioral structures. • We develop a hierarchical skill construction and refinement mechanism that organizes induced behaviors into action-, procedure-, and strategy-level skills, enabling compact, transferable, and reliable experience reuse for LLM agents across long-horizon decision-making tasks.
Related Work Agent Experience Learning LLM agents reuse prior interactions through interfaces. ReAct exposes reasoning in the action loop; Reflexion converts feedback into persistent guidance; Voyager stores executable programs; ExpeL combines cross-task insights with retrieved episodes; and SEER retrieves step-level evidence from successful trajectories (Yao et al. 2022b; Shinn et al. 2023; Wang et al. 2023; Zhao et al. 2024; Cui et al. 2025). Memory studies further show that similarity-based experience following can propagate errors or replay misaligned experiences (Xiong et al. 2025). These methods mainly reuse textual memories, demonstrations, trajectories, or artifacts selected by contextual relevance. Such representations do not explicitly preserve which transition enabled success, which branch failed, or which prerequisites preceded later actions. Trace2Tower instead induces these dependencies from trajectories. Skill Library Construction Recent work builds persistent repositories and structured skill graphs for lifelong learning. SkillFlow automates skill discovery; benchmarks assess acquisition and transfer over task streams (Zhang et al. 2026; Li et al. 2026a; Zheng et al. 2025); SkillX refines hierarchical skills (Wang et al. 2026a); and SAGE accumulates skills through sequential interaction (Wang et al. 2026b). Graph of Skills, SkillGraph, and SkillDAG further model inter-skill dependencies for retrieval and evolution (Liu et al. 2026; Li et al. 2026b; Bai et al. 2026). These systems improve curation and selection, but structure is largely defined among existing skill artifacts. They do not explain how recurring execution events form procedures or why compositions align with success. Trace2Tower instead induces levels from semantic, temporal, and outcome relations.
Raw Steps I need an ac adapter with output protection, and price lower than 50.00 dollars. AC Adapter with out...
Result item - ... item - coolm ac to dc 12v... item - ...
Result item - ... item - ... item - busy raising baller...
Canonical Types
Query
Query(constraints)
Select Description
Prev
Features
Prev
SelectCandidate(product)
Buy Now
12v 3.5a
Inspect
I am looking for a busy raising ballers softball tank top for mom that is 100% cotton heather that can be washed in a washing machine. should be large in size and dark in colour, and price lower than 50.00 dollars. women's tank top, ...
Event Segments
Features
Prev
Description
Prev
women
large
black
Buy Now
Return
InspectProductInformation (product, required_attributes)
Configure
ReturnToResults
Purchase
RefineQuery(constraints) ConfigureOptions (product, option_set)
Event Abstraction
Purchase(product)
product
"Coolm adapter" "busy raising ballers" "Google Pixel 6"
I need a long lasting cell phone that is 128 gb, and price lower than 610.00 dollars 128 gb cell phone ...
Result item - ... item - google pixel 6 5g... item - ...
option set
"12V, 3.5A" Description
Prev
Features
Prev
128gb
kinda coral
Buy Now
"women, large, black" "128 GB, coral" "description, features"
required attributes
"features, description" "description, features"
Raw Steps
Figure 2: Event-level abstraction from raw agent trajectories. Trace2Tower converts successful and failed step-level executions into ordered canonical event sequences for subsequent behavioral structure induction. Structured Skill Induction Trace2Skill distills successful and failed trajectories into reusable skill directories (Ni et al. 2026). Recent methods also make skill relations explicit: GraSP compiles skills into dependency graphs for structured execution, while SkillGraph evolves directed relations from trajectories and feedback (Xia et al. 2026; Li et al. 2026b). These approaches organize skill-level structure, whereas Trace2Tower addresses structure before reusable procedures exist. It builds an outcome-conditioned graph over canonical events and contrasts successful and failed transitions before spectral decomposition. Procedures and strategies therefore inherit observed execution order and success alignment rather than relations imposed over an existing skill collection.
where G is the EigenTrace graph and Z = {Z (c) }C c=1 contains spectral representations of its nontrivial components. The objective is a compact hierarchy whose relations are supported by semantic, transition, and outcome evidence.
Problem Formulation
Event-Level Trajectory Segmentation Trace2Tower groups consecutive steps that pursue a shared local objective into canonical events Ei = Φ(τi ). Boundaries follow changes in subgoal, action family, manipulated entity, observed state, or feedback. Each event is summarized as qi,j = Ω(gi , ei,j ), and task-specific entities are replaced by typed arguments before behaviorally equivalent summaries receive a common identity κ(qi,j ) = u. The observed identities form graph nodes V = {vu }m u=1 . With occurrence set Iu = {(i, P j) | κ(qi,j ) = u}, their representation is hu = |Iu |−1 (i,j)∈Iu fϕ (qi,j ), reducing instance-level linguistic variation. This separation preserves two kinds of invariance simultaneously. Typed arguments let the same operation recur across objects and tasks, while the original event order remains available for transition estimation. The graph can therefore share local behavior without flattening the temporal context that determines whether the behavior is executable.
Let D = {(τi , yi )}N i=1 denote interaction histories, where i yi ∈ {0, 1} is task success and τi = ⟨xi,t ⟩Tt=1 . Each xi,t = (gi , oi,t , Ai,t , ai,t , fi,t ) contains the task, observation, available actions, selected action, and feedback. Trace2Tower converts these fragmented steps into the ordered canonical events shown in Figure 2: Ei = Φ(τi ) = ⟨ei,1 , ei,2 , . . . , ei,Mi ⟩,
E = {Ei }N i=1 . (1)
Each event represents a coherent execution stage while preserving sequence, state changes, and outcome evidence. Given D, Trace2Tower learns a structure induction function F : D → T , where T = {S (1) , S (2) , S (3) } forms a three-level skill tower representing action-, procedure-, and strategy-level skills, respectively. The complete induction pipeline is formalized as: D→E →G→Z →T,
(2)
Method Trace2Tower distills accumulated LLM agent trajectories into a robust skill hierarchy via event abstraction, transitionaware EigenTrace construction, and parameter-free contrastive spectral decomposition. The extracted behavioral modes establish skills at the action, procedure, and strategy levels, which are dynamically refined through hierarchical retrieval and verifier feedback.
Semantic
Transition
Success-Conditioned Affinity
Transition Dependency Edge Existence
Outcome
Evidence Strength
Failure-Conditioned Affinity
Semantic Compatibility
Outcome Compatibility
Figure 3: Construction of the transition-aware EigenTrace graph. The outcome-conditioned edge affinities A± uv geometrically ± integrate semantic compatibility suv , transition dependency t± , and outcome compatibility o , which are further gated by an uv uv edge mask Muv and scaled by evidence strength ωuv to yield robust behavioral topologies. Transition-Aware EigenTrace Graph Construction The directed graph in Figure 3 combines three signals. Successful ± ± ± and failed transition counts c± uv give tuv = cuv / max{1, cu }; mapped cosine similarity gives suv ∈ [0, 1]; and trajectorylevel occurrence counts give smoothed outcome tenden± + − cies ρ± up= (nu + 1)/(nu + nu + 2) and compatibility ± ± ± − ouv = ρu ρv . The mask Muv = 1[c+ uv + cuv > 0] retains + − − observed transitions, and ωuv = (cuv +cuv )/(1+c+ uv +cuv ) discounts weak evidence. Their geometric integration requires no manual mixing weights: 1 ± ± 3 A± . uv = Muv ωuv suv tuv ouv
(3)
The matrices A+ and A− therefore encode the same directed event relation under successful and failed outcomes. The three signals play nonredundant roles. Semantics transfers evidence across linguistically varied events, transitions retain executable direction, and outcomes distinguish useful dependencies from failure-correlated shortcuts. Their geometric integration requires every retained edge to have joint support, preventing one high but isolated score from determining the behavioral topology. Contrastive EigenTrace Decomposition To suppress behavioral patterns prevalent in failures, Trace2Tower applies a parameter-free contrastive affinity transformation: + 2 (Auv ) , A+ + A− > 0, uv uv (4) Āuv = A+ + A− uv uv 0, otherwise. This transformation increases with success affinity, decreases with failure affinity, and remains bounded by A+ uv . Its robustness to estimated affinities is formalized below.
Lemma 1 (Contrastive Stability) For x, y ≥ 0, define g(x, y) = x2 /(x + y) when x + y > 0, and g(0, 0) = 0. Then 0 ≤ g(x, y) ≤ x, with g nondecreasing in x and nonb+ , A b− and their increasing in y. For estimated affinities A b̄ transformation A, b̄ − Ā∥ ≤ ∥A b+ − A+ ∥F + ∥A b− − A− ∥F . ∥A F
(5)
The lemma shows that failure suppression does not amplify total estimation error beyond the two input perturbations. Its proof is in Appendix A. Based on the directed contrastive matrix Ā, Trace2Tower constructs the symmetric affinity matrix W , diagonal degree matrix D, and normalized Laplacian L: m X 1 1 Ā + Ā⊤ , Duu = Wuv , L = I − D− 2 W D− 2 , 2 v=1 (6) −1/2 where Duu = 0 for isolated nodes. Zero-degree nodes form singleton procedure groups, whereas positive-degree nodes are partitioned into disjoint connected components SC V ◦ = c=1 Vc . Spectral decomposition is executed independently per component; components smaller than three nodes default to single procedure groups. For each component c with mc = |Vc | ≥ 3, let L(c) be its (c) normalized Laplacian with sorted eigenvalues 0 = λ1 < (c) (c) λ2 ≤ · · · ≤ λmc . Excluding the trivial degree-weighted (c) direction q1 , Trace2Tower dynamically determines the optimal procedure group count via the maximum eigengap: (c) (c) rc = arg max λk+1 − λk . (7)
W =
2≤k≤mc −1
The retained spectral basis and normalized EigenTrace
Symmetrized Weight Matrix
1
Strength in successful trajectories
Success-dominant evidence ratio
0
Eigengap Selection & Embedding
λ 1
largest nontrivial eigengap Removes degree bias preserves strongly connected behavior 0 modes
Index j 1
2
3
4
5
6
7
8
9 10
Spectrum-to-Tower Skill Induction
Action-Level Skills
Procedure-Level Skills
Hierarchical Skill Tower
Strategy-Level Skills
Procedure
Action • Preconditions • Ordered components
• Completion criterion • Recovery branch
Figure 4: From success-aligned EigenTrace decomposition to hierarchical skill tower induction.
(c)
Experimental Setup
(c)
Q(c) = [q2 , q3 , . . . , qr(c) ] ∈ Rmc ×(rc −1) , c (c)
Qu,: (c)
∥Qu,: ∥2
,
u ∈ Vc ,
Post-episode feedback updates utility from empirical reliability, reward improvement, step savings, and invocation cost. Structural evidence then governs splitting, merging, promotion, and down-weighting. Appendix E specifies these operations, and Appendix F gives the complete time and memory analysis; the dominant spectral computation operates component-wise on the sparse behavioral graph.
Experiments
representations are formulated as:
zu =
With successful (n+ σ ) and total (nσ ) invocation counts, empirical reliability is smoothed as ϱσ = (n+ σ + 1)/(nσ + 2). Given a prompt-token cost ℓσ , budget Bt , and dependencyclosed skill universe Ht , the optimal hierarchical skill set is retrieved via: X Rt = arg max log (1 + ζt (σ)ϱσ ) . (11) P R∈Ht σ∈R σ∈R ℓσ ≤Bt
Strategy
Action Template • Preconditions • Typed arguments • Action pattern • Expected effect • Termination / failure cues
and path construction are provided in Appendix D. During deployment, encoded context ξt = fψ (g, ot , a1:t−1 ) is matched to each skill’s supporting-event representation h̄σ : ξt⊤ h̄σ 1 + , ∥ξt ∥2 ∥h̄σ ∥2 > 0, ζt (σ) = 2 2∥ξt ∥2 ∥h̄σ ∥2 (10) 0, otherwise.
Z (c) = [zu⊤ ]u∈Vc .
(8)
Nodes with zero-norm representations form singleton groups, while Z = {Z (c) }C c=1 captures the remaining success-aligned topology. The retained eigenvectors solve the normalized spectral relaxation on each component, as characterized in Appendix B. Their empirical stability depends on the separation selected by the eigengap. b (c) − L(c) ∥2 ≤ Theorem 1 (EigenTrace Stability) Let ∥L (c) (c) (c) (c) εc and let ∆c = min{λ2 −λ1 , λrc +1 −λrc }. If ∆c > 2εc , then √ 2 rc − 1εc (c) (c) b ∥ sin Θ(Q , Q )∥F ≤ . (9) ∆c Thus, well-separated behavioral modes remain stable when graph statistics are estimated from finite traces; the exact spectral characterization and proofs are deferred to Appendix C. Hierarchical Skill Induction and Deployment Figure 4 illustrates the skill tower T = {S (1) , S (2) , S (3) }. Action skills map from canonical events. Procedure skills cluster normalized EigenTrace representations using the eigengapselected count; zero-degree nodes and components smaller than three remain isolated groups. For strategy induction, trajectories are compressed into repetition-free procedure sequences, the contrastive graph is rebuilt over procedure groups, and strongly connected components are collapsed. Distinct maximal paths supported by observed successful contrastive edges become strategy skills. Exact clustering
ALFWorld (Shridhar et al. 2020) evaluates household manipulation tasks featuring explicit prerequisite dependencies and state transitions. We evaluate on all 134 solvable valid_unseen tasks across six families, inducing skills from 1,240 No-Skill trajectories collected over 310 training tasks. WebShop (Yao et al. 2022a) assesses web-based search and purchasing behavior over a product catalog. Skills for WebShop are induced from 400 trajectories across 100 training tasks, with all methods benchmarked on a fixed 100task test manifest. Both environments enforce an interaction horizon of 20 steps. For ALFWorld, we report success rate, execution steps, invalid action, input tokens, and skill-context character length; for WebShop, we evaluate exact success rate, average reward, and invalid actions. Unless stated otherwise, GPT-5.4 serves as the Skill Author and plan rewriter, while DeepSeek-V4-Flash acts as the Skill User. We evaluate two deployment policies over the same Tower: the High-only policy rewrites three retrieved strategy paths into a compact plan, whereas the Full policy additionally injects up to eight step-aligned procedure skills. We compare against No-Skill, Expert-Crafted, ExpeL (Zhao et al. 2024), SkillX (Wang et al. 2026a), and both the +Combined and +Error variants of Trace2Skill under identical trajectory pools, Skill User, test tasks, and interaction budgets. Table 1 reports the mean and standard deviation across three independent runs; detailed configurations are provided in Appendix G.
Overall Performance Table 1 shows that both Tower policies consistently outperform baselines across benchmarks. On ALFWorld, Highonly reaches 84.83% success with minimal token and context overhead, while Full achieves a peak success of 87.31%,
ALFWorld
Method Success %↑
WebShop
Steps Invalid Input Skill Context ↓ ↓ Tokens ↓ Chars ↓
Exact Success %↑
Reward ↑
Invalid ↓
No-Skill Expert-Crafted
46.27 ± 5.83 71.39 ± 4.11
15.58 12.01
0.58 0.38
49,052 41,502
0 3,286
40.67 ± 0.58 48.00 ± 0.00
0.6776 ± 0.0044 0.7183 ± 0.0000
0.68 ± 0.03 0.07 ± 0.02
Trace2Skill +Combined Trace2Skill +Error SkillX ExpeL
61.44 ± 2.15 61.19 ± 1.29 78.61 ± 3.53 81.59 ± 0.86
13.91 14.19 12.06 11.50
0.28 0.37 0.40 0.31
67,186 73,447 64,229 52,456
9,508 11,447 10,039 7,469
40.67 ± 0.58 44.00 ± 0.00 49.33 ± 2.08 48.00 ± 0.00
0.5580 ± 0.0084 0.5892 ± 0.0055 0.6922 ± 0.0102 0.6987 ± 0.0101
2.39 ± 0.07 1.81 ± 0.02 0.32 ± 0.04 0.41 ± 0.05
Trace2Tower High-only Trace2Tower Full
84.83 ± 0.86 10.52 87.31 ± 0.75 10.35
0.27 0.26
37,649 44,651
1,966 3,623
48.33 ± 0.58 0.6935 ± 0.0116 0.40 ± 0.06 50.67 ± 2.89 0.7115 ± 0.0183 0.27 ± 0.05
Table 1: Overall performance and inference efficiency on ALFWorld and WebShop across three independent runs. Bold and underline denote the best and second-best automatic methods.
66.42
GPT-5.4 Tower DeepSeek-V4 Flash Tower
88.06
85.82
65.67
79.10
Table 2: ALFWorld success (%) by experience condition and Skill User.
beating ExpeL by 5.72 points and SkillX by 8.70 points with only 10.35 steps and 0.26 invalid actions per episode. The 2.48-point gap between them highlights the value of state-aligned procedural skills beyond a global strategy plan. On WebShop, Full achieves the top exact success rate of 50.67%, outperforming SkillX by 1.34 points and cutting invalid actions from 0.68 in No-Skill to 0.27. High-only reaches 48.33% exact success, showing that procedural skills add a 2.34-point boost when interaction constraints arise, while its 0.7115 reward leads automated methods and approaches the 0.7183 Expert-Crafted benchmark. Figure 7 illustrates that High-only provides cost efficiency while Full maximizes performance over the same Tower. Rather than a full method versus an ablation, they offer complementary deployment choices: High-only prioritizes concise long-horizon guidance, whereas Full uses context budget for state-conditioned execution. Efficiency metrics confirm this design. Compared with SkillX, Full cuts ALFWorld input tokens by 30.5% and injected context by 63.9%, while Highonly further reduces these costs by 15.7% and 45.7% relative to Full. Thus, performance gains stem from structured skill organization rather than context window expansion.
Generalization and Structural Ablations Figure 5 demonstrates that both Tower deployment policies maintain consistently high performance across all six task families on ALFWorld. Full achieves the top success
75.9
100.0
98.1
87.0
92.6
Pick & Place 68.1
79.2
70.8
68.1
87.5
86.1
91.7
90.3
Clean & Place 58.1
86.0
73.1
78.5
89.2
88.2
90.3
95.7
Cool & Place 20.6
68.3
31.7
42.9
81.0
95.2
85.7
87.3
Heat & Place 26.1
69.6
60.9
44.9
63.8
53.6
71.0
72.5
Pick Two & Place 19.6
43.1
43.1
49.0
41.2
66.7
80.4
82.4
80
60
40
20
Tr Ex ac e2 pe To l w er Tr H ac ig e2 h To w er Fu ll
52.99
81.5
Sk ill X
No-Skill
68.5
Mean Success Rate (%)
DeepSeek-V4 DeepSeek-V4 Flash Pro
100
Examine in Light 77.8
N oSk Ex ill pe rtCr af Tr te ac d e2 Sk ill +C Tr ac e2 Sk ill +E
Skill User
Experience
Figure 5: ALFWorld success rates (%) by task family and method. Outlined columns denote the two Trace2Tower deployment policies.
rate on Clean-and-Place, Heat-and-Place, and Pick-Two-andPlace, whereas High-only leads on Pick-and-Place. In contrast, competing baselines exhibit pronounced performance degradation on specific task families despite strong overall averages. This stability indicates that Trace2Tower generalizes effectively across changing prerequisite chains, state transformations, and object multiplicity rather than relying on family-specific skills. To isolate the contribution of each graph component, we perform structural ablations on ALFWorld, where high task diversity and explicit environment feedback facilitate finegrained diagnosis. As shown in Figure 6, removing transition dynamics causes the most severe performance drop, reducing success from 87.31% to 70.15% and shrinking the induced hierarchy from 39 procedures and 118 strategies down to 19 procedures and 76 strategies. Disabling outcome evidence or contrastive affinity lowers success to 73.88%, with the latter collapsing the hierarchy to 10 procedures and 44 strategies. These results confirm that transitions encode necessary execution order, while outcome contrast prevents yet success-
(a) Task Performance
(b) Induced Hierarchy Size Procedure-level
87.31
80
70.15
73.88
73.88
60 40 20
Full
w/o Transition
106
90
Expert
T2S +C
T2S +E
60 39
59.2–63.3
30
19
Full
Frozen Tower
44
39
w/o Outcome
w/o Contrastive Affinity
SkillX
ExpeL
Tower H
80.0–80.8
84.58
82.5–86.7
Graph + Embedding
83.75
81.7–85.8
40
60
80
100
Success Rate (%)
Figure 8: Deployment success and observed range over two held-out ALFWorld sets.
Tower Full
WebShop: Exact Success–Cost Landscape 54 52
(a) Event segments per procedure
70
60
50
50
12 Number of procedures
Exact Success Rate (%)
80
48 46 44 42
8
40
45
50
55
60
Mean Agent Input Tokens (k)
65
70
20
30
40
50
60
6
≤199
12
5
200– 299
(b) Strategy reuse per procedure
11
4
0 40 40
10
300– 399
400– 499
4
500– 599
3
≥600
(c) Procedures per strategy path
11 9
8
8 6 4
4 1 0
0
1–4
5–9
10–14 15–19
≥20
Number of strategy paths
90
80.42
Graph + TF-IDF
10
w/o Transition
ALFWorld: Success–Cost Landscape
Success Rate (%)
61.25
No-Skill
Figure 6: Structural ablation on ALFWorld: (a) success rate and (b) induced procedure and strategy skills. No-Skill
ObservedRange
76
0
w/o w/o Contrastive Outcome Affinity
Deployment Performance
Number of procedures
0
Strategy-level
118
120 Number of Induced Skills
ALFWorld Success Rate (%)
100
47 40
40 31
20
0
2
3
4
70
Mean Agent Input Tokens (k)
Figure 7: Success–cost trade-offs on ALFWorld and WebShop over three runs.
ambiguous relations from dominating the behavioral graph.
Cross-Model Transfer and Feedback Refinement We evaluate cross-model transfer by decoupling the Skill Author from the Skill User. Table 2 compares each user model under No-Skill control against Towers generated by two distinct author models. The Flash-authored Tower improves performance for both user models by 12.69 percentage points. For the Flash user, a GPT-5.4-authored Tower further raises success from 65.67% to 88.06%, achieving 34 paired wins against 4 losses with a p-value of 6.04 × 10−7 . For the Pro user, the margin between 79.10% and 85.82% yields a p-value of .150. These findings show that graph structure transfers robustly across model architectures, while author quality and user capability determine the realized gain. Trace2Tower optimizes deployment from verifier feedback without reconstructing trajectories. Four graph edit operations split heterogeneous Mid evidence, merge compatible procedures, promote supported Mid paths, and downweight harmful High paths. Relation expansion connects candidate pairs, while Pareto selection balances semantic, child, and feedback relevance. As evaluated in Figure 8 across two heldout ALFWorld sets, updating the frozen Tower raises success from 80.42% to 84.58% with TF-IDF and 83.75% with embeddings, confirming that feedback effectively revises future retrieval without re-inducing the Tower.
Hierarchy Organization and Interface Stability Figure 9 demonstrates the functional separation across hierarchy levels. Each of the 39 induced procedures aggregates 352 event segments on average, while strategy paths compose only two to four procedures. Notably, 4 procedures recur in over 20 strategy paths whereas 11 appear in none. High-only
Figure 9: Hierarchy organization: (a) supporting event segments per procedure, (b) strategy-path reuse per procedure, and (c) procedures per strategy path.
thus concentrates on 28 recurrent procedures, whereas Full additionally retrieves specialized Mid-level procedures outside global paths, driving their quality-cost trade-off. Overall, Trace2Tower compresses 13,724 segments into 3,764 quotient nodes to induce 39 procedures and 118 strategies, consuming 16.85% fewer GPT tokens during construction compared to SkillX. We also evaluate stability across four experience interfaces, spanning fixed procedures in Trace2Skill, insights with episodes in ExpeL, queried multi-level skills in SkillX, and relational High and Mid composition in Trace2Tower. Interface stability closely tracks environment structure. In ALFWorld, upfront task family and state disclosures anchor the execution plan, keeping standard deviations for High-only and Full below one percentage point at 0.86 and 0.75 respectively. Conversely, WebShop reveals constraints dynamically through page transitions, increasing sensitivity to site traversal. Consequently, Full and SkillX yield higher standard deviations of 2.89 and 2.08, whereas High-only remains stable at 0.58, confirming that variance reflects dynamic interface sensitivity rather than poor skill transfer.
Conclusion Trace2Tower induces a multi-level hierarchy from semantic, transition, and outcome evidence. It achieves 87.31% ALFWorld success and 50.67% WebShop exact success with efficient execution. Ablations and cross-model transfer validate the induced behavioral structure. Feedback-based graph edits further improve a frozen Tower without re-induction, demonstrating that the hierarchy remains editable after deployment rather than becoming a static skill library tied to its original trajectory pool. Together, these results support compact and adaptable skills across distinct execution environments.
References Agashe, S.; Han, J.; Gan, S.; Yang, J.; Li, A.; and Wang, X. E. 2024. Agent s: An open agentic framework that uses computers like a human. arXiv preprint arXiv:2410.08164. Bai, T.; Wan, Z.; Zhou, P.; Yu, X.; You, Y.; and Tsang, I. W. 2026. SkillDAG: Self-Evolving Typed Skill Graphs for LLM Skill Selection at Scale. arXiv preprint arXiv:2606.03056. Cui, S.; He, A.; Xu, S.; Zhang, H.; Wang, Y.; Zhang, Q.; Wang, Y.; and Xu, B. 2025. Self-Guided Function Calling in Large Language Models via Stepwise Experience Recall. arXiv preprint arXiv:2508.15214. Davis, C.; and Kahan, W. M. 1970. The rotation of eigenvectors by a perturbation. III. SIAM Journal on Numerical Analysis, 7(1): 1–46. Fu, Y.; Kim, D.-K.; Kim, J.; Sohn, S.; Logeswaran, L.; Bae, K.; and Lee, H. 2024. Autoguide: Automated generation and selection of context-aware guidelines for large language model agents. Advances in Neural Information Processing Systems, 37: 119919–119948. Horn, R. A.; and Johnson, C. R. 2012. Matrix analysis. Cambridge university press. Hu, M.; Chen, T.; Chen, Q.; Mu, Y.; Shao, W.; and Luo, P. 2025. Hiagent: Hierarchical working memory management for solving long-horizon agent tasks with large language model. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 32779–32798. Li, X.; Chen, W.; Liu, Y.; Zheng, S.; Chen, X.; He, Y.; Li, Y.; You, B.; Shen, H.; Sun, J.; Wang, S.; Zeng, Q.; Wang, D.; Zhao, X.; Wang, Y.; Chaim, R. B.; Di, Z.; Gao, Y.; He, J.; He, Y.; Jing, L.; Kong, L.; Lan, X.; Li, J.; Li, S.; Li, Y.; Lin, Y.; Liu, X.; Liu, X.; Lyu, H.; Ma, Z.; Wang, B.; Wang, R.; Wang, T.; Ye, W.; Zhang, Y.; Xing, H.; Xue, Y.; Dillmann, S.; and Lee, H.-c. 2026a. SkillsBench: Benchmarking How Well Agent Skills Work Across Diverse Tasks. arXiv:2602.12670. Li, X.; Li, M.; Bao, K.; Ma, Y.; Wang, W.; Liu, D.; and Feng, F. 2026b. SkillGraph: Skill-Augmented Reinforcement Learning for Agents via Evolving Skill Graphs. arXiv preprint arXiv:2605.12039. Liu, D.; Li, Z.; Du, H.; Wu, X.; Gui, S.; Kuang, Y.; and Sun, L. 2026. Graph-of-Skills: Dependency-Aware Structural Retrieval for Massive Agent Skills. arXiv preprint arXiv:2604.05333. Ni, J.; Liu, Y.; Liu, X.; Sun, Y.; Zhou, M.; Cheng, P.; Wang, D.; Zhao, E.; Jiang, X.; and Jiang, G. 2026. Trace2Skill: Distill Trajectory-Local Lessons into Transferable Agent Skills. arXiv:2603.25158. Pysklo, H. M.; Zhuravel, A.; and Watson, P. D. 2026. Agent-diff: Benchmarking llm agents on enterprise api tasks via code execution with state-diff-based evaluation. arXiv preprint arXiv:2602.11224. Shinn, N.; Cassano, F.; Berman, E.; Gopinath, A.; Narasimhan, K.; and Yao, S. 2023. Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366.
Shridhar, M.; Yuan, X.; Côté, M.-A.; Bisk, Y.; Trischler, A.; and Hausknecht, M. 2020. Alfworld: Aligning text and embodied environments for interactive learning. arXiv preprint arXiv:2010.03768. Song, Y.; Xiong, W.; Zhao, X.; Zhu, D.; Wu, W.; Wang, K.; Li, C.; Peng, W.; and Li, S. 2024a. Agentbank: Towards generalized llm agents via fine-tuning on 50000+ interaction trajectories. In Findings of the Association for Computational Linguistics: EMNLP 2024, 2124–2141. Song, Y.; Yin, D.; Yue, X.; Huang, J.; Li, S.; and Lin, B. Y. 2024b. Trial and error: Exploration-based trajectory optimization of LLM agents. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 7584–7600. Wang, C.; Yu, Z.; Xie, X.; Yao, W.; Fang, R.; Qiao, S.; Cao, K.; Zheng, G.; Qi, X.; Zhang, P.; and Deng, S. 2026a. SkillX: Automatically Constructing Skill Knowledge Bases for Agents. arXiv:2604.04804. Wang, G.; Xie, Y.; Jiang, Y.; Mandlekar, A.; Xiao, C.; Zhu, Y.; Fan, L.; and Anandkumar, A. 2023. Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv:2305.16291. Wang, J.; Yan, Q.; Wang, Y.; Tian, Y.; Mishra, S. S.; Xu, Z.; Gandhi, M.; Xu, P.; and Cheong, L. L. 2026b. Reinforcement learning for self-improving agent with skill library. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 1529– 1550. Xia, T.; Hu, L.; Sun, Y.; Xu, M.; Xu, L.; Wang, S.; Xu, W.; and Jiang, J. 2026. Grasp: Graph-structured skill compositions for llm agents. arXiv preprint arXiv:2604.17870. Xiong, Z.; Lin, Y.; Xie, W.; He, P.; Liu, Z.; Tang, J.; Lakkaraju, H.; and Xiang, Z. 2025. How memory management impacts llm agents: An empirical study of experiencefollowing behavior. arXiv preprint arXiv:2505.16067. Yang, W.; Xiao, J.; Zhang, H.; Zhang, Q.; Wang, Y.; and Xu, B. 2025. Coarse-to-fine grounded memory for llm agent planning. arXiv preprint arXiv:2508.15305. Yao, S.; Chen, H.; Yang, J.; and Narasimhan, K. 2022a. Webshop: Towards scalable real-world web interaction with grounded language agents. Advances in Neural Information Processing Systems, 35: 20744–20757. Yao, S.; Zhao, J.; Yu, D.; Shafran, I.; Narasimhan, K. R.; and Cao, Y. 2022b. React: Synergizing reasoning and acting in language models. In NeurIPS 2022 Foundation Models for Decision Making Workshop. Yu, G.; Wang, Z.; Huang, Y.; Zhong, R.; Zhong, Y.; Wang, Y.; and Lyu, M. R. 2026. Why Does the LLM Stop Computing: An Empirical Study of User-Reported Failures in Open-Source LLMs. arXiv preprint arXiv:2601.13655. Yu, Y.; Wang, T.; and Samworth, R. J. 2015. A useful variant of the Davis–Kahan theorem for statisticians. Biometrika, 102(2): 315–323. Zhang, Z.; Shi, K.; Huang, S.; Nie, A.; Zeng, Y.; Zhao, Y.; Fang, Z.; Su, Q.; Qiu, H.; Yang, W.; Ren, Q.; Zou, S.; Huang, W.; Chen, L.; Chen, Z.; and Zhao, F. 2026. SkillFlow:
Benchmarking Lifelong Skill Discovery and Evolution for Autonomous Agents. arXiv:2604.17308. Zhao, A.; Huang, D.; Xu, Q.; Lin, M.; Liu, Y.-J.; and Huang, G. 2024. Expel: Llm agents are experiential learners. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, 19632–19642. Zheng, J.; Cai, X.; Li, Q.; Zhang, D.; Li, Z.; Zhang, Y.; Song, L.; and Ma, Q. 2025. LifelongAgentBench: Evaluating LLM Agents as Lifelong Learners. arXiv:2505.11942.
Appendix This supplementary material provides the complete mathematical proofs, the exact structure-induction procedure, the reported deployment policy, essential implementation settings, and additional analyses.
Appendix A: Proof of Contrastive Stability This appendix proves the Contrastive Stability lemma for the outcome-conditioned affinities used by Trace2Tower. For a directed canonical-event pair (u, v), let x = A+ uv and y = A− uv denote the success- and failure-conditioned affinities in Equation (3). Define 2 x , x + y > 0, g(x, y) = x + y x, y ≥ 0, (12) 0, x = y = 0, − so that Āuv = g(A+ uv , Auv ). For x + y > 0, we have g(x, y) = x x/(x + y). Since 0 ≤ x/(x + y) ≤ 1, it follows that 0 ≤ g(x, y) ≤ x. Moreover, ∂g/∂x = x(x + 2y)/(x + y)2 ∈ [0, 1] and ∂g/∂y = −x2 /(x + y)2 ∈ [−1, 0]. Therefore, the retained contrastive edge is nondecreasing in success affinity and nonincreasing in failure affinity. The definition at (0, 0) is continuous because 0 ≤ g(x, y) ≤ x → 0. Let (x, y) and (x′ , y ′ ) be two nonnegative affinity pairs. Applying the mean-value theorem along the two coordinates gives
|g(x′ , y ′ ) − g(x, y)| ≤ |g(x′ , y ′ ) − g(x, y ′ )| + |g(x, y ′ ) − g(x, y)| ′
(13)
′
≤ |x − x| + |y − y|. The same inequality holds on the boundary by continuity. − ′ ′ b+ Substituting x = A+ uv , y = Auv , x = Auv , and y = b− A uv into Equation (13) yields the corresponding entrywise bound. Taking the Frobenius norm over all matrix entries and applying Minkowski’s inequality gives b̄ − Ā∥ ≤ ∥A b+ − A+ ∥F + ∥A b− − A− ∥F . ∥A F
(14)
This proves the lemma. Importantly, Equation (14) does not require independence between A+ and A− , which are estimated from the same trajectory pool in Trace2Tower. The result therefore isolates a property of the proposed failuresuppression mechanism itself: the contrastive transformation does not amplify total affinity perturbation beyond the sum of its success- and failure-conditioned inputs.
Appendix B: Spectral Relaxation Characterization Consider a positive-degree connected component Vc with symmetric affinity W (c) , degree matrix D(c) , and normalized Laplacian L(c) = I − (D(c) )−1/2 W (c) (D(c) )−1/2 .
(15)
Because the component is connected, the smallest eigenvalue equals zero. Its normalized eigenvector is (c)
q1 =
(D(c) )1/2 1 . ∥(D(c) )1/2 1∥2
(16)
For the eigengap-selected procedure Trace2Tower uses the constrained relaxation min
Q∈Rmc ×(rc −1)
s.t.
count
rc ,
tr(Q⊤ L(c) Q) Q⊤ Q = I,
(c)
Q⊤ q1 = 0.
(17)
By the Rayleigh–Ritz/Courant–Fischer characterization (Horn and Johnson 2012), the minimizing subspace is spanned by the next rc − 1 eigenvectors. Hence one valid optimizer is (c) Q(c) = [q2 , . . . , qr(c) ], (18) c Prc (c) and the minimum objective value is j=2 λj . Right multiplication by any orthogonal matrix gives an equivalent basis of the same subspace. Trace2Tower row-normalizes the retained representation before K-means, and orthogonal transformations preserve Euclidean distances. Therefore, the procedure partition is invariant to this global basis ambiguity. Zero-norm rows have no defined angular direction and are assigned to singleton groups. The symmetrization W = (Ā + Ā⊤ )/2 is used only for procedure discovery. Direction is retained in the original contrastive graph and reintroduced when compressed procedure sequences are used to build the directed Mid-level graph for strategy induction. Thus, the spectral step identifies stable procedure groups without discarding the execution order required by higherlevel strategies.
Appendix C: Proof of EigenTrace Stability b=L b (c) , E = L b − L, Q = [q2 , . . . , qr ], and Let L = L(c) , L c b Q = [b q2 , . . . , qbrc ]. The theorem concerns perturbations on the same component node set; it therefore controls changes in graph weights and the corresponding invariant subspace rather than discrete changes in component membership. Define the separation between the retained EigenTrace block and its complementary spectrum as ∆c = min {λ2 − λ1 , λrc +1 − λrc } .
(19)
Assume ∥E∥2 ≤ εc and ∆c > 2εc . A populationeigengap form of the Davis–Kahan sin-Θ theorem (Davis and Kahan 1970; Yu, Wang, and Samworth 2015) gives b Q)∥2 ≤ 2εc . ∥ sin Θ(Q, (20) ∆c Since the retained subspace has dimension rc − 1, √ b Q)∥2 b Q)∥F ≤ rc − 1 ∥ sin Θ(Q, ∥ sin Θ(Q, √ (21) 2 rc − 1 εc ≤ . ∆c Equation (21) proves the theorem. The result is stated for the invariant subspace rather than individual eigenvectors because repeated or spaced eigenvalues inside the retained block can rotate its basis without changing the procedurerelevant representation. Together with Appendix A, this establishes two distinct robustness properties: the contrastive transformation is stable with respect to errors in A+ and A− , and a sufficiently separated EigenTrace subspace is stable with respect to perturbations of the normalized graph.
Stage
Input
Main operation
Event ab- Raw trajectory straction Graph in- Canonical events duction Contrastive graph Procedure induction Strategy induction Deployment
A+ , A− Ā Procedure quences Skill tower
Segment and canonicalize Semantic + transition + outcome evidence Failure-aware transformation Component-wise spectral clustering se- Directed graph + SCC paths High plan + optional Mid support
Output E A+ , A−
Ā S (2) S (3) Retrieved context
Table 3: Trace2Tower representations and their roles.
Appendix D: Skill-Tower Induction and Deployment Table 3 summarizes how each representation in the main paper is produced and what information it preserves. Each environment interaction is serialized as (g, ot , at , ot+1 , rt ) together with admissible-action information. Benchmark adapters map raw actions to domain event labels, and maximal consecutive runs with the same label form event segments. ALFWorld signatures retain normalized task context, neighboring event labels, segment length, and typed action templates; WebShop additionally retains compact page-state context. The reported representation dimensionality is 4,096. A trajectory is labeled successful when its primary benchmark score is at least 0.999. Node occurrence counts use each node at most once per trajectory, whereas transition counts retain every adjacent occurrence. For an observed transition (u, v), semantic compatibility is suv =
h⊤ 1 u hv + , 2 2∥hu ∥2 ∥hv ∥2
(22)
with suv = 0 if either representation has zero norm. Semantic similarity alone never creates an edge; the transition must have been observed. The remaining graph statistics are − c+ c± uv + cuv uv t± , uv = + − , 1 + cuv + cuv max(1, c± u) q n± u +1 ± ± ρ± = , o = ρ± u ρv . u uv − n+ u + nu + 2
ωuv =
(23)
The affinities A± uv and Āuv then follow Equations (3) and (4). No learned coefficient mixes semantic, transition, and outcome evidence. For procedure induction, zero-degree nodes form singleton groups, while positive-degree nodes are processed component-wise. Components with fewer than three nodes remain single groups. Larger components use the eigengap-selected procedure count in Equation (7) and the EigenTrace representation in Equation (8), followed by Kmeans clustering. We use 20 initializations, a maximum of 300 iterations, and random seed 42. Let C(e) denote the procedure containing event segment e. Each trajectory is
Algorithm 1 Trace2Tower: Transition-Aware Skill-Tower Induction Input: Trajectories D = {(τi , yi )}N i=1 Output: tower T = {S (1) , S (2) , S (3) } 1: for each τi ∈ D do 2: Construct canonical events Ei using Eq. (1) 3: end for 4: Build event nodes V and success/failure statistics 5: for each observed transition (u, v) do 6: Compute A± uv using Eq. (3) 7: Compute Āuv using Eq. (4) 8: end for 9: Construct W , D, and L using Eq. (6) 10: for each component Vc do 11: Select rc using Eq. (7) 12: Construct Z (c) using Eq. (8) 13: Cluster Z (c) into procedure skills 14: end for 15: Set canonical events as action skills S (1) 16: Collect induced procedures as S (2) 17: Retain maximal success-supported paths as S (3) 18: return T = {S (1) , S (2) , S (3) }
compressed into a procedure sequence πi = C(ei,j1 ), C(ei,j2 ), . . . , C(ei,jLi ) ,
(24)
where j1 , . . . , jLi retain only the first event of each maximal run with the same procedure label. Thus, consecutive repetitions are removed while the original procedure order is preserved. Trace2Tower then rebuilds the transition, outcome, and contrastive graph over procedure sequences and collapses strongly connected components. Maximal paths observed in successful trajectories are retained only when every adjacent component pair has positive contrastive support, forming strategy-level skills. Structural membership is fixed before textual rendering, so the Skill Author cannot alter procedure membership, path order, or support statistics. At deployment, both policies use the same induced Tower. The reported evaluator retrieves three High-level strategy references and rewrites them into a task-bound plan. High-only uses this plan alone. Full additionally retrieves procedure candidates for the rewritten plan steps, removes duplicates and candidates below cosine similarity 0.45, and retains at most eight Mid cards after self-filtering. The budgeted objective in Equation (11) formalizes the desired hierarchical selection problem. The reported experiments instantiate this objective with the fixed two-stage policy above rather than solving the combinatorial argmax exactly. Mid retrieval is performed from the rewritten plan at episode start and is not refreshed after every environment transition.
Appendix E: Experimental Configuration, Complexity, and Structural Analyses This appendix provides the computational complexity, experimental configuration, and additional analyses required to interpret the reported results. The implementation settings
Stage
Time
Event abstraction O(S) Embedding / quotienting O(nd) Graph statistics O(n P+ ed) Component eigensystems O(P c m3c ) Procedure clustering O( c mc rc2 ) Strategy graph / SCCs O(P + ER d + R + ER )
Working memory
Setting
O(n) O(nd) O(m + e) O(maxc m2c ) O(maxc mc rc ) O(Rd + ER )
Outcome pseudo-counts 1 success + 1 failure Minimum nontrivial component 3 nodes Zero-degree tolerance 10−12 K-means initializations 20 K-means maximum iterations 300 Random seed 42 Retrieved High references 3 Mid candidates per plan step 4 Mid cosine threshold 0.45 Maximum injected Mid cards 8 Per-transition Mid refresh no
Table 4: Dominant time and working-memory costs of the reported pipeline.
Value
Benchmark Train tasks Rollouts/task Trajectories Test tasks ALFWorld WebShop
310 100
4 4
1,240 400
134 100
Table 5: Construction and evaluation pools. Both benchmarks use a 20-step interaction horizon.
follow the method defined in the main paper and Appendix , while the additional analyses examine how the induced structure behaves under component removal, model transfer, and large-scale skill construction.
E.1 Time and Memory Complexity Let S be the number of raw interaction steps, n the number of event segments, m the number of quotient nodes, e the number of observed quotient transitions, d the embedding dimension, mc the size of component c, R the number of procedure groups, and P the total length of compressed procedure sequences. The graph remains sparse because semantic similarity is evaluated only for observed transitions. The dominant computational cost arises from the spectral stage. Since the reported configuration searches the full admissible eigengap of every nontrivial component, it computes a complete eigensystem for each component rather than using a truncated solver. Component-wise decomposition therefore changes the dense P spectral cost from a monolithic O(m3 ) computation to O( c m3c ) and bounds peak dense memory by the largest component. The complexity in Table 4 describes the reported configuration and does not assume an unreported partial eigensolver.
E.2 Experimental Configuration Table 5 summarizes the benchmark construction and evaluation protocol. ALFWorld evaluates all 134 solvable validunseen tasks, while WebShop uses a frozen 100-task test manifest. Construction and evaluation identifiers are disjoint in both environments. The same interaction horizon of 20 steps is used for all methods. GPT-5.4 serves as the Skill Author and plan rewriter, while DeepSeek-V4-Flash is the default Skill User. The Skill User uses temperature 0 and a maximum of 512 output tokens per interaction turn. Skill rendering is schema constrained. The supplied experimental records confirm a 4,096-dimensional embedding representation processed in batches of 16. The exact embedding-model identifier is not recoverable from the supplied records and
Table 6: Essential graph-induction and deployment settings. Variant
Retained signals Mid/High
Full No Transition No Outcome No Contrastive
S+T+O+C S+O+C S+T+C S+T+O
39/118 19/76 39/106 10/44
Success 87.31 ± 0.75 70.15 73.88 73.88
Table 7: ALFWorld structural ablations. S, T, O, and C denote semantic, transition, outcome, and contrastive evidence. Each ablation is one 134-task evaluation; Full is the three-run mean.
should therefore be taken from the final run metadata rather than inferred from representation dimensionality. The essential method and deployment settings are summarized in Table 6. The graph-induction parameters correspond to the component-wise procedure induction described in Appendix . The deployment parameters specify the practical realization of the hierarchical retrieval objective in Equation (11). In particular, Full retrieves Mid-level support against the rewritten plan at episode initialization rather than refreshing the retrieval set after every environment transition. For R = 3 complete repetitions, each task metric is averaged within one repetition. Main tables report the arithmetic mean across repetitions and the sample standard deviation v u u s=t
R 1 X (xr − x̄)2 . R − 1 r=1
(25)
ALFWorld success uses the final environment completion indicator. WebShop exact success is the indicator that the official reward is at least 0.999. Invalid actions include malformed, unavailable, or environment-rejected executable actions. Skill-context characters count only the skill information injected into the Skill User. All automatic baselines use the same benchmark-specific trajectory pool, Skill User, evaluation manifest, environment implementation, and interaction horizon. ExpeL (Zhao et al. 2024), SkillX (Wang et al. 2026a), and Trace2Skill (Ni et al. 2026) retain their native experience representations rather than being converted into the Trace2Tower interface.
E.3 Structural Ablations
Edit
The main paper reports overall benchmark performance, while Table 7 isolates the contribution of the graph signals that determine the induced hierarchy. Removing transition evidence causes the largest performance degradation and reduces the number of induced procedure and strategy structures from 39/118 to 19/76. This result indicates that temporal dependencies provide information that cannot be recovered from semantic similarity and outcome evidence alone. Removing outcome evidence or the contrastive transformation also substantially lowers success. Together, these results support the use of success- and failure-conditioned behavioral topology rather than a purely semantic event graph. Each structural ablation is evaluated once on the complete 134-task ALFWorld set, whereas Full reports the mean and sample standard deviation across three complete runs. The ablation values therefore diagnose the structural effect of removing individual signals and are not interpreted as runto-run variance estimates.
Split
E.4 Cross-Model Transfer The cross-model experiment separates the model that constructs the Tower from the model that subsequently executes with it. With DeepSeek-V4-Flash as the Skill User, the GPT5.4-authored Tower reaches 88.06% success compared with 65.67% for the DeepSeek-V4-Flash-authored Tower. Their paired outcomes contain 34 GPT-only wins, 4 Flash-only wins, and 96 ties, yielding an exact two-sided McNemar value of p = 6.04 × 10−7 . With DeepSeek-V4-Pro as the Skill User, the corresponding success rates are 85.82% and 79.10%, with p = 0.150. The improvement across both Skill Users indicates that the induced Tower is not tied to the model that authored its textual rendering, while the difference between the two Tower authors also shows that representation quality remains sensitive to the Skill Author.
E.5 Hierarchy Scale and Construction Cost On ALFWorld, 1,240 construction trajectories produce 13,724 event segments and 3,764 reported quotient nodes. Trace2Tower subsequently induces 39 procedure skills and 118 strategy skills. Across 402 Full evaluation episodes, retrieval uses 53 distinct High skills and 30 distinct Mid skills, showing that deployment draws from a substantial fraction of both induced levels rather than repeatedly relying on a small fixed subset. Skill construction uses 1,025,732 total GPT tokens, compared with 1,233,641 for SkillX. Trace2Tower therefore reduces total chat-generation tokens by 16.85%. This reduction arises despite explicitly constructing procedure and strategy structure, indicating that structural induction does not require a larger language-model generation budget than iterative skill-library construction.
Appendix F: Verifier-Guided Refinement and Feedback Evaluation This appendix describes how Trace2Tower updates an induced Tower using deployment feedback. Refinement operates on the frozen hierarchy without repeating event segmentation, graph construction, or spectral decomposition,
Target
Structural effect
Heterogeneous pro- Creates evidence-specific cedure children while retaining the parent Merge Compatible proce- Contracts evidence and supdures ported relations into one procedure Promote Supported Mid path Adds a reusable strategy motif DownweightHarmful High skill Adds a reversible retrieval penalty without deleting the skill
Table 8: Verifier-guided structural edit operators.
allowing the learned structure to be corrected after deployment.
F.1 Verifier-Guided Structural Refinement Candidate Towers are evaluated against the frozen Tower on the same task manifest using paired outcomes. Table 8 summarizes four edits: Split separates heterogeneous procedures, Merge combines compatible procedures, Promote elevates success-supported procedure paths, and Downweight reduces harmful strategy reuse without deleting the underlying structure. Candidate edits are compared on semantic relevance, structural relevance, and verifier-feedback evidence. An edit is dominated if another is no worse on all three criteria and better on at least one. Only non-dominated candidates reach the deployment gate, avoiding an additional tuned scalar combination. The held-out study uses 120 tasks per set and 10,000 paired bootstrap resamples. The accepted transaction splits one procedure, promotes eight strategy motifs, downweights one strategy, and performs no merge. Versioned updates enable direct comparison with the frozen Tower and rollback when the paired gate is not satisfied.
F.2 Feedback Evaluation The frozen Tower achieves 80.42% pooled success across the two held-out sets. Structural refinement increases this rate to 84.58% with TF–IDF-based Pareto selection and 83.75% with embedding-based selection. The two relevance representations exhibit opposite set-level rankings: TF–IDF performs better on the first set, while embedding relevance performs better on the second. Their consistent improvement over the frozen Tower supports the contribution of editable structural relations and paired feedback rather than dependence on a single relevance representation.