Pith.

Artificial Intelligence · arXiv:2607.27929 v1 · submitted 30 Jul 2026 · 15 references

Meta-Task: Turning Terminal Task Synthesis into a Terminal Task for Scalable Agent Training

Zhihong Pan, Jiyuan He, Kai Zhang, Yupeng Han, Ze Liu, Yuze Zhao, Yongcong Ye, Zhaohua Yang

The paper says

“Training terminal agents at scale requires diverse, verifiable terminal tasks and high-quality interaction trajectories, yet acquiring such data remains a significant challenge.”

more of the abstract

Existing synthesis methods face two key limitations: (1) weak reliability caused by the disconnect between task generation and real execution, and (2) limited diversity and scalability due to dependence on existing repositories. We propose Meta-Task, a framework that redefines terminal task synthesis as a Terminal-Bench-format task itself: an agent operates within a real container environment to iteratively generate, execute, and verify tasks, so that synthesized components are checked for internal consistency and executability within the generation loop itself. Building upon this, we decouple the target task requirements along multiple dimensions, introduce a multi-phase mechanism that dynamically designs novel task specifications before producing the actual tasks, and incorporate optional external material support to enhance diversity and realism. We additionally apply LLM-as-Judge filtering to ensure the quality of the final training data. Experiments on Terminal-Bench 2.0 show that fine-tuning on only 3,221 Meta-Task synthesized trajectories achieves 22.5% and 31.8% Avg Pass@1 for Qwen3-14B and Qwen3-32B respectively, outperforming concurrent approaches with significantly less training data.

from the abstract

Pith says

Machine review · deepseek-v4-flash · 15 Aug 2026 · what was read was not recorded · not checked by a person

It can be wrong. Challenge this review or reply to it.

Holds up, with conditions. The meta-task framing is a genuinely new move in synthetic data for terminal agents, but the headline transfer gains are not yet protected against environment-level leakage. This line is wrong

3 major objections · 4 minor

How often objections from reviews like this one are right: not yet measured

Are you an author? What you can do.

Not checked: figures, code, what the 15 references say.

The paper says, at Section 2.5.2 and Section 2.2.3

The review did not quote this passage.

Pith says: Objection 1 of 3 · major

The decontamination check compares only instruction.md text pairs using word-level n-gram overlap, TF-IDF cosine similarity, and technical-entity matching, and reports that no pair is flagged as high risk. This does not rule out environment-level leakage. Because the Meta-Task pipeline explicitly grounds tasks in real open-source materials through the search-and-download tool for GitHub and HuggingFace, and because Terminal-Bench 2.0 tasks are …

more of objection 1

… similarly containerized with Dockerfiles, data files, scripts, and buggy code fragments, two tasks can share environment artifacts while having entirely different instruction texts. If any synthesized training task shares a Dockerfile, data file, or code fragment with a Terminal-Bench test task, the SFT model could memorize environment-specific commands and file layouts, inflating Avg Pass@1 without acquiring general terminal competence. Please add an environment-level decontamination check that compares file hashes or directory structures of synthesized task environments against Terminal-Bench 2.0 task environments, and report the thresholds used for the existing text-level check and the artifacts that were manually inspected.

The paper says, at Table 2 and Section 3.1

The review did not quote this passage.

Pith says: Objection 2 of 3 · major

The headline claim of outperforming concurrent methods is supported by numbers cited from other papers, but those baselines were evaluated with different scaffolds: TermiGen-32B uses BashAgent, LiberCoder models use OpenHands, and the other fine-tuned baselines use Terminus-2. Since scaffold choice materially affects Pass@1 on Terminal-Bench, as is evident from the spread of scores in Table 2, the comparison conflates data quality with scaffold differences.

more of objection 2

Please either re-run the baselines under the same Terminus-2 scaffold and evaluation harness, or explicitly caveat that the cross-method comparison is not controlled. In addition, the main results are reported only as means over three runs with no error bars or standard deviations, which is insufficient for assessing the stability of the claimed improvements.

The paper says, at Sections 2.4 and 2.5.1

The review did not quote this passage.

Pith says: Objection 3 of 3 · major

The same teacher model (Qwen3.5-397B) is used for task synthesis, trajectory sampling, and LLM-as-Judge filtering. This does not make the evaluation circular, since Terminal-Bench 2.0 is an external benchmark, but it may bias the filtered training data toward the teacher's own behavioral patterns and preferences.

more of objection 3

The paper would be strengthened by a small human-annotation study reporting agreement between the LLM judge's KEEP/DISCARD decisions and independent human raters on a random sample of trajectories, or by an ablation using a different judge model for filtering.

4 minor objections

The paper says, at Section 2.5.2

Pith says: minor objection 1 of 4

The statement that n-gram scores are 'essentially zero' should be quantified with specific thresholds and the distribution of scores rather than a qualitative description.

The paper says, at Figure 3

Pith says: minor objection 2 of 4

The axes in the scaling plots are not labeled; please specify what is plotted on the x- and y-axes, include units, and add error bars for the three runs if available.

show 2 more

The paper says, at Section 3.6 and Appendix C

Pith says: minor objection 3 of 4

The error analysis is based on manual inspection of 146 failed trajectories; please report the number of annotators, the annotation instructions, and the inter-annotator agreement for the four error categories.

The paper says, at Full text, near Figure 3

Pith says: minor objection 4 of 4

The manuscript contains an unresolved token sequence beginning with '/uni00000087/...' that appears to be a rendering or encoding artifact; it should be removed or fixed.

What would settle it

Release the synthesized task packages, or at least their environment file trees, and compute file-level MinHash/Jaccard similarity between each synthesized task's environment/ directory and each Terminal-Bench 2.0 test task's environment/ directory, after normalizing away generic boilerplate (base images, standard apt-get lines). Also compare normalized Dockerfile hashes and data-file hashes. If any non-generic file (data, scripts, configs, source code) has Jaccard similarity above a pre-registered threshold (e.g., >0.8) or an identical hash, quantify how many of the 3,221 training trajectories share such files with test tasks. As a stricter check, retrain on the subset of trajectories with no environment-file overlap and compare Avg Pass@1; if the score drops materially, environment leakage is confirmed.

from the skeptic's reading

How the review went

4 readings by deepseek-v4-flash · 15 Aug 2026

  1. Reader holds up, with conditions confidence moderate
  2. Skeptic agrees 55 s · 21,734 tokens read, 6,065 written
  3. Editor wrote the verdict above 21 s · 22,467 tokens read, 2,279 written
  4. Referee major revision: 3 major objections, 4 minor 32 s · 21,857 tokens read, 3,782 written

Not run on this paper: the simulated authors' defence.

Pith did not check this review's objections against the paper.

The review in full

The review in brief, machine-written

I read this one carefully. The core move—packaging task synthesis itself as a Terminal-Bench-format meta-task that an agent executes inside Docker—is new relative to the staged pipelines and repository-mining work I know. It also happens to be a good engineering decision: because the generation loop runs in a real container with pytest verification, a lot of the usual hallucination failure modes get caught. The multi-phase diversity mechanism and trajectory-level LLM-as-Judge filtering are sensible additions, and the ablation in Table 3 (judge-filtered 3,221 trajectories beat the 5,004 passed-only set by +3.3) is exactly the kind of internal control that makes me trust the pipeline's logic. The error analysis in Section 3.6 is unusually honest—80% of failures involve the agent declaring success while wrong, and they say so outright.

The soft spot is the decontamination check. Section 2.5.2 compares instruction.md pairs only—n-gram, TF-IDF, entity matching—then says manual inspection confirmed the highest-scoring pairs differ. That does not cover the environment directory, the Dockerfile, or the data files. Since the meta-task pipeline explicitly uses a GitHub/HuggingFace search-and-download tool to ground tasks in real materials, and Terminal-Bench 2.0 tasks are also containerized terminal tasks, two tasks with entirely different instructions can share the same repository, script, or data artifact. If that happens anywhere in the 3,221 training trajectories, the SFT model can memorize environment-specific layouts and commands, and the reported 5.2→22.5 / 4.1→31.8 jumps become inflated by leakage rather than capability. That is a direct alternative explanation for the headline claim, and the paper does not address it. I don't think this is fatal—the internal ablations and scaling curves are consistent with a real effect—but it means the headline numbers are not yet trustworthy.

Two smaller issues. The comparison against concurrent methods relies on cited numbers from different scaffolds and harnesses (BashAgent, OpenHands, Terminus-2), and there are no error bars on the main results. And the same Qwen3.5 teacher is used for generation, trajectory sampling, and judging; that won't create circularity in the derivation sense, but it can bias the selected data toward the teacher's own behavioral style. Worth a sentence of discussion, not a red flag.

Bottom line: the frame is valuable and will be picked up by people working on synthetic data for agentic training. It deserves a serious referee, but I would ask for environment-level decontamination (hashes or directory diffs of Dockerfiles and data files) or a release of the generated tasks before I'd trust the transfer numbers. If they can show no environment overlap, this becomes a solid contribution.

The strongest objection

The decontamination check in Section 2.5.2 compares only instruction.md pairs using n-gram overlap, TF-IDF similarity, and technical-entity matching. This cannot detect environment-level leakage. The Meta-Task pipeline (Section 2.2.3) explicitly grounds tasks in real open-source materials through a GitHub/HuggingFace search-and-download tool, and Terminal-Bench 2.0 tasks are also containerized terminal tasks. Two tasks can have entirely different instruction texts yet share the same Dockerfile, data files, scripts, or buggy code fragments. If any synthesized training task and Terminal-Bench test task draw on the same repository or data artifact, the SFT model can memorize environment-specific commands and file layouts, inflating Avg Pass@1 without acquiring general terminal competence. The reported check never compares environment directories, file hashes, or solution/test contents, and the manual inspection of highest-scoring pairs appears limited to instructions. Because the headline claim is specifically that 3,221 synthesized trajectories transfer better than much larger datasets, environment-level leakage is a direct alternative explanation for the gain.

The reader's weakest assumption was that the decontamination check guarantees no test-task leakage. I agree, and I sharpen the concern: the check is instruction-only, while the pipeline's grounding in real GitHub/HuggingFace materials makes environment-level leakage a live possibility. This is load-bearing because the central empirical claim is that 3,221 trajectories outperform much larger datasets on Terminal-Bench 2.0; if environment files are shared, the gains could come from memorization rather than transferable skill. The paper's execution-grounded synthesis loop, quality-filtering ablations, and scaling curves are real supporting evidence, but they do not rule out this failure mode. The appropriate resolution is not rejection but conditional acceptance pending artifact release and a file-level decontamination demonstration. Since the reader already issued a CONDITIONAL verdict, my recommendation is UNCHANGED; the added specificity strengthens the condition rather than altering the verdict. No ad hominem is intended; the concern is about the completeness of a reported check, not about author integrity.

The referee's report

If the results hold, Meta-Task is a significant advance in synthetic data generation for terminal agents: it directly addresses the reliability gap of prior generation pipelines by grounding synthesis in real execution, and the reported data efficiency (3,221 trajectories) is striking. The internal evidence is on the whole credible: the quality-filtering ablation (Table 3) shows a consistent gain, the scaling curves (Figure 3) are monotonic, and the error analysis (Table 4) identifies concrete and plausible failure modes. The reframing of synthesis as a Terminal-Bench task is elegant and allows reuse of advanced agent scaffolds. However, the headline comparison against concurrent methods is weakened by the reliance on cross-paper numbers obtained with different scaffolds, and the decontamination check described in Section 2.5.2 does not rule out environment-level leakage, which would directly confound the data-efficiency claim. The central method is defensible, but the empirical claims require additional verification before acceptance.

Pith's reading of the paper (a machine's summary, not the authors')

This paper's claim is that the bottleneck in training terminal-using agents is not the size of the dataset but how the data is made. In Meta-Task, every data-generation request is packaged as a terminal task in the same format the agent will later be evaluated on: a container, an instruction, and automated tests, and an agent must design the new task, write its environment and solution, run it, and fix failures before anything is kept. Fine-tuning on just 3,221 such self-verified trajectories raises a 14-billion-parameter model from 5.2% to 22.5% and a 32-billion-parameter model from 4.1% to 31.8% average Pass@1 on the held-out Terminal-Bench 2.0 benchmark, beating concurrent synthesis pipelines that used 50.7K or even 490.5K training trajectories. The practical stake is that high-quality agent training data can be produced by the same agentic capabilities it is meant to teach, rather than mined from repositories or written by hand.

What carries the argument. The load-bearing object is the meta-task: a synthesis request packaged in the same format as the evaluation tasks, with a fixed instruction template, a prebuilt Docker environment, example tasks, an output template, and automated tests that check the generated package's structure and consistency. Its work is to make execution feedback part of data creation: the agent sees real install errors, test failures, and solution mismatches, and the self-validation checklist forces instruction, environment, solution, and tests to agree before a task is accepted. Two supporting mechanisms extend coverage and quality: decoupled category, scenario, and difficulty templates plus a multi-phase mode that designs new specifications from topic and style seeds, and a trajectory-level LLM-as-Judge filter that removes successful but low-signal trajectories.

Core claim. The paper's central claim is that task synthesis and task solving can be the same activity: each synthesis request is turned into a meta-task, a complete benchmark-format package whose instruction asks an agent to produce another package containing instruction.md, a Dockerfile, a reference solution, and pytest verification tests. The generating agent works inside a live container, explores example tasks, optionally searches real code and data, writes the package, runs the solution, executes the tests, and iterates until everything passes, so a task's executability and internal consistency are checked inside the generation loop rather than in a separate stage. From roughly 15,000 synthesized packages the authors sampled 14,040 teacher trajectories, kept 5,004 that passed execution, and after an LLM-as-Judge screen retained 3,221 for supervised fine-tuning; on Terminal-Bench 2.0 these trajectories lift Qwen3-14B from 5.2% to 22.5% and Qwen3-32B from 4.1% to 31.8% average Pass@1, outperforming concurrent pipelines trained on substantially more data.

The premise it rests on. The load-bearing assumption is that no synthesized training task leaks or duplicates the held-out test tasks: the decontamination check is described qualitatively, without released artifacts or thresholds, and if near-duplicates slipped through, the reported gains could be memorization rather than capability.

If the paper is right (Pith's inferences, not the authors')

If the central claim holds, data volume is not the limiting factor for terminal-agent training; a few thousand execution-grounded trajectories can beat hundreds of thousands of synthesized or mined ones.

The scaling curves show performance still rising at 3,221 trajectories, so the pipeline should keep paying off as more meta-tasks are run.

Trajectory quality filtering is a genuine training lever: removing shortcut and low-signal trajectories raised Pass@1 by 3.3 points even while reducing the dataset from 5,004 to 3,221 examples.

Because meta-tasks are standard benchmark packages, new domains and scaffolds can be added without redesigning the pipeline, only by adding new topic seeds or swapping the agent scaffold.

At the same model scale the 32B fine-tuned model surpasses concurrent 32B fine-tuned systems and a 480B coder model, suggesting targeted terminal task training can partly substitute for model scale.

The same 'synthesis as an executable task' pattern could transfer to other domains with verifiable outcomes, such as database administration, web agents, or simulation-based robotics, wherever a task can be packaged with tests rather than judged by a human.

The teacher's 35.6% pass rate on generated tasks could be reinterpreted as a difficulty signal: trajectories on tasks near the teacher's ability frontier may be more informative than either trivially solvable or unsolvable ones, though the paper does not test this.

A natural stress test would replace the LLM-as-Judge with automated proxies already hinted at in its rubric, such as interaction-turn length and absence of answer-file reads, to see whether the +3.3-point filter gain survives without a judge model.

Check this review

Pith stored no record of this review's passes and took no fingerprint of it. Reviews made by code from 13 Nov 2026 on carry both.

How often reviews like this one are right

Reviews like this one: written by deepseek-v4-flash, where what was read was not recorded.

How often objections from reviews like this one are right: not yet measured

Every value above, in the review's public record (JSON)

Reviews by people

This review was written by a machine. No person has reviewed this paper on Pith yet. A scientist listed on Pith can review it for a fee, and their review is published here whatever it concludes.

Request a human review

How Pith checks papers · The full audit of this paper · Review history (2 versions)

The paper

Abstract

Training terminal agents at scale requires diverse, verifiable terminal tasks and high-quality interaction trajectories, yet acquiring such data remains a significant challenge. Existing synthesis methods face two key limitations: (1) weak reliability caused by the disconnect between task generation and real execution, and (2) limited diversity and scalability due to dependence on existing repositories. We propose Meta-Task, a framework that redefines terminal task synthesis as a Terminal-Bench-format task itself: an agent operates within a real container environment to iteratively generate, execute, and verify tasks, so that synthesized components are checked for internal consistency and executability within the generation loop itself. Building upon this, we decouple the target task requirements along multiple dimensions, introduce a multi-phase mechanism that dynamically designs novel task specifications before producing the actual tasks, and incorporate optional external material support to enhance diversity and realism. We additionally apply LLM-as-Judge filtering to ensure the quality of the final training data. Experiments on Terminal-Bench 2.0 show that fine-tuning on only 3,221 Meta-Task synthesized trajectories achieves 22.5% and 31.8% Avg Pass@1 for Qwen3-14B and Qwen3-32B respectively, outperforming concurrent approaches with significantly less training data.

The paper's own sentences, arranged, kept beside the review and separate from it. Each label is drawn from a closed vocabulary; the number beside it is the probability the classifier gave that label. No sentence in this record was written by a model.

abstract compiled · 2026-09-23

The authors' main claim, as the classifier picked it out 1.00

“Experiments on Terminal-Bench 2.0 show that fine-tuning on only 3,221 Meta-Task synthesized trajectories achieves 22.5% and 31.8% Avg Pass@1 for Qwen3-14B and Qwen3-32B respectively, outperforming concurrent approaches with significantly less training data.”

How the main claim is stated: asserted 1.00

What the abstract itself states, as probabilities: claims first 0.07 · states limitation 0.12 · human participants 0.03 · controlled comparison 0.57 · randomized assignment 0.01 · states quantitative result 0.99 · compares with prior results 0.93 · mentions code or data availability 0.05

The abstract, sentence by sentence

This table labels the abstract only (arXiv listing abstract v1). The number is the probability the classifier gave the label.

SentenceRoleThe authors' own workStates the main conclusionStrength
Training terminal agents at scale requires diverse, verifiable terminal tasks and high-quality interaction trajectories, yet acquiring such data remains a significant challenge. background 0.86 0.06 0.03 asserted 1.00
Existing synthesis methods face two key limitations: (1) weak reliability caused by the disconnect between task generation and real execution, and (2) limited diversity and scalability due to dependence on existing repositories. gap 0.59 0.04 0.02 asserted 1.00
We propose Meta-Task, a framework that redefines terminal task synthesis as a Terminal-Bench-format task itself: an agent operates within a real container environment to iteratively generate, execute, and verify tasks, so that synthesized components are checked for internal consistency and executability within the generation loop itself. method 0.51 0.82 0.13 asserted 0.99
Building upon this, we decouple the target task requirements along multiple dimensions, introduce a multi-phase mechanism that dynamically designs novel task specifications before producing the actual tasks, and incorporate optional external material support to enhance diversity and realism. method 0.88 0.88 0.04 asserted 0.98
We additionally apply LLM-as-Judge filtering to ensure the quality of the final training data. method 0.94 0.92 0.03 asserted 0.99
Experiments on Terminal-Bench 2.0 show that fine-tuning on only 3,221 Meta-Task synthesized trajectories achieves 22.5% and 31.8% Avg Pass@1 for Qwen3-14B and Qwen3-32B respectively, outperforming concurrent approaches with significantly less training data. result 1.00 0.96 0.72 asserted 1.00

What kind of paper the classifier reports this is: method or tool 1.00 · evidence from observation or experiment 0.99

What was examined, and what was not

Sources read

  • arXiv listing abstract v1

Not examined

  • full text
  • figures and tables
  • references and citing sentences
  • relations to other papers

Levels run

  • P abstract

Not run

  • S sections
  • T body sentences
  • C citations
  • R cross-paper relations

How the labels were made

Compiled by classifier-1.13.0 via TypeSafe API, question bank abstract-p1-20260923, 2026-09-23: 1 request, 5,190 input tokens.

Every quoted sentence on this record is the authors'. Every label is from Pith's closed vocabulary, with the probability shown beside it. This record as JSON

Figures (8)
Figure 1 of the paper
Figure 1. Left: the file structure of a Terminal-Bench
Figure 2 of the paper
Figure 2. Overview of the Meta-Task pipeline. Stage 1 (Meta-Task Generation): decoupled diversity dimensions (category, scenario, difficulty) are composed into a meta-task instruction via single-phase composition or multi-phase dynamic task specification design, paired with a pre-configured Docker environment. Stage 2 (Agent Synthesis): an agent executes the meta-task inside a Docker container, exploring examples, searching real materials, designing and implementing new tasks, and iteratively self-validating until all checks pass. Stage 3 (Quality Filtering): a teacher model samples…
Figure 3 of the paper
Figure 3. Scaling behavior of Meta-Task-synthesized
Figure 4 of the paper
Figure 4. Task quality, diversity, and trajectory analysis. (a) Task quality evaluation across synthesis methods (50
Figure 5 of the paper
Figure 5. A synthesized task example from Meta-Task. Top: the task instruction describing a buggy type checker to
Figure 6 of the paper
Figure 6. Meta-Task synthesis instruction template (fixed parts). Variable placeholders
Figure 7 of the paper
Figure 7. Multi-phase synthesis prompt (Phase 1). The agent dynamically designs a new category and scenario
Figure 8 of the paper
Figure 8. Trajectory-level LLM-as-Judge quality review prompt for filtering SFT training data.

Figures are the authors', reproduced from the paper.

References (15)
  1. [1] Specialized Knowledge Required:The task must require domain exper- tise that goes beyond basic programming (e.g., cryptographic algorithms, compiler internals, signal processing, bioinformatics). A general-purpose developer should NOT be able to solve it without learning new concepts on Pith
  2. [2] Non-Obvious Solution Path:The solution must NOT be a straightfor- ward “read input→ process→ write output” pipeline. Require creative problem-solving, algorithm design, or reverse engineering. Include at least one step where the solver must discover or infer something not expl... on Pith
  3. [3] Difficulty from the Materials, Not Artificial Constraints:The chal- lenge should come from the inherent complexity of the real materials. Do NOT make tasks hard by just adding arbitrary time limits or format restrictions on top of a simple problem on Pith
  4. [4] Multi-Stage Verification:Tests must verify multiple intermediate or final artifacts. Include at least 3 distinct verification checks. Verify both correctness AND constraints (performance, size, format) on Pith
  5. [5] Real-World Complexity:Model realistic scenarios with edge cases and error conditions. Include at least one “trap” that a naive implementation would fail on. The task should take an expert 30+ minutes to solve. Anti-patterns to A VOID:Simple CRUD operations; Tasks solvable with... on Pith
  6. [9] Print "Type: <type>" for each successful type inference on Pith
  7. [10] Print "Error: <message>" for type errors on Pith
  8. [11] Programs that should fail (like self-application) will show errors - that's correct behavior the test programs in `/app/test_programs/` have comments saying what type they should infer or whether they should fail. just make the type checker actually correct? Dockerfile FROM py... on Pith
  9. [12] Simple types are inferred correctly on Pith
  10. [13] Polymorphic let-bindings work on Pith
  11. [14] Occurs check prevents infinite types on Pith
  12. [15] Type errors are properly rejected """ import sys import os import pytest sys.path.insert(0, "/app") def run_type_inference(source: str): """ Run the type inference engine on source code. Returns (type_string, error_message) tuple. """ # Import fresh to get the fixed version im... on Pith
  13. [18] and tests inline with 5 self-chosen vectors (<script>, onclick, javascript: href). All pass. Marks complete at Step 23: “Filter thor- oughly tested and working.” Verifier:assert 4 == 0 (4 vector groups failed). Cause:Actual suite applies 400+ vec- tors with encoded JS, uncommo... on Pith
  14. [2025] Qwen3 technical report.arXiv preprint arXiv:2505.09388. John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent-computer interfaces enable automated software engineering.Advances in Neural Information... on PithPith's reviewarXiv
  15. [2026] Swe-smith: Scaling data for software engineer- ing agents.Advances in Neural Information Process- ing Systems, 38. John Yang, Akshara Prabhakar, Karthik Narasimhan, and Shunyu Yao. 2023. Intercode: Standardizing and benchmarking interactive coding with execution feedback.Prepr... on PithPith's reviewarXiv
Cited by 3 Pith papers
How the literature uses it

What this paper does with the arXiv papers it cites

Each citing sentence is taken from the citing paper's LaTeX source and typed by Pith's classifier. A label appears at probability 0.8 or more (0.95 for support), a contest at 0.7 or more; the quoted words are the citing authors'. How each label was checked · JSON

What it cites · 11 sentences without a confident label

Uses the method or tool of 2 papers
Compares with 5 papers
  • Fine-tuned models: we compare with recent concurrent works on terminal task synthesis, including TerminalTraj [ref] , CLI-Gym [ref] , TermiGen [ref] , Nemotron-Terminal [ref] and SkillSynth [ref] .

    2602.07274 · Experimental Setup · 0.99

  • Fine-tuned models: we compare with recent concurrent works on terminal task synthesis, including TerminalTraj [ref] , CLI-Gym [ref] , TermiGen [ref] , Nemotron-Terminal [ref] and SkillSynth [ref] .

    Large-Scale Terminal Agentic Trajectory Generation from Dockerized Environments · Experimental Setup · 0.99

  • Fine-tuned models: we compare with recent concurrent works on terminal task synthesis, including TerminalTraj [ref] , CLI-Gym [ref] , TermiGen [ref] , Nemotron-Terminal [ref] and SkillSynth [ref] .

    2602.10999 · Experimental Setup · 0.99

Cites as support 1 paper
  • This result confirms that trajectory quality matters more than quantity for training terminal agents, consistent with findings in CLI-Gym [ref] .

    2602.10999 · Ablation: Quality over Quantity · 0.99

Cites as background 17 papers

Challenges and discussion

Disagree with the review, or know something it missed? Leave a comment, or challenge this review formally: a challenge becomes a permanent entry in this paper's record, and its decision is published here.

No comments yet.

Sign in to comment