Terminal · Coding · Multimodal
We provide terminal, coding, and multimodal training data for agents. Every task ships with its own reference solution and executable verifier, and every trajectory is verified and rewritten into one consistent harness, calibrated to the difficulty your model needs next.
Tasks run on the software practitioners actually use
What we provide
Terminal work is coding work: to finish a terminal task, the agent writes, runs, tests, and debugs real programs. The same verified environments extend to visual inputs, from engineering drawings to rendered pages.
Long-horizon command-line work across real tools, services, builds, and data: hundreds of commands toward one verified end state.
Every terminal task is a coding task. Agents write, test, and debug real programs, from rebuilding scientific software to shipping full-stack apps.
Visual inputs, code outputs: engineering drawings, renders, screenshots, meshes, and scientific images.
Examples
A sample of our software-reconstruction tasks. The agent sees public runs of real scientific and engineering software, writes a program that reproduces it, and is graded on hidden configurations it never saw. Every visual is rendered from the task's own files.
Spatial, Visual & 3D
Regenerate a swept fan-duct mount STL whose inlet size, outlet size, bend angle, and rib count change the geometry.
Physical & Engineering Simulation
Reconstruct a 2-D dam-break CFD workflow across water height, mesh, gravity, and simulation time.
Spatial, Visual & 3D
Reconstruct LED-matrix driver board outputs (DRC report and project files) under row, column, driver, and routing interventions.
Software & Formal Systems
Infer coupled container base-image, package-set, label, entrypoint, and SBOM-scope behavior.
Spatial, Visual & 3D
Reconstruct cloth-scene behavior under wind, pin-group, frame, and subdivision interventions.
Physical & Engineering Simulation
Infer robot state and trajectory behavior under actuator, collision, pose, joint-limit, and target interventions.
Life & Molecular Sciences
Reconstruct cell segmentation and measurement behavior across channel, illumination, threshold, object size, and measurement feature.
Earth & Space Sciences
Reconstruct FITS/WCS cutout and photometry behavior under aperture, background, clipping, threshold, and coordinate-frame interventions.
Data & Document Workflows
Reconstruct how DPI, font, language, metadata, and page range affect OCR behavior.
Spatial, Visual & 3D
Infer a color pipeline across color space, white point, tone curve, demosaicing, and compression quality.
Terminal & coding examples
Seeded from real recorded terminal sessions, then extended round by round. Every task ships with its environment, a reference solution, and a verifier that passed in a fresh sandbox. Each replay shows commands from the task's own reference solution.
Software engineering
Fix the assembly source at /app/horas_seg.s so it prompts for integer hours and correctly prints the equivalent seconds (e.g., 2 → 7200 segundos.).
Networking
Set up a Linux network namespace t1 with a veth pair.
Containers & cloud
Align the Dockerfile at /environment/Dockerfile with the files referenced by the kustomization in /app (kustomization.yaml), notably config.yaml.
Databases
Set up InfluxDB 2 using the configuration at /etc/influxdb/init.json.
Version control
Set up a DVC-tracked dataset under /app/dataset/ with two items: dataset/foo and dataset/test/0.
Data & scientific computing
Install the Flux Python package from the tarball at /app/flux-python-0.48.0rc6.tar.gz after verifying its integrity against the provided checksum file.
System administration
Assemble a three-line GRUB boot sequence (linux, initrd, boot) in /app/result.txt for the system rooted at /mnt/target.
Debugging & performance
In /app, diagnose and fix the environs URL parsing bug.
Security analytics
Working in /app, count each event_type in the dataset '/app/normalized-atomic-red-team.json.gz' using the EQL shell and save results to counts.json.
Share of terminal tasks by area, from system administration and databases to security and scientific computing.
Why verified synthesis
Hand-written environments are slow to produce. Prompted generation is fast, but a task can look perfect and be silently broken. We generate aggressively and then try to break every task, so only environments that survive the gates ship.
A task is accepted only if its reference solution passes in a fresh sandbox, a do-nothing agent fails, and every check is stated in the instruction.
Tasks grow harder round by round. Every task carries a measured tier, so you train on a curriculum instead of a pile.
New, never-published environments each cycle, synthesized for you and audited against public benchmark test sets before delivery.
Passing runs from many harnesses are rewritten into the single harness your model trains and runs under, so it learns the skill, not the scaffolding.
Capabilities
Each family pairs what the model sees with what it must produce and how we check it. Pick one, or combine them into a single training mix.
Multi-hour workflows where the agent explores a real environment, writes and runs programs, and checks its own work. Terminal tasks are coding tasks.
$ jq -c .axes_to_vary observations/manifest.json
["inlet_size","outlet_size","bend_angle","rib_count"]
$ ls /tmp/obs/public_1/native
metrics.json product.stl
$ jq -c .parameters /tmp/obs/public_1/scenario.json
{"bend_angle":238,"inlet_size":11.15,"rib_count":5}
$ python3 workspace/reconstruct.py < hidden.json
verifier ▸ hidden configurations vs. real OpenSCAD
✓ geometry matches on every hidden scenarioReal scientific and engineering software becomes the reference solution. The model sees how it behaves and must rebuild that behavior without its source.
Turn a dimensioned drawing or multi-view renders into parametric CAD code that builds the right solid.
From a design, a specification, or a legacy desktop app to a running web product with real persistence.
Charts, diagrams, vector graphics, and documents rebuilt as code that re-renders them, and keeps working when the data changes.
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.bar(q, revenue, color=c)
ax.plot(q, trend, marker="o")
ax.set_ylim(0, 120)
fig.savefig(out, dpi=200)Fix what users can see. Visual bug reports inside real repositories, resolved with patches that hold up in a browser.
@@ components/NavMenu.vue
- .menu { overflow: hidden; }
+ .menu { overflow: visible; }
+ .menu { z-index: 40; }How it works
Generation is the cheap part. The value is in the gates: a task reaches you only after it survives all of them.
Licensed or authored seed tasks and real software workflows. Never benchmark test sets.
Rewrite operators add tools, services, data, and failure modes. Solution, environment, verifier, and instruction change together.
Fresh-sandbox build. The reference must pass, a do-nothing agent must fail, and every verifier check must be stated in the instruction.
Measure pass rates with reference solvers or your checkpoint, and assign every task a difficulty tier.
Environments, verified trajectories, and a calibration and integrity report for every batch.
Trajectory scaling
Hard tasks get solved in different ways under different harnesses, and raw trajectories carry each harness's scaffolding with them. We pool successes across harnesses, then rewrite each one into the single harness your model trains and runs under, so it learns the skill, not the scaffolding.
Calibrated difficulty
Each synthesis round makes tasks measurably harder: longer solutions, more tools, more checks. In our runs, a fixed strong solver went from solving 90% of first-round tasks to 2.5% by round fifteen, with no ceiling in sight.
We measure your checkpoint on every tier and ship the band where it succeeds sometimes, but not yet reliably. As your model improves, the band moves up with it.
Watch one task grow
Successive stages from one task family: build a Git commit using only low-level plumbing commands. Each stage keeps the goal and adds requirements, and the reference solution and verifier grow with it. New requirements are highlighted.
Illustrative family: stages are related tasks from successive synthesis rounds, shown in order of depth.
Deliverables
Delivered in a reproducible, container-first format that drops into SFT and RL pipelines, with adapters for your stack on request.
Self-contained Docker environments with instruction, executable verifier, reference solution, and metadata, in Harbor task format.
Agent runs kept only when they pass the hidden checks, rewritten into one consistent harness, and exported as chat-format JSONL for fine-tuning.
Tier and measured pass rate for every task, against reference solvers or your own checkpoint.
Overlap audit against public benchmark test sets, shortcut controls, and sampled human review, plus the domains, tools, licenses, and known limitations of every batch.
task/
├── instruction.md # what the agent sees
├── task.toml # tier, tags, timeouts
├── environment/
│ └── Dockerfile # fresh, pinned sandbox
├── solution/
│ └── solve.sh # reference solution
└── tests/
└── test_state.py # executable verifier
trajectories.jsonl # verified agent runs
report.json # calibration + auditAlignment
We train skills, not test items. No benchmark test data is used, copied, or derived, and every batch ships with an overlap audit.
Research
Each method is measured across multiple seeds and against matched-budget baselines.
Scientific software
Existing scientific software becomes both the reference solution and the source of hidden test cases, so verification scales with the software rather than with authoring effort.
Task difficulty
Accepted tasks seed the next round. Each round extends the solution, verifier, and instruction together and re-validates the whole task in a fresh sandbox, with no human authoring in the loop.
Trajectory scaling
Successes discovered under diverse harnesses are rewritten by the same base model into one general harness, with leakage screening and fresh-sandbox re-execution.
Working together
A calibrated sample batch in your format, measured on your checkpoint, for the task families that matter most to you.
Fresh, never-published environments every month at the tiers you choose. Difficulty moves up as your model improves.
New domains, software stacks, and modalities built for your team alone, on your timeline.
We'll come back with a pilot plan: task families, difficulty tiers, delivery format, and a calibration run on your model.
The agent sees public runs of the real software and writes a program that reproduces it. That program is then run on hidden configurations of these parameters and must match the software's outputs, field by field.
Request the full samplesolve.sh