April 29, 2026
T OWARD S CALABLE T ERMINAL TASK S YNTHESIS VIA S KILL G RAPHS Zhiyuan Fan
Tinghao Yu
Jiang Zhou
Xing Wu
Yuanjun Cai
Zhuo Han
Jiangtao Guan
Feng Zhang
Yun Yang
Dingxin Hu
Lilin Wang
arXiv:2604.25727v1 [cs.AI] 28 Apr 2026
Hunyuan Team, Tencent B [email protected], {maxwellyu, lilinwang}@tencent.com
A BSTRACT Terminal agents have demonstrated strong potential for autonomous commandline execution, yet their training remains constrained by the scarcity of highquality and diverse execution trajectories. Existing approaches mitigate this bottleneck by synthesizing large-scale terminal task instances for trajectory sampling. However, they primarily focus on scaling the number of tasks while providing limited control over the diversity of execution trajectories that agents actually experience during training. In this paper, we present SkillSynth, an automated framework for terminal task synthesis built on a scenario-mediated skill graph. SkillSynth first constructs a large-scale skill graph, where scenarios serve as intermediate transition nodes that connect diverse command-line skills. It then samples paths from this graph as abstractions of real-world workflows, and uses a multi-agent harness to instantiate them into executable task instances. By grounding task synthesis in graph-sampled workflow paths, SkillSynth explicitly controls the diversity of minimal execution trajectories required to solve the synthesized tasks. Experiments on Terminal-Bench demonstrate the effectiveness of SkillSynth. Moreover, task instances synthesized by SkillSynth have been adopted to train Hy3 Preview, contributing to its enhanced agentic capabilities in terminal-based settings.
1
I NTRODUCTION
Terminal agents leverage the command-line interface (CLI) as a universal action space, enabling large language models (LLMs) to execute complex, long-horizon tasks across computing systems (Jimenez et al., 2024; Team, 2025; Merrill et al., 2026). Yet their capabilities remain fundamentally limited by the scarcity of high-quality, diverse trajectories for training. Since manually curating executable terminal tasks is expensive and difficult to scale (Lin et al., 2018; Merrill et al., 2026), recent work has turned to large-scale terminal task synthesis as a path toward scalable trajectory collection. To understand what makes such trajectories useful for training, it helps to look at how terminal agents actually operate. During execution, a terminal agent does not plan over the entire environment in a single shot. Instead, it acts through step-by-step interaction with a sequence of intermediate scenarios, applying a skill at each scenario to make progress. An execution trajectory is therefore jointly characterized by two dimensions: the scenarios it traverses and the skills it exercises. Training terminal agents thus amounts to learning to apply appropriate skills across diverse partial scenarios, which in turn requires trajectories that are diverse along both dimensions. Existing efforts, however, primarily scale terminal task instances, either by broadening domain coverage via LLM-generated taxonomies, which often diverge from real-world usage (Pi et al., 2026; Zhu et al., 2026), or by deriving task instances from real GitHub repositories and inverting healthy environments into buggy states (Wu et al., 2026; Lin et al., 2026; Chen et al., 2026), which remain narrowly scoped to software-engineering domains such as issue resolution and feature development (Yang et al., 2025b; Zhang et al., 2025; Wang et al., 2025a). These approaches provide limited explicit control over the scenario or skill composition underlying the resulting trajectories. 1
(a) Skill Graph κ₂
σ₁
κ₁ σ₆
κ₃
skill κ skill κ
σ₂
σ₅
σ₄
scenario σ scenario σ
🧠 Planner
✓ Executable Task
⚙️ Constructor
σ₃
κ₄
(c) Task Instance 𝒯
strategy + steps
κ₇
κ₆
(b) Synthesis Harness
→
instantiate task artifacts Tools for create_file read_file🛠️str_replace File Manipulation
🛠️ Tools overwrite_file delete_file Repair
✗ fail Loop↺ ✗ fail
κ₅
Verification ⚖️⚖️VERIFICATION
sampled path 𝒫 sampled path 𝒫
Harbor Harbor Oracle Oracle solvable solvable✓✓
Rubric Eval quality ✓ ✓ quality
→
✓pass
📄 instruction.md
📁environment/
├─Dockerfile
Dockerfile
└─Files/
📁test/
├─ test.py
└─ test.sh
📄 solve.sh
Figure 2: Overview of SkillSynth. (a) A compositional path P of scenarios σ and skills κ (highlighted in orange) is sampled from the scenario-mediated skill graph. (b) A multi-agent harness instantiates P into the components of a task instance through a planner and a tool-augmented synthesis agent, followed by dual verification that checks solvability (execution-based) and specification quality (rubric-based); failed instances re-enter the synthesis loop for iterative repair. (c) The resulting task instance T is fully executable and verified. 6
Count (K)
5
5,799
Nemotron (Easy) Nemotron (Medium) Nemotron (Mixed) TerminalTraj SkillSynth (Ours)
4
As empirically shown in Figure 1, these trajectories exhibit redundancy in both scenario coverage and skill usage: different task instances often expose the agent to overlapping scenarios and reuse similar skills (Wu et al., 2026).
To address this gap, we propose SkillSynth, a scalable framework for constructing diverse terminal tasks. SkillSynth first collects skills from 2 ClawHub (OpenClaw, 2026) and public GitHub repositories, capturing practical experience dis1 tilled from real terminal usage. For each skill, SkillSynth derives a precondition scenario that de0 #Scenarios #Skills #Pairs scribes when the skill is applicable, and a postcondition scenario that describes the state reached after its execution. It then links semantically Figure 1: Diversity of synthesized trajectories compatible scenarios across skills to construct a across datasets, measured by the number of scenario-mediated skill graph, in which scenarunique scenarios, skills, and (scenario, skill) ios serve as nodes and skills as directed transipairs after semantic canonicalization. Each tions between them. A directed path sampled from value is averaged over three independent sam- the graph therefore specifies an agentic workflow, consisting of a sequence of skills ordered together ples of 1,000 trajectories per dataset. with the intermediate scenarios they traverse. We then use a multi-agent harness to instantiate each sampled workflow into a concrete executable task instance whose intended solution realizes the sampled path, with oracle-based verification to ensure solvability and rubric-based evaluation to ensure task quality. 3
2,523
2,607
In a single fully automated run, SkillSynth constructs 3,560 verified task instances from 3,721 sampled paths, achieving a 95.7% oracle pass rate at only an average cost of $27.3 per verified task instance. Compared with tasks synthesized from single-skill seeds or randomly composed multiskill seeds, SkillSynth tasks are more challenging and diverse: Claude Opus 4.6 requires 37 steps on average to solve them, and 121 tasks remain unsolved after three independent rollouts. We validate the effectiveness of SkillSynth by performing supervised fine-tuning on Qwen3-8B and Qwen3-32B using sampled trajectories, and evaluating on Terminal-Bench 1.0 and 2.0. With the enhanced diversity of the sampled trajectories, the fine-tuned models achieve improved performance with higher data efficiency. Additionally, task instances synthesized by SkillSynth have been adopted to train Hy3 Preview (Tencent Hy Team, 2026), contributing to its enhanced agentic capabilities. 2
Currently, the constructed skill graph contains 82,073 scenarios after deduplication and merging, 57,214 filtered skills, and 185,529 LLM-verified bridges, from which a large space of workflow paths can be sampled for task construction. Its scenario-mediated structure makes the graph a naturally scalable infrastructure for task synthesis. As the community contributes more skills, the graph continues to expand, enabling continual synthesis of diverse terminal tasks. Our contributions are summarized as follows: 1. We model agentic trajectories as sequences of scenarios and skills to analyze their diversity, and introduce a scenario-mediated skill graph that organizes existing skills as a foundation for sampling workflows for controllable synthesis of terminal task instances. 2. We build an end-to-end multi-agent harness that synthesizes sampled paths into executable task instances without human intervention, achieving a 95.7% oracle pass rate and producing 3,560 verified task instances in a single fully automatic run. 3. We collect trajectories on the synthesized task instances and demonstrate that graph-guided synthesis yields harder tasks and more diverse trajectories than single-skill or composed multi-skill baselines, leading to consistent gains on Terminal-Bench 1.0 and 2.0 across model scales.
2
P ROBLEM F ORMULATION
Terminal agent task. We formulate a terminal agent task as a tuple τ = (E, s0 , g, V ). From the initial state s0 ∈ S, an agent π interacts with the executable environment E to achieve a natural language described goal g. At step t under partial observability, the agent receives an observation ot ∈ O and samples an action at ∼ π(· | o≤t , a<t , g). The resulting low-level trajectory ζ = (o0 , a0 , . . . , oT ) is labeled successful if the final state satisfies the external verifier, i.e., V (sT ) = 1. Scenario and skill abstraction. However, low-level trajectories ζ consist only of fine-grained observations and actions, obscuring the high-level strategy the agent applies during execution. We thus lift ζ to a higher semantic abstraction through two objects. A scenario σt ∈ Ω is a decisionrelevant abstraction of the observation at a decision point of execution, and by construction serves as a sufficient statistic of the interaction history up to that point for the agent’s next decision. A skill κt ∈ K is an action subsequence applied at one scenario that produces a predictable transition to the next, κt : σt−1 → σt , κt = (ait , ait +1 , . . .). (1) Under this identification, ζ induces an execution trajectory ξ = σ0 , κ1 , σ1 , κ2 , . . . , κL , σL ∈ (Ω × K)L × Ω, (2) which jointly characterizes the scenarios traversed and the skills exercised (cf. options in hierarchical RL (Sutton et al., 1999)). Learning objective. Based on Equation 2, an agent reduces to a policy over skills conditioned on scenarios, and training such an agent thus amounts to maximizing the expected skill-selection likelihood under the empirical distribution D induced by the training trajectories: J (π) = Eξ∼D
L X
log π(κt | σt−1 , g) ,
(3)
t=1
which is equivalent to the standard next-token-prediction loss on low-level interaction trajectories (§ A). For a fixed goal g, decomposing J over the support of D yields X X J (π) = pD (σ | g) pD (κ | σ, g) log π(κ | σ, g), (4) σ∈Ω
κ∈Kσ
where Kσ ⊆ K denotes skills admissible at σ. Equation 4 makes explicit that the learnable region of π is confined to the support of D along both factors: scenarios with pD (σ | g) = 0 are unobservable, and skills with pD (κ | σ, g) = 0 are unexercised. Maximizing learned capacity therefore requires training data whose induced D densely covers the conditional product space {(σ, κ) : σ ∈ Ω, κ ∈ Kσ }, which motivates our approach to scale synthetic task instances by maximizing the diversity of execution trajectories experienced by the agent. 3
Filter Raw Skills
Infer Pre/Post Scenarios Filtered Skills
LLM
Scenario Clustering Merging & Deduplication Pre-Scenarios
Cluster Alignment
Graph Construction
Pre-Clusters Post-Clusters
... Unified Pre-Clusters
Pre-Scenarios
Post-Scenarios
...
...
Post-Scenarios
...
Filtered Skills
Unified Post-Clusters
Connecting Semantically Consistent Clusters
Pre-scenario Post-scenario Skill
Figure 3: Overview of the skill graph construction pipeline.
3
A PPROACH
3.1
OVERVIEW
SkillSynth synthesizes diverse terminal task instances through three stages. We first construct a scenario-mediated skill graph, in which nodes are scenarios and directed edges represent skills that point from precondition to postcondition scenarios (§ 3.2). From this graph we sample directed paths, each specifying a compositional sequence of skills to be exercised sequentially together with the scenarios they traverse (§ 3.3). A multi-agent harness then instantiates each sampled path into a concrete, executable task instance with oracle verification and rubric-based evaluation to ensure solvability and task quality (§ 3.4). 3.2
S KILL G RAPH C ONSTRUCTION
Recall from § 2 that each skill κ ∈ K is a directed transition κ : σ → σ ′ between scenarios. We lift this pairwise structure into a directed multigraph G = (Ω, K), where nodes are scenarios and edges are skills. A directed path in G corresponds to a sequential workflow in which each skill’s postcondition serves as the precondition of the next. The full construction pipeline is illustrated in Figure 3. Skill filtering. We instantiate G from human-written skills in ClawHub (OpenClaw, 2026) and public GitHub repositories. The skill pool K retains only skills that are 1) executable on a Linux terminal, 2) defined by a structured workflow rather than prompt engineering alone, 3) free of adversarial or jailbreak content (e.g., downloading files from unknown IPs, exfiltrating environment keys), and 4) producing deterministic, objectively verifiable outputs. Scenario inference. For each retained skill κ ∈ K, we prompt an LLM with its full specification (Markdown description, code, and usage examples) to infer plausible precondition scenarios Ωpre κ ′ and postcondition scenarios Ωpost , yielding atomic transitions {κ : σ → σ ′ | σ ∈ Ωpre κ κ , σ ∈ Ωpost }. κ Scenario deduplication. All inferred scenarios are embedded and undergo clustering-based semantic deduplication, merging scenarios that describe the same state but differ in lexical form. We evaluate nine common clustering algorithms and find that a hierarchical agglomerative clustering method with Louvain-based coarse bucketing performs best empirically. Cross-skill alignment. To connect atomic transitions into a unified graph, postconditions of one skill are aligned with preconditions of another. For each postcondition scenario, the top-1,000 most similar precondition scenarios are retrieved by embedding similarity, and an LLM judges semantic compatibility. We repeat this process in reverse (precondition → top-1,000 postconditions) using separately designed prompts to ensure bidirectional alignment quality. Scenario merging and filtering. Aligned pre- and postcondition pairs are merged into unified scenario nodes using an LLM. Finally, we perform an LLM-based filtering pass over all resulting 4
Algorithm 1 Inverse-Frequency Path Sampling with Monotone Progression Require: Skill graph G = (Ω, K), length range [Lmin , Lmax ], sampling budget N Ensure: Set of unique sampled paths Π 1: Initialize ν(σ) ← 0 for all σ ∈ Ω, µ(κ) ← 0 for all κ ∈ K, Π ← ∅, S ← ∅ 2: for b = 1, . . . , N do 3: Sample σ0 ∈ Ω with probability ∝ (ν(σ) + 1)−1 4: P ← (σ0 ), Vκ ← ∅, Vσ ← {σ0 }, l ← 0 5: while l < Lmax do 6: N (σl ) ← κ ∈ K : κ : σl → σ ′ for some σ ′ ∈ Ω \ Vσ , κ ∈ / Vκ 7: if N (σl ) = ∅ then 8: break {dead-end; no monotone continuation} 9: end if 10: Sample κl+1 ∈ N (σl ) with probability ∝ (µ(κ) + 1)−1 11: Sample σl+1 ∈ κl+1 .post \ Vσ with probability ∝ (ν(σ) + 1)−1 12: Append (κl+1 , σl+1 ) to P 13: Vκ ← Vκ ∪ {κl+1 }, Vσ ← Vσ ∪ {σl+1 } 14: l ←l+1 15: end while 16: if Lmin ≤ l ≤ Lmax and skills(P) ∈ / S then 17: Π ← Π ∪ {P}; S ← S ∪ {skills(P)} 18: ν(σ) ← ν(σ) + 1 for each σ in P 19: µ(κ) ← µ(κ) + 1 for each κ in P 20: end if 21: end for 22: return Π (scenario, skill, scenario) triples, retaining only those that form valid transitions. Through manual review of sampled graph cases, we find that each stage is necessary to ensure the overall quality of the constructed graph. Full alignment criteria and prompt details are provided in § B. 3.3
G RAPH -G UIDED PATH S AMPLING
Given the skill graph G = (Ω, K), we sample directed paths that serve as compositional inputs to the multi-agent synthesis harness (§ 3.4). A sampled path P = (σ0 , κ1 , σ1 , κ2 , . . . , κL , σL ) interleaves L skill transitions with L + 1 scenarios, where each κl ∈ K is a directed edge from σl−1 to σl in G. Paths whose length L falls within [Lmin , Lmax ] are retained, covering single-skill tasks (L ∈ {1, 2, 3}) through compositional multi-step ones (L ≥ 4); we set Lmin = 1 and Lmax = 7 in our experiments. A uniform random walk on G concentrates on high-degree scenarios and frequently traversed skills, producing redundant paths that revisit the same sub-structures. We instead sample paths with inverse-frequency weighting: for each scenario σ ∈ Ω we maintain a visit count ν(σ), and for each skill κ ∈ K a usage count µ(κ). The source scenario is drawn with probability p(σ) ∝ (ν(σ)+1)−1 , and at each step of the walk the next edge is drawn from the outgoing skills of the current node with probability p(κ) ∝ (µ(κ) + 1)−1 . To enforce monotone progression, visited scenarios and skills are excluded from subsequent steps within the same path. The walk continues until it reaches Lmax or encounters a dead-end with no valid continuation. If the resulting path length falls within [Lmin , Lmax ] and its skill set has not been seen before, the path is accepted and both counters are incremented, progressively steering the empirical distribution toward uniform coverage over Ω × K, which is the coverage criterion derived in Equation 4. The full procedure is given in Algorithm 1. 3.4
M ULTI -AGENT H ARNESS
Given a sampled path P from § 3.3, a multi-agent harness is designed to produce an executable task instance consisting of five components: a natural-language instruction, an initial filesystem snapshot, a containerized environment, verification scripts, and an oracle solution. 5
Terminal Task Instruction Turn the provided raw video into a GIF summary package with sampled frames, metadata, and the final animated GIF. Scenario
Level 1 Graph Chain
Scenario
Skill
active video editing session
Video Analyzer Frame Extractor
Skill
Scenario
Scenario
Skill
GIF
GIF
raw video footage available in the workspace
raw video footage
Video Analyzer
Skill 1: Video Analyzer
Level 2 Skill Workflows
Skill 2: Frame Extractor
video session with metadata GIF
extracted frames with timestamps
Generator
GIF
generated GIF with output metadata
Skill 3: GIF Generator
1
Locate the raw video file.
1
Read video metadata and duration.
1
Load extracted frames and metadata.
2
Extract basic metadata.
2
Choose a frame sampling interval.
2
Order frames and set GIF parameters.
3
Detect scenes and key segments.
3
Extract representative frames.
3
Compose frames into an animated GIF.
4
Generate a video summary and captions.
4
Save frames with timestamps.
4
Optimize or compress the GIF.
5
Create an active video session for downstream.
5
Record extraction metadata.
5
Save the final GIF and output metadata.
Figure 4: A video-domain example of a path sampled from the skill graph and the corresponding synthesized task instruction. To accomplish the task, the agent needs to apply multiple skills, each of which expands into a multi-step internal workflow. Directly prompting an LLM to generate all components in a single pass leads to two issues: 1) longcontext generation produces outputs of inconsistent quality, and 2) the model focuses on implementation details rather than designing a coherent task instance, resulting in tasks that lack sufficient complexity. We thus decouple planning from implementation: a planner first transforms P into a structured plan of sub-objectives and expected outputs, then a constructor generates the whole task instance conditioned on this plan. Each task instance is checked along two complementary axes: execution-based verification runs the verification scripts against the oracle solution inside the environment container to ensure solvability; and rubric-based verification uses LLM-as-a-Judge to assess (i) alignment between instructions and tests, ensuring that tests are neither too lenient (missing required functionality) nor too strict (imposing unstated constraints), and (ii) instruction selfcontainedness, ensuring that no hints about the oracle solution progress leak into the instruction. If either check fails, diagnostic feedback is returned to the constructor for repair via multi-turn tool use. We permit up to R = 3 repair cycles, each with at most Ntool = 20 tool calls, after which the instance is accepted or discarded. An example of a sampled path and the corresponding synthesized task instruction is shown in Figure 4.
4
E XPERIMENTS
4.1
E XPERIMENTAL S ETUP
We sample 3,721 paths from the constructed skill graph to synthesize task instances and validate the effectiveness of SkillSynth. Base Model. We select the Qwen3 dense series (Yang et al., 2025a) (8B, 14B, and 32B) as our base models to study the effect of model scale, with Qwen3-32B serving as our primary model for ablation studies. All models are trained with full-parameter supervised fine-tuning using a learning rate of 2e-5 for 5 epochs. Full training details are provided in § C. Evaluation. We use Terminal-Bench 1.0 and 2.0 (Merrill et al., 2026) as our evaluation benchmarks, comprising 80 and 89 community-curated tasks, respectively, with the latter serving as a harder successor to the former. All reported results are the mean accuracy over three independent runs, along with 95% confidence intervals. We adopt Terminus 2 as our agent scaffold, which interacts with the environment solely through a single headless terminal without additional harness constraints. For evaluation infrastructure, we employ Harbor (Harbor Framework Team, 2026), the official orchestration framework of Terminal-Bench 2.0, to parallelize trajectory sampling across 128 concurrent Docker (Merkel, 2014) environments for enhanced sampling efficiency. 6
Task Verification Results Category
Count
Ratio (%)
All passed Oracle passed only Failed
3,423 137 161
92.0 3.7 4.3
Total
3,721
100.0
Successes (out of 3)
Repair Statistics Avg. repair cycles Avg. tool calls Recovered tasks
2.31 11 721
Percentage
# Tasks
0/3 1/3 2/3 3/3
38% 18% 19% 25%
1,352 637 679 892
Total
100%
3,560
Table 2: Difficulty distribution of the 3,560 usable task instances. Lower success counts indicate harder tasks.
Table 1: Summary of multi-agent harness outcomes and repair statistics.
4.2
M ULTI - AGENT H ARNESS Q UALITY
The multi-agent harness achieves high yield. As shown in Table 1, 95.7% of synthesized instances pass the oracle check, with 92.0% passing both quality checks. The multi-turn verify-then-repair loop recovers 721 task instances that failed in the first round, which shows that interactive repair is necessary to achieve high yield at scale. In total, a single fully automatic run produces 3,560 usable task instances. Scaling further simply requires sampling more paths from the skill graph and re-running the multi-agent harness. Misalignment between instructions and tests dominates rubric failures. Of failed rubric checks, 77% stem from test scripts that either over-specify or under-specify relative to the instruction, potentially producing inaccurate evaluation of agent trajectories and erroneous reward signals for reinforcement learning. We retain these task instances for supervised fine-tuning to preserve trajectory diversity, but discard them for reinforcement learning to avoid erroneous reward signals. Poor first-round generations are hard to recover. For oracle failures, the dominant cause is corrupted filesystem snapshots: due to the randomness of LLM generation, the first synthesis round may produce buggy stages that remain unrecoverable even after multiple repair cycles. Although the multi-agent architecture substantially outperforms a single-stage pipeline, these cases suggest a floor on repair effectiveness. Re-running failed paths with a higher sampling temperature is a simple yet effective strategy to help recover these paths and preserve the diversity of the synthesized task set. Task difficulty distribution. We categorize the 3,560 usable task instances by difficulty using Hy3 Preview (Tencent Hy Team, 2026). Each task is attempted three times, and we assign difficulty levels based on the number of successful attempts. Table 2 reports the distribution. 37% of tasks fall in the learnable range (1/3 or 2/3 success rate), while 38% (0/3) represent potentially challenging problems for future exploration.
4.3
M AIN R ESULTS
For trajectory collection, we use MiniMax M2.7 as the teacher model due to its cost efficiency, sampling three trajectories per task instance for a total of 10,680 trajectories. We retain both successful and failed trajectories for training (Pi et al., 2026) to preserve diversity and coverage, as failed trajectories contain useful reasoning patterns for agentic problem-solving, such as error diagnosis and recovery strategies across diverse scenarios. Table 3 reports experimental results after training Qwen3-8B, Qwen3-14B, and Qwen3-32B on collected trajectories. All three models improve over their respective baselines, with gains scaling with model size. Qwen3-32B + SS outperforms the larger Qwen 3 Coder 480B on TB 2.0, suggesting that targeted data construction and domain-specific training can effectively improve the terminal agentic capabilities of smaller models. 7
Proprietary Model
Open-Source
TB 1.0
TB 2.0
Model
GPT-5.3-Codex Claude Opus 4.6 Claude Opus 4.5 Gemini 3 Pro GPT-5.2 Claude Sonnet 4.5 GPT-5.1 Claude Opus 4.1 Claude Haiku 4.5 GPT-5
– – – – – 51.0 ± 1.6 – 43.8 ± 2.8 41.8 ± 2.6 41.3 ± 2.2
64.7 ± 2.7 62.9 ± 2.7 57.8 ± 2.5 56.9 ± 2.5 54.0 ± 2.9 42.8 ± 2.8 47.6 ± 2.8 38.0 ± 2.6 28.3 ± 2.9 35.2 ± 3.1
GLM 5 Kimi K2.5 MiniMax m2.5 Grok 4 DeepSeek-V3.2 Grok 4 Fast Qwen 3 Coder 480B
Claude Opus 4 Claude Sonnet 4 GPT-5-Mini
39.0 ± 0.8 36.4 ± 1.2 30.8 ± 3.9
– – 24.0 ± 2.5
Qwen3-8B + SS Qwen3-14B + SS Qwen3-32B + SS
TB 1.0
TB 2.0
– – – 39.0 ± 3.2 – 31.3 ± 2.8 –
52.4 ± 2.6 43.2 ± 2.9 42.2 ± 2.6 – 39.6 ± 2.8 – 23.9 ± 2.8
Ours 17.1 ± 1.8 22.9 ± 1.8 33.8 ± 3.1
13.5 ± 2.8 19.9 ± 1.6 29.6 ± 1.6
Table 3: Experimental results on Terminal-Bench 1.0 and 2.0 with the Terminus 2 scaffold. +SS denotes models trained with SkillSynth generated trajectories.
4.4
A BLATION S TUDY
To isolate the contributions of skill graph construction and path sampling, we compare SkillSynth against two baselines that use the same multi-agent harness for task synthesis. We first construct a skill pool from all skills appearing in the sampled paths, then create: 1) Single-skill: 3,721 skills randomly drawn from the pool, each used as a standalone seed for task synthesis. 2) Multi-skill: 3,721 randomly composed combinations of 2–7 skills from the pool, without graph-guided ordering. Task Distribution
Accuracy
Strategy
0/3
1/3
2/3
3/3
TB 1.0
TB 2.0
Single-skill Multi-skill SkillSynth (Ours)
16% 27% 38%
23% 24% 18%
34% 21% 19%
27% 28% 25%
25.4 ± 1.8 30.8 ± 1.8 33.8 ± 3.1
21.3 ± 2.8 25.8 ± 2.8 29.6 ± 1.6
Table 4: Ablation study on synthesis seed selection strategy. Table 4 reports both task difficulty and downstream model performance. SkillSynth tasks are harder than both baselines. On the training side, models trained on SkillSynth trajectories outperform those trained on single-skill trajectories by 8.4 points on TB 1.0 and 8.3 points on TB 2.0, and outperform multi-skill trajectories by 3.0 points on TB 1.0 and 3.8 points on TB 2.0. Random composition lacks workflow coherence. We find multi-skill baselines produce lowerquality tasks because randomly composed skills lack sequential dependencies and cannot form coherent workflows. The multi-agent harness tends to generate simplified task instances that contain multiple fine-grained requirements but require few execution steps. 4.5
D IVERSITY A NALYSIS
We analyze diversity at two levels: 1) the structural diversity of the skill graph itself and sampled paths, and 2) the diversity of the collected trajectories. Skill graph and sampled paths. The constructed skill graph spans a wide range of domains, including long-tail areas such as Audio & Speech and 3D & Simulation (see § D for the full domain distribution). The graph is highly connected at the macro level: 85.6% of scenarios belong to the largest weakly connected component, while 6251 smaller components capture specialized, selfcontained workflows. From the whole graph, we enumerate 16,632,220 paths requiring seven or more skills, confirming a vast combinatorial space for task synthesis. Algorithm 1 ensures that the sampled paths are diverse at the skill and scenario levels. 8
Trajectories. To quantify execution diversity, we randomly sample 1,000 trajectories separately and use deepseek-reasoner (v3.2) to extract the scenarios and skills encountered by the agent during execution. Using the same prompt and model across all strategies ensures statistically comparable extraction granularity. We then embed all extracted scenarios and skills using Harrier-OSS-v1-27B and perform clustering-based deduplication to obtain unique scenarios, skills, and scenario-skill pairs. Trajectories sampled from SkillSynth tasks exhibit 31% higher unique scenario-skill coverage than single-skill baselines and 19% higher than randomly composed multi-skill baselines on average. The improved diversity translates directly into higher data efficiency and performance, as shown in Table 4. Prompts are provided in § E. 4.6
E RROR A NALYSIS
Error Category
Ratio
Typical Example
Partial Implementation
42.2%
Agent runs pytest on self-generated tests, gets all tests passing, and submits but silently skips one or more clauses from the instruction.
Inline Self-Test Over-trust
29.5%
Agent never runs pytest; instead verifies with hand-picked python3 -c assertions on happy paths, missing edge cases.
Premature Termination
12.9%
Agent finishes writing code and exits without running any form of verification.
API/Flag Hallucination
7.0%
Agent repeatedly invokes non-existent modules or flags, triggering ≥3 errors such as No module named or unexpected kwarg.
Debug Fixation Loop
5.1%
Agent repeats the same command ≥10 times with minor edits, never switching strategy, and exhausts the episode budget.
Error Rationalization
3.3%
Agent observes failing tests but rationalizes them as “preexisting” or “flaky” and completes anyway.
Table 5: Error analysis of failed trajectories. To understand failure modes, three of the authors independently analyzed 20 failed trajectories each. Based on the results, we design an error analysis skill for an LLM agent, which then analyzes all failed trajectories accordingly. As shown in Table 5, the dominant failure modes are partial implementation (42.2%) and over-trust in inline self-test (29.5%). In both cases, the agent substitutes self-narrated verification for specification-grounded testing and confidently marks the task complete. These findings suggest that terminal agents require stronger alignment with task instructions and more flexible exploration strategies during execution. 4.7
D ISCUSSION AND F UTURE W ORK
SkillSynth synthesizes a large number of task instances that reflect real-world workflows, covering diverse scenarios and skills. Future work includes 1) scaling SkillSynth to larger data regimes while continuously refining the multi-agent harness to adapt to more cost-effective models, 2) sampling subgraphs rather than chains from the skill graph, which requires parallel execution of multiple skills and increases task complexity.
5
R ELATED W ORK
Terminal Agents. Recent work has increasingly explored LLMs as terminal agents that interact with real-world computing systems through command-line interfaces (Yang et al., 2023; Jimenez et al., 2024). To evaluate such capabilities, Terminal-Bench (Merrill et al., 2026) provides a set of hand-crafted tasks spanning diverse domains, requiring agents to complete end-to-end workflows within containerized Docker environments. Meanwhile, a series of agent scaffolds (Anthropic, 2025; OpenAI, 2025; Google, 2025; Wang et al., 2025b; JetBrains, 2025) have been developed to enhance LLMs’ planning, execution, and tool calling capabilities in terminal settings. Despite strong pro9
prietary results, open-source models remain substantially behind, motivating scalable synthesis of diverse terminal execution trajectories for effective training. Synthetic Data for Terminal Agents. To reduce the cost of curating terminal training data, prior efforts scale synthetic task instances along different dimensions. Some approaches expand domain coverage through LLM-generated taxonomies, such as Endless Terminals (Gandhi et al., 2026), TermiGen (Zhu et al., 2026), and Nemotron-Terminal (Pi et al., 2026), enabling task instance generation across diverse domains. Others scale the number of task instances, for example by collecting realworld Docker environments from GitHub (Wu et al., 2026), or by inverting healthy environments into buggy states to derive new task instances (Lin et al., 2026). While these approaches increase the number of task instances, they provide limited control over the diversity of execution trajectories experienced by agents during task solving. We address this limitation by synthesizing task instances from a skill graph, enabling explicit control over the trajectories encountered during training. Skill Topology. A separate line of work organizes reusable agent skills into structured topologies, following the reusable skill library introduced by Voyager (Wang et al., 2023) and drawing on large skill repositories such as ClawHub (OpenClaw, 2026). AgentSkillOS (Li et al., 2026) organizes skills into a hierarchical capability tree and composes them through DAG-based orchestration graphs, while SkillNet (Liang et al., 2026) models skills as nodes in a relational graph with explicit inter-skill connections. However, these approaches primarily focus on skill organization and retrieval, rather than modeling how skills are composed during execution. In contrast, we organize skills through scenarios, where skill transitions are induced by shared executable states and temporal ordering in trajectories, enabling structured synthesis of terminal tasks with controllable scenario and skill diversity.
6
C ONCLUSION
In this paper, we model agentic trajectories as sequences of scenarios and skills to analyze their diversity, and propose SkillSynth, a framework that synthesizes diverse terminal task instances by sampling compositional paths from a constructed skill graph. SkillSynth achieves a high synthesis pass rate at relatively low cost, enabling scalable production of verified task instances. Experimental results show that training effectiveness depends on trajectory diversity, not merely on task volume. As communities like ClawHub continue to grow, SkillSynth provides a scalable way to transform emerging workflows into diverse task instances, enabling models to continuously learn real-world experience.
E THICS S TATEMENT The skills used to construct our data are sourced from publicly available GitHub repositories and ClawHub, and are used in accordance with their respective open-source licenses.
R EFERENCES Anthropic. Claude code: Best practices for agentic coding. https://www.anthropic.com/ engineering/claude-code-best-practices, Apr 2025. Vincent D Blondel, Jean-Loup Guillaume, Renaud Lambiotte, and Etienne Lefebvre. Fast unfolding of communities in large networks. Journal of Statistical Mechanics: Theory and Experiment, 2008(10):P10008, October 2008. ISSN 1742-5468. doi: 10.1088/1742-5468/2008/10/p10008. URL http://dx.doi.org/10.1088/1742-5468/2008/10/P10008. Mouxiang Chen, Lei Zhang, Yunlong Feng, Xuwu Wang, Wenting Zhao, Ruisheng Cao, Jiaxi Yang, Jiawei Chen, Mingze Li, Zeyao Ma, Hao Ge, Zongmeng Zhang, Zeyu Cui, Dayiheng Liu, Jingren Zhou, Jianling Sun, Junyang Lin, and Binyuan Hui. Swe-universe: Scale real-world verifiable environments to millions, 2026. URL https://arxiv.org/abs/2602.02361. Kanishk Gandhi, Shivam Garg, Noah D. Goodman, and Dimitris Papailiopoulos. Endless terminals: Scaling rl environments for terminal agents, 2026. URL https://arxiv.org/abs/2601. 16443. 10
Google. Gemini cli: Your open-source ai agent. https://blog.google/technology/ developers/gemini-cli-open-source-ai-agent/, 2025. Harbor Framework Team. Harbor: A framework for evaluating and optimizing agents and models in container environments, January 2026. URL https://github.com/ harbor-framework/harbor. JetBrains. Junie cli: Llm-agnostic coding agent built for real-world development. https:// junie.jetbrains.com/, 2025. Carlos E. Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real-world github issues?, 2024. URL https://arxiv.org/abs/2310.06770. Stephen C. Johnson. Hierarchical clustering schemes. Psychometrika, 32(3):241–254, 1967. doi: 10.1007/BF02289588. Hao Li, Chunjiang Mu, Jianhao Chen, Siyue Ren, Zhiyao Cui, Yiqun Zhang, Lei Bai, and Shuyue Hu. Organizing, orchestrating, and benchmarking agent skills at ecosystem scale, 2026. URL https://arxiv.org/abs/2603.02176. Yuan Liang, Ruobin Zhong, Haoming Xu, Chen Jiang, Yi Zhong, Runnan Fang, Jia-Chen Gu, Shumin Deng, Yunzhi Yao, Mengru Wang, Shuofei Qiao, Xin Xu, Tongtong Wu, Kun Wang, Yang Liu, Zhen Bi, Jungang Lou, Yuchen Eleanor Jiang, Hangcheng Zhu, Gang Yu, Haiwen Hong, Longtao Huang, Hui Xue, Chenxi Wang, Yijun Wang, Zifei Shan, Xi Chen, Zhaopeng Tu, Feiyu Xiong, Xin Xie, Peng Zhang, Zhengke Gui, Lei Liang, Jun Zhou, Chiyu Wu, Jin Shang, Yu Gong, Junyu Lin, Changliang Xu, Hongjie Deng, Wen Zhang, Keyan Ding, Qiang Zhang, Fei Huang, Ningyu Zhang, Jeff Z. Pan, Guilin Qi, Haofen Wang, and Huajun Chen. Skillnet: Create, evaluate, and connect ai skills, 2026. URL https://arxiv.org/abs/2603.04448. Xi Victoria Lin, Chenglong Wang, Luke Zettlemoyer, and Michael D. Ernst. Nl2bash: A corpus and semantic parser for natural language interface to the linux operating system, 2018. URL https://arxiv.org/abs/1802.08979. Yusong Lin, Haiyang Wang, Shuzhe Wu, Lue Fan, Feiyang Pan, Sanyuan Zhao, and Dandan Tu. Cli-gym: Scalable cli task generation via agentic environment inversion, 2026. URL https: //arxiv.org/abs/2602.10999. Dirk Merkel. Docker: Lightweight linux containers for consistent development and deployment. Linux Journal, 2014(239):2, 2014. Mike A. Merrill, Alexander G. Shaw, Nicholas Carlini, Boxuan Li, Harsh Raj, Ivan Bercovich, Lin Shi, Jeong Yeon Shin, Thomas Walshe, E. Kelly Buchanan, Junhong Shen, Guanghao Ye, Haowei Lin, Jason Poulos, Maoyu Wang, Marianna Nezhurina, Jenia Jitsev, Di Lu, Orfeas Menis Mastromichalakis, Zhiwei Xu, Zizhao Chen, Yue Liu, Robert Zhang, Leon Liangyu Chen, Anurag Kashyap, Jan-Lucas Uslu, Jeffrey Li, Jianbo Wu, Minghao Yan, Song Bian, Vedang Sharma, Ke Sun, Steven Dillmann, Akshay Anand, Andrew Lanpouthakoun, Bardia Koopah, Changran Hu, Etash Guha, Gabriel H. S. Dreiman, Jiacheng Zhu, Karl Krauth, Li Zhong, Niklas Muennighoff, Robert Amanfu, Shangyin Tan, Shreyas Pimpalgaonkar, Tushar Aggarwal, Xiangning Lin, Xin Lan, Xuandong Zhao, Yiqing Liang, Yuanli Wang, Zilong Wang, Changzhi Zhou, David Heineman, Hange Liu, Harsh Trivedi, John Yang, Junhong Lin, Manish Shetty, Michael Yang, Nabil Omi, Negin Raoof, Shanda Li, Terry Yue Zhuo, Wuwei Lin, Yiwei Dai, Yuxin Wang, Wenhao Chai, Shang Zhou, Dariush Wahdany, Ziyu She, Jiaming Hu, Zhikang Dong, Yuxuan Zhu, Sasha Cui, Ahson Saiyed, Arinbjörn Kolbeinsson, Jesse Hu, Christopher Michael Rytting, Ryan Marten, Yixin Wang, Alex Dimakis, Andy Konwinski, and Ludwig Schmidt. Terminalbench: Benchmarking agents on hard, realistic tasks in command line interfaces, 2026. URL https://arxiv.org/abs/2601.11868. OpenAI. Introducing codex. https://openai.com/index/introducing-codex/, May 2025. OpenClaw. Clawhub: Open skill registry for AI agents, 2026. URL https://clawhub.ai. 11
Renjie Pi, Grace Lam, Mohammad Shoeybi, Pooya Jannaty, Bryan Catanzaro, and Wei Ping. On data engineering for scaling llm terminal capabilities, 2026. URL https://arxiv.org/ abs/2602.21193. Richard S. Sutton, Doina Precup, and Satinder Singh. Between MDPs and semi-MDPs: A framework for temporal abstraction in reinforcement learning. Artificial Intelligence, 112(1–2):181– 211, 1999. OpenThoughts-Agent Team. OpenThoughts-Agent. https://www.open-thoughts.ai/blog/agent, December 2025. Tencent Hy Team. Hy3 preview: The first step in rebuilding the hy model, 2026. URL https: //hy.tencent.com/research/hy3. Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. Voyager: An open-ended embodied agent with large language models, 2023. URL https://arxiv.org/abs/2305.16291. Lilin Wang, Lucas Ramalho, Alan Celestino, Phuc Anthony Pham, Yu Liu, Umang Kumar Sinha, Andres Portillo, Onassis Osunwa, and Gabriel Maduekwe. Swe-bench++: A framework for the scalable generation of software engineering benchmarks from open-source repositories, 2025a. URL https://arxiv.org/abs/2512.17419. Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song, Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig. Openhands: An open platform for ai software developers as generalist agents, 2025b. URL https://arxiv.org/abs/2407.16741. Siwei Wu, Yizhi Li, Yuyang Song, Wei Zhang, Yang Wang, Riza Batista-Navarro, Xian Yang, Mingjie Tang, Bryan Dai, Jian Yang, and Chenghua Lin. Large-scale terminal agentic trajectory generation from dockerized environments, 2026. URL https://arxiv.org/abs/2602. 01244. An Yang, Anfeng Li, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Gao, Chengen Huang, Chenxu Lv, Chujie Zheng, Dayiheng Liu, Fan Zhou, Fei Huang, Feng Hu, Hao Ge, Haoran Wei, Huan Lin, Jialong Tang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxi Yang, Jing Zhou, Jingren Zhou, Junyang Lin, Kai Dang, Keqin Bao, Kexin Yang, Le Yu, Lianghao Deng, Mei Li, Mingfeng Xue, Mingze Li, Pei Zhang, Peng Wang, Qin Zhu, Rui Men, Ruize Gao, Shixuan Liu, Shuang Luo, Tianhao Li, Tianyi Tang, Wenbiao Yin, Xingzhang Ren, Xinyu Wang, Xinyu Zhang, Xuancheng Ren, Yang Fan, Yang Su, Yichang Zhang, Yinger Zhang, Yu Wan, Yuqiong Liu, Zekun Wang, Zeyu Cui, Zhenru Zhang, Zhipeng Zhou, and Zihan Qiu. Qwen3 technical report, 2025a. URL https://arxiv.org/abs/2505.09388. John Yang, Akshara Prabhakar, Karthik Narasimhan, and Shunyu Yao. Intercode: Standardizing and benchmarking interactive coding with execution feedback, 2023. URL https://arxiv. org/abs/2306.14898. John Yang, Kilian Lieret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang. Swe-smith: Scaling data for software engineering agents, 2025b. URL https://arxiv.org/abs/2504.21798. Linghao Zhang, Shilin He, Chaoyun Zhang, Yu Kang, Bowen Li, Chengxing Xie, Junhao Wang, Maoquan Wang, Yufan Huang, Shengyu Fu, Elsie Nallipogu, Qingwei Lin, Yingnong Dang, Saravan Rajmohan, and Dongmei Zhang. Swe-bench goes live!, 2025. URL https://arxiv. org/abs/2505.23419. Kaijie Zhu, Yuzhou Nie, Yijiang Li, Yiming Huang, Jialian Wu, Jiang Liu, Ximeng Sun, Zhenfei Yin, Lun Wang, Zicheng Liu, Emad Barsoum, William Yang Wang, and Wenbo Guo. Termigen: High-fidelity environment and robust trajectory synthesis for terminal agents, 2026. URL https://arxiv.org/abs/2602.07274.
12
A
P ROOF OF E QUIVALENCE
We show that the skill-level objective in Equation 3 reduces to the standard next-action objective under three assumptions: (A1) the mapping ζ 7→ ξ is deterministic, (A2) each scenario σt is a sufficient statistic for the agent’s next decision, and (A3) each skill κt = (ait , . . . , ajt ) is executed autoregressively. Under (A2) and (A3), the chain rule of conditional probability gives log π(κt | σt−1 , g) =
jt X
log π(ak | o≤k , a<k , g).
(5)
k=it
Summing over t = 1, . . . , L and using the contiguity it+1 = jt + 1, the double sum collapses into a single sum over all actions. Taking expectations and applying (A1) yields J (π) = Eξ∼D
L X
log π(κt | σt−1 , g) = Eζ∼D
t=1
T −1 X
log π(at | o≤t , a<t , g).
(6)
t=0
The equivalence shows that the scenario–skill abstraction imposes no additional training machinery, and properties of D established at the scenario–skill level (e.g., the coverage criterion in Equation 4) transfer directly to the token-level loss.
B
S KILL G RAPH C ONSTRUCTION D ISCUSSION
All LLM calls use DeepSeek Reasoner (v3.2) to ensure extraction quality and reliability. We also explored several alternative graph construction strategies, including embedding-based scenario alignment and single-pass subgraph generation; we found that the LLM-based pairwise alignment approach yields higher-quality graphs. We cluster scenarios using a two-stage scalable hierarchical procedure. First, we construct a sparse semantic similarity graph over normalized scenario embeddings and apply Louvain community detection (Blondel et al., 2008) to obtain coarse buckets. Then, within each bucket, we run completelinkage agglomerative clustering (Johnson, 1967) with cosine distance to avoid the quadratic memory cost of global hierarchical clustering while preserving the desirable property of complete linkage: every pair within a cluster must be mutually close, preventing chain-drift artifacts where transitively linked but semantically distant scenarios get merged (e.g., A is close to B and B is close to C, but A and C are semantically different.). For the clustering hyperparameters, we sweep the agglomerative distance threshold on held-out scenario samples and manually inspect the resulting clusters. We choose the final threshold by balancing merge quality and over-fragmentation: the selected value should merge clear paraphrases and near-equivalent states while keeping semantically distinct states, especially negations and pre/post condition changes, in separate clusters.
C
S UPERVISED F INE -T UNING
We perform supervised fine-tuning with AdamW, using β1 = 0.9 and β2 = 0.95, together with a cosine learning rate schedule and a warmup ratio of 10%. The peak learning rate is set to 2 × 10−5 and the weight decay is 1×10−4 unless otherwise noted. We train all models for 5 epochs in bfloat16 precision. To stabilize optimization on long terminal trajectories, we apply gradient clipping with a maximum norm of 1.0. Training uses a micro-batch size of 1 per GPU and gradient accumulation to achieve the desired global batch size.
D
S KILL G RAPH A NALYSIS
Table 6 summarizes the structural properties of the skill graph G constructed in § 3.2. 13
Metric
Value
Scenario nodes |S| Skill-labeled transitions |E| Source-only scenarios Sink-only scenarios Bridge scenarios
82,073 57,214 18,749 (22.8%) 12,299 (15.0%) 46,699 (56.9%)
Mean / Median / Max degree Connected components Giant component
4.32 / 2 / 752 6,251 118,806 (85.6%)
Component size
Count
2 3–5 6–10 11–50 >50
482 5,561 183 24 1
Total
6,251
Table 6: Left: Structural statistics of the skill graph G. Right: Connected component size distribution. Coding Agents & IDEs General Automation & Utilities Documents, PDF & OCR Testing & Quality Assurance DevOps & Cloud Infrastructure Security & Compliance Knowledge, Memory & Notes Productivity & Task Management Operations & Monitoring Writing, Blogging & SEO Web & Frontend Development Data Analysis & Visualization AI/LLM Model Operations Communication & Messaging Image, Video & Creative Media Research & Literature Finance & Accounting Browser & Web Automation E-commerce, Sales & CRM Games, 3D & Simulation Audio & Speech Legal, Admin & Governance Mobile & App Development Health, Wellness & Lifestyle IoT, Hardware & Robotics Education & Learning
0%
3%
6%
9%
12%
Share (%)
Figure 5: Skill category distribution. 100
The degree distribution (Figure 6) is heavy-tailed: the median node degree is 2, while a small number of hub scenarios reach degree 752, correspond10−2 ing to generic intermediate states compatible with many skills. This motivates the inverse-frequency −3 10 sampling in § 3.3. The connected component distrimean 4.32 10−4 bution (Table 6, right) is dominated by a single giant median 2 component of 118,806 nodes (85.6%), confirming max 752 −5 10 that the cross-skill alignment stage chains the majority of skills into a single traversable subgraph. Fig100 101 102 103 Node degree ure 5 shows that the graph covers both common domains, such as coding agents, document processing, DevOps, and security, as well as long-tail domains, Figure 6: Degree distribution of the skill such as audio/speech, 3D simulation and IoT/hardware workflows. graph.
CCDF
10−1
E
P ROMPTS
The prompts used to extract skills and scenarios from trajectories, and to cluster embeddings to obtain unique instances, are provided below. We use DeepSeek Reasoner (v3.2) for extraction and Microsoft/Harrier-OSS-v1-27B for embedding. 14
Prompt Name
Trajectory Analysis
You are analyzing a terminal agent trajectory to extract its semantic structure. TRAJECTORY: {{{observation_action_sequence}}} Your task: Segment this trajectory into a sequence of (scenario, skill ) pairs, where: - A SCENARIO is the semantic state of the environment at a decision point (e.g., "Python project with failing unit tests", "empty Git repository", "server container with missing dependency"). - A SKILL is a coherent multi-step workflow the agent executes to transition from one scenario to the next (e.g., "run pytest and capture output ", "install missing package via pip", "create a Dockerfile for the service"). Output a JSON array of pairs: ‘‘‘json [ { "step_range": [start_index, end_index], "scenario": "<brief semantic description of the state before this skill>", "skill": "<brief description of the workflow executed in this range>" }, ... ] ‘‘‘ Keep scenario and skill descriptions under 15 words each. Return ONLY the JSON array, no other text.
Prompt Name
Embedding Scenarios
Instruct: Retrieve scenarios that describe the same real-world condition. Query: {{{scenario}}}
Prompt Name
Embedding Skills
Instruct: Retrieve skills that perform the same workflow. Query: {{{skill}}}
15