Glonce

World-time compute lifts small LLM generalization by 29 points

researchThe Glonce editorsarXiv🔥71Glonce rating71Impact65Novelty68Relevance100Surprise48Players20Credibility85

Large language models generalize across a domain only after seeing many real, labeled examples. Most domains do not have enough of them. This paper's fix is to generate that data instead: when a domain's dynamics can be written as code, a single template can be instantiated into many different 'world models': executable, verifiable programs that track a symbolic state. Each world model becomes an inexhaustible source of exactly labeled trajectories, meaning full logs of how that world's state changes over many steps.

Fine-tuning a language model on trajectories drawn from many such generated worlds is what the paper calls world-time compute, framed as a training-time analogue of test-time compute: instead of spending extra compute at inference, the extra compute goes into training on synthetic but verified worlds. The payoff is generalization to held-out worlds the model never trained on, drawn from synthesized families of worlds it has not seen before.

The gains are largest exactly where capability is scarcest. A 0.5B-parameter model's generalization to those held-out worlds improves by 29 points after this kind of fine-tuning. The lift for the largest model tested falls within noise, a pattern the paper describes as consistent with saturation; the text does not disclose how large that largest model actually is.

The labels can be trusted because the worlds themselves are verified code rather than an approximate simulator: the dynamics are synthesized and then checked, so rollouts stay exact over 20-step sequences and answer probes that sit ten times out of distribution with 100% accuracy. When the per-step dynamics are instead predicted by a learned model, an LLM or an MLP, rather than executed as verified code, the errors compound across the rollout and the predictions collapse.

Unlike domain randomization, the paper notes, every world here is independently authored and separately verified. A corrupted-label control experiment, which keeps the same variety of tasks but breaks the correctness of the labels, performs far worse: evidence that it is the exactness of the labels, not the diversity of the worlds, that drives the improvement.

The same effect holds on three real benchmarks, ARC-AGI grids, List Functions and CLRS, when applied as per-world test-time training. List Functions also supports a harder, cross-world test: a single adapter trained across 128 disjoint worlds at once reaches 40% accuracy on worlds it never saw during training, versus 6% for a corrupted-label control run the same way, a 34-point gap (confidence interval 29 to 39 points). The paper does not report matching accuracy figures for ARC-AGI or CLRS, only that the same lever holds there.

The paper frames the effect as a saturating regularity, not a law. It is largest for tasks that need only a few reasoning steps and for small or weak models; it fades for long reasoning chains, for tasks driven mainly by perception, and for tasks a model has already nearly mastered. Cross-task transfer is weak unless the tasks share an underlying skill. The approach is also scoped to domains with symbolic state: pixel-native domains, where the state is an image rather than structured data, remain the territory of separately learned models.

The worlds are authored and served by a companion framework called OpenWorld, described as zero-dependency and detailed in a separate companion paper that this text does not identify further by author, title or link. The paper states that all of its code, training recipes and the manuscript itself regenerate from a single repository. The claim that this method manufactures labeled data cheaply is not backed by any cost or compute figures in the material available, and the text gives no author names, institutions or publication date.

Key facts

  • A new paper introduces world-time compute: fine-tuning an LLM on trajectories from many code-defined, verified 'world models' generated from one template, each an unlimited source of exactly labeled data.
  • Gains are largest for small models: a 0.5B-parameter model's generalization to held-out worlds improves by 29 points, while the largest model tested shows a lift within noise, consistent with saturation.
  • Verified-code world dynamics stay exact over 20-step rollouts and answer probes ten times out of distribution with 100% accuracy; per-step LLM and MLP predictors instead compound error and collapse.
  • On List Functions, an adapter trained across 128 disjoint worlds reaches 40% accuracy on held-out worlds versus 6% for a corrupted-label control run the same way, a 34-point gap (confidence interval 29 to 39 points).
  • The effect is scoped to symbolic-state domains, fades for long reasoning chains and perception-driven or already-mastered tasks, and the worlds themselves are generated by a separate zero-dependency framework called OpenWorld.

Why it matters

Most domains do not have enough real labeled examples for a language model to generalize across them. This paper's fix is to generate that data instead, wherever a domain's behavior can be written as code: one template becomes many independently authored and verified 'world models', each producing an unlimited stream of trajectories whose labels are exact by construction rather than approximate. Fine-tuning on those trajectories, what the paper calls world-time compute, is offered as a training-time counterpart to test-time compute: rather than spending extra compute reasoning at inference, the extra compute goes into training on synthetic but verifiably correct worlds instead.

Who it affects

The direct audience is researchers and engineers working on domains whose dynamics can be written as code, the kind of domain represented by the paper's own benchmarks: ARC-AGI grids, List Functions and CLRS. The benefit is concentrated at the small end: gains are largest, in the paper's own framing, 'where capability is scarcest', a 0.5B-parameter model improves by 29 points, while the largest model tested improves only within noise. By the paper's own scoping, the method also does not extend to pixel-native domains, where the state is an image rather than symbolic, and it fades for tasks that need long reasoning chains or are driven mainly by perception.

How to use it

The synthetic worlds themselves are authored and served by a companion framework called OpenWorld, described as zero-dependency and documented in a separate companion paper that this text does not identify further by author, title or link. The paper states that all of its code, training recipes and the manuscript itself regenerate from a single repository. Applying the method starts with writing a domain's dynamics as code, so a template can generate many independently verified worlds from it; only domains that fit that mold, symbolic state rather than raw pixels, are in scope. The claim that this manufactures labeled data cheaply is not backed, in the material available here, by any cost or compute figures.

How solid is it

The central result rests on more than a single number: a corrupted-label control isolates label exactness, rather than task variety, as the actual driver, and the List Functions cross-world test reports a 34-point gap with a confidence interval (29 to 39 points), not just a point estimate. The same underlying lever also holds across three separate benchmarks, ARC-AGI grids, List Functions and CLRS, when applied as per-world test-time training. Some of that strength cannot be checked from the material available here: ARC-AGI and CLRS get no accuracy numbers of their own, only List Functions does; the size of the largest model tested, whose near-zero lift anchors the saturation claim, is not stated; and the text carries no author names, institutions or publication date to weigh the work's provenance.

Risks and caveats

The paper is explicit that the gain is a saturating regularity, not a law: it is largest for tasks that need only a few reasoning steps and for small or weak models, and it fades for long reasoning chains, for tasks driven mainly by perception, and for tasks a model has already nearly mastered. Cross-task transfer is weak unless the tasks share an underlying skill, so a gain on one domain should not be assumed to carry over to another. The method is scoped to domains with symbolic state; pixel-native domains stay outside it. And the framing of this as a cheap way to manufacture labeled data is not backed, in the material available, by any cost or compute figures.