Training Long-Horizon Terminal Agents on Environments That Do Not Do the Work for Them ── A preprint proposing TerminalHorizon, which uses independent execution to find the work that environment synthesis quietly removed

1. Short trajectories do not show how work actually gets done

A terminal agent is an AI system that works through a command line: it edits files, runs programs and checks the results on its own. The abstract describes these agents as moving beyond local operations toward finishing real professional tasks.^[1]

Handing over a real task takes more than knowing individual commands. The agent has to explore and collect evidence, use that evidence to make judgments, change course when feedback says it should, and turn intermediate results into something that can be delivered. The authors point out that short trajectories can demonstrate commands and tool calls, but they do not capture this chain of behavior or how its steps connect inside one problem-solving episode.

Long trajectories should fill that gap. The difficulty is in how the practice environments are produced. When a task, its files and its tools are synthesized automatically, the construction step may complete or simplify the key work in advance. The result is a task that no longer requires exploration, implementation or verification. Collecting long trajectories on such tasks does not teach the behavior the trajectories were supposed to contain. That is the problem the abstract sets out to address.

2. The core idea: run the task to find what the environment already did

TerminalHorizon is described as a fully automated engine for synthesizing training data for long-horizon terminal agents, starting from real-world professional work.

This article treats one mechanism as the center of the method: inspection by independent execution. The engine runs the task separately inside the constructed environment. That run exposes key work that was omitted or pre-completed during construction, and the resulting evidence guides a reconstruction of the environment. Instead of estimating difficulty by reading the task statement, the design checks, by actually running things, whether the work the agent is meant to do is still there.

The second mechanism is progressive expansion. Under the same overall goal, the engine adds new requirements that build on results from earlier stages and call for further exploration and improvement. According to the authors, this stretches the explore-judge-revise pattern across several stages of a single task. The abstract does not say which model performs the independent execution or what procedure it follows.

3. What the abstract reports

• Scale of environments: the engine was used to build 1.5K task environments.
• Training: Qwen3.5-27B was fine-tuned with supervised learning on the resulting data, producing TerminalHorizon-27B.
• Evaluation: the authors report substantial gains on all 12 benchmarks, which span coding-agent tasks, agentic tasks in real-world production settings, and general reasoning.
• Case studies: several RSI case studies, each with a 12-hour research budget, are said to show the model continuing to experiment beyond an initial solution, revising its methods from feedback, and keeping effective improvements in the final deliverable. The abstract uses only the acronym; it reads as recursive self-improvement.

Two cautions apply. "Substantial gains" is the abstract's wording; it gives no effect sizes, no baselines and no benchmark names. Whether the comparison is against the same model before fine-tuning or against models fine-tuned on other agentic data changes what the result means. For the case studies, the abstract does not say how success was judged or how often it occurred.

4. A worked example: rebuilding a summary table from updated data

Where exactly does key work disappear when long tasks are generated automatically? Consider a task close to pharmaceutical practice. The environment holds a clinical study's summary program and its source data. The instruction is: "Regenerate the summary tables from the latest data cut and write a note explaining what changed since the previous version."

This is an illustration of the TerminalHorizon idea, not a task taken from the paper; the abstract does not list its task domains. The point is that the same instruction can yield very different trajectories depending on whether the environment still contains the work.

5. What is not new, and where the limits are

Synthesizing agent environments automatically and fine-tuning on trajectories collected in them is an established line of work. ProgramGym, posted the same week, also proposes building verifiable training environments from repositories.^[3] Feeding execution results back into environment construction is likewise familiar from methods that run tests to check task quality. On the evaluation side, benchmarks such as Terminal-Bench already pair each terminal task, drawn from real workflows, with its own environment and automated tests.^[4] The abstract does not say whether Terminal-Bench is among the 12 benchmarks used here. The contribution here, as far as the abstract shows, is naming a specific failure mode, environments that do the agent's work in advance, and pairing a detect-and-rebuild step for it with progressive task expansion under a fixed goal.

Several limits are visible from the abstract alone. First, the size of the gains and the baselines are not given. Second, without the list of 12 benchmarks, there is no way to judge how close the evaluation tasks are to the training tasks; if they come from similar kinds of work, part of the improvement could reflect that overlap. Third, there is no measure of how reliably independent execution finds omitted work, or how much it misses.

Fourth, the case studies illustrate a capability; they are not an evaluation of how often it appears. Fifth, the abstract does not say whether the data or model will be released, and no GitHub repository was registered when the paper was collected. Reproduction cannot be checked yet.

6. Why this topic is clustering: attention is moving to how training environments are built

The selection system behind this article gives weight to clusters: independent papers asking the same question within a short window. This cluster has size 2. The other paper is ProgramGym.^[3]

The shared keywords include long-horizon, environments, scaling and training. ProgramGym targets agents that study a reference program and then rebuild it from scratch, and it constructs verifiable training environments from repositories at scale. The domains differ, terminal work versus program reproduction, but both answer the same question: long-horizon behavior needs training environments that do not yet exist in sufficient number or quality. One reading is that effort is shifting from changing the model to changing where the model is trained.

On Hugging Face Daily Papers the paper received 132 upvotes.^[2] That number says the paper caught researchers' attention. It does not say the claims are correct or that anyone has reproduced them. A cluster of two is also small, and whether this becomes a sustained topic depends on what follows.

7. What connects to pharmaceutical and regulatory practice

Pharmaceutical organizations run many long terminal-based tasks: updating clinical summary programs, refreshing analysis environments, assembling datasets for regulatory submissions. Each follows the same arc of investigating, deciding, fixing and delivering. If such work is ever delegated to agents, the question of what tasks the agent was trained on belongs next to its benchmark scores.

The failure mode this paper names also applies to anyone evaluating an agent in-house. If the person who prepares a test task also cleans up the data beforehand, the agent can pass without doing the part that matters. Before adoption, someone other than the task author should run the task and confirm that the work the organization actually wants delegated is still present. This lines up with the computerized system validation practice of separating the people who write test scripts from those who execute and review them.

The second issue is an agent that keeps experimenting over long stretches and revises its own methods. That may help exploratory research. In a GxP setting it requires a record that lets a reviewer reconstruct when, what and why something changed. The abstract says the model keeps effective improvements in its final deliverables, but it says nothing about how the process is recorded. Organizations considering such agents need to decide the form of that process record before the agent starts, not only the form of the deliverable.