Latent-World-First Task Synthesis
Long-horizon agent tasks can drift when prompts, files, and graders are built separately; TEV constructs one hidden correct world first and derives the workflow, corrupted inputs, public contract, verifier, and progress checks from it.
Read the paper ↗What it is
- Latent world A complete hidden correct state of the task domain, generated first and used as the source of truth for the rest of the environment.
- Workflow graph A map of task stages and their dependencies, showing what can happen in parallel and what must come first.
- Controlled corruption Declared reversible defects added to rendered inputs so the agent must repair a messy workspace whose correct answer is still recoverable.
Why it matters
Building the files, instructions, and grader from one shared world prevents them from disagreeing about the task. The result can be difficult and multi-stage while remaining verifiable from the agent’s inputs.
Before getting into the machinery, here’s the idea in plain language: make a complete correct version of the world first, then turn it into the messy task the agent sees. The workflow, files, instructions, and grader all come from that same source, so the task can be complicated without making the right answer unknowable.
- Consistency: If you write a prompt, generate files, and build a verifier separately, each piece can be plausible while they disagree about what “correct” means. Starting from one world keeps them aligned.
- Long-horizon structure: A difficult task is not just a lot of files. Some work depends on other work, so the task needs an explicit shape that captures prerequisites and possible parallel steps.
- Recoverable difficulty: You want the agent to repair real defects, not guess at facts that were never present. Declared corruption makes the inputs messy while keeping the intended solution recoverable.
The canonical example is a retail warehouse recovery task. Start with a correct warehouse world: customers, products, and transactions. Render that world into input files, deliberately introduce defects such as duplicates or schema drift, and ask the agent to build a clean database and truthful sidecar files. That concrete example generalizes: the hidden world might instead describe tensor shards and machine topology, but the same design question applies—can the agent recover a known-correct result from the workspace it receives?
How do you represent the work so “do the task” is more than a vague instruction? I think of it as a project plan with real prerequisites, not a checklist you can satisfy in any order. Profiling source files can feed several preparation steps; loading facts depends on the right preparation; validation and packaging come later. The paper represents these stages as a directed acyclic graph, or DAG: a map where dependencies point forward and cycles are absent. Its longest dependent chain determines the horizon. That is more informative than counting steps, because two independent steps may happen alongside each other. What should happen when the clean files become the agent’s messy inputs?
The key intuition is to treat defects like edits you know how to undo. In the warehouse example, the generator can add duplicates or drift a category label; those defects are specified rather than improvised. The clean files must first round-trip back to the original world, and the declared corruption must preserve enough information to recover it. In other words, the agent sees a distorted notebook, not a mystery novel with missing pages. The analogy has a limit: real formats and joins impose exact constraints that a notebook metaphor cannot capture. Why does reversibility matter so much? Because otherwise a correct solution might depend on facts the agent never received.
Once that workspace exists, the public task contract can say which outputs and schemas are required, what requirements depend on others, and which sources take precedence if they conflict. The strict verifier checks the submitted result against the same hidden world that generated the files. A sealed suite can also test whether harmless rewrites still pass and whether plausible stale outputs fail. For intermediate work, the environment can check progress against known-correct workflow states; the details of turning that into a training reward belong to the separate progress-reward module. What keeps the prompt, final grader, and intermediate checks from quietly drifting apart? They all anchor back to the same world, while the qualification design keeps the scorer, verifier, and reference solvers independent.
The tradeoff is clear: you get a task that is difficult yet exactly checkable, but you have to engineer and validate the generator, graph, rendering, corruption, and graders. I find that a worthwhile exchange for long tasks: complexity is useful only when the environment still knows what counts as correct.
Read the deep dive
Why People Wanted It
A long-horizon agent task is not just a prompt with a difficult answer. The agent must repair a workspace over many dependent steps, and the task only makes sense if the files, requested outputs, and grader all agree about what the correct world is. Generate those pieces independently and they can each look plausible while quietly describing different tasks. That is artifact drift.
So the real question was never just how to make a task longer. It was: can you construct a messy but solvable environment whose ground truth is known exactly, whose dependencies define the work, and whose grader checks the same reality the agent was given?
The Core Move
Construct a complete latent world first, then derive the workflow, rendered and corrupted inputs, public task, verifier, and progress checks from that shared ground truth. The paper gives this as a pipeline, not a single formula: no synthesis equation is specified here.
Why the Workflow Is a Graph, Not a Checklist
Now the version for readers who want more of the machinery: the workflow graph is built from the scale of the world and records dependencies, permitted parallelism, and estimated semantic work. A stage can proceed only when its dependency conditions are met; independent stages may run in parallel. The graph’s critical path—the longest chain of dependent stages—sets the task horizon, while its stages provide the structure for intermediate progress checks.
This matters because a flat checklist loses which work blocks other work. In the warehouse example, profiling sources can precede reconciling facts or normalizing dimensions; loading facts depends on the needed preparation; aggregation and sidecar packaging come later. The graph encodes this structure rather than asking the grader to infer it from a prompt.
Why Corruption Must Be Reversible
Here is the part that gets technical: the clean artifacts are rendered as a projection of the latent world, and the rendering is checked by round-tripping the files back to that world. A seed-derived defect plan then applies declared, invertible corruptions to those artifacts. The agent receives the corrupted workspace, not the untouched world.
Because rendering round-trips and the corruptions are declared and invertible, the received workspace determines the world. That is the crucial constraint: the correct answer must be computable from what the agent actually sees, without a separate solver inventing hidden facts. Corruption can create schema drift, duplicates, missing records, or category drift, but it must not make the task underdetermined. What can the agent be asked to do if the public contract itself is incomplete?
Why the Contract and Graders Share One Anchor
Now one level deeper: the task prompt, initial workspace, strict verifier, and progress potential are all functions of the same latent world. The public contract specifies input roles, required output artifacts and schemas, ordered requirements, authority-precedence rules, and permitted tools. Separately, a sealed verification suite includes semantics-preserving rewrites that should retain the grade and plausible stale outputs that should fail.
The strict verifier checks submitted outputs against the world; it does not merely reward resemblance to one reference file. The progress contract also tracks whether intermediate work matches the known-correct workflow states. These roles need independent implementations: qualification requires disjoint code closures for the progress scorer, strict verifier, and reference solvers. That separation limits the chance that one shared bug makes both a solution and its grader appear correct. How do you keep a detailed progress signal from becoming a shortcut the agent can game?
Minimal Causal Code
This plain loop makes the shared-world dependency visible; it is a conceptual sketch, not TEV’s implementation.
world = generate_world(seed, tier)
validate_world(world)
defect_plan = draw_defects(seed, world)
clean_files = render(world)
assert round_trip(clean_files) == world
agent_files = apply_invertible_defects(clean_files, defect_plan)
workflow = build_workflow(world)
prompt = make_public_contract(world, workflow)
verifier = make_verifier(world)
progress_contract = make_progress_checks(world, workflow)
# At submission, grade the agent's outputs against the same world.
result = verifier(agent_outputs, world)
What You Gain, and What You Lose
You gain exact ground truth by construction: one world anchors the prompt, artifacts, corruption plan, verifier, and intermediate checks. A workflow graph makes dependency depth explicit, while scale tiers and defect classes provide controls over task size and dependency depth. Reversible corruption means the agent can recover the answer from its inputs rather than guess at hidden state.
The tradeoff is that this is generator engineering, not free task variety. Each environment needs validated world invariants, a correct rendering round-trip, declared defects, a coherent workflow, and independent grading roles. The graph and checks must also be designed so that partial work is meaningful without weakening the strict final verifier. The approach buys consistency and controllability by requiring structure up front.
Build the world once; make every task artifact and every grader answer to that same reality.