FACET Grounds Terminal-Agent Tasks in Executable State

Introduction

Training an agent to work in a terminal is not simply a matter of teaching it to produce shell commands. The training data must also define tasks that can actually run and be evaluated correctly. A typical terminal task combines a natural-language instruction, an initialized environment, a reference solution, and an executable verifier. If these artifacts are produced from different assumptions, the task may be impossible, or a correct solution may be marked as wrong.

FACET, or Fine-grained Agentic Construction of Executable Tasks, addresses this problem as a data-construction challenge. The framework is designed to preserve the goals, dependencies, state transitions, and procedural constraints found in source material while maintaining consistency across the final task artifacts. Its central idea is to make the executable environment the shared basis for task construction rather than treating it as a late-stage implementation detail.

How FACET works

• Reconstructing source intent. Related agent skills are organized into coherent and information-rich scenarios. This is intended to reduce the loss of requirements that can occur when source material passes through several synthesis stages.
• Realizing the environment first. FACET builds the container state and repairs it through execution before producing the final instruction, solution, and verifier. The resulting state provides a common grounding point.
• Validating by running the task. Components are checked through execution, allowing the system to detect whether the proposed solution works in the environment and whether the verifier recognizes the intended outcome.
• Repairing selectively. When a failure is specific to one artifact, the framework targets that artifact instead of regenerating every component. Valid work can therefore be retained while local inconsistencies are corrected.

Why this matters

Many synthetic-data pipelines generate task descriptions, solutions, and evaluation scripts as loosely connected outputs. That approach may scale in volume, but it is fragile for long-horizon terminal work. Hidden files, dependencies, intermediate state changes, and ordering constraints can accumulate across steps. A mismatch in any one of them can turn a seemingly reasonable benchmark item into an invalid one.

FACET makes the environment the point where these elements meet. The instruction states what should be achieved, the reference solution describes one way to achieve it, and the verifier checks the result. The environment supplies the executable facts that all three must share. This design reframes validity as a property of the whole task rather than of an individual text field or script.

The supplied abstract says that FACET can produce complex tasks with dense executable checks. Successful trajectories collected from those tasks are presented as useful, data-efficient supervision, and fine-tuning across multiple model scales consistently improves performance on Terminal-Bench 2.1. The paper’s comparisons of alternative synthesis schemes also support environment-grounded construction as an important factor in task validity and solution–verifier alignment.

The available material is limited to the abstract, so it does not establish the exact number of tasks, the size of the reported gains, or the cost of repair. Those details should be checked in the full paper. Still, FACET offers a clear design principle for terminal-agent datasets: preserve what the source intended, and make every executable artifact answer to the same realized state.

Source: Hugging Face Daily Papers