This is not a coincidence. Three papers landed on arXiv within 12 hours of each other last week, from completely unrelated teams, attacking exactly the same problem.

Every autoregressive generative model for video, motion, or control decays exponentially after ~10 steps. Everyone knew this. No one had a clean fix. Now they do.

The broken contract at the heart of autoregressive generation

This flaw is older than transformers. It has a name: exposure bias.

When you train any autoregressive model, you always condition every prediction on ground truth history. The model never sees bad input. It never sees its own mistakes. It never has to recover from drift.

When you run that same model at inference, you condition every prediction on outputs the model itself generated. These are not drawn from the same distribution. The model is operating in a state it was never shown during training.

Every single error propagates. Every small drift amplifies. After enough steps the model enters a distribution it has zero training data for, and output turns to garbage.

For twelve years every proposed fix broke inference speed, required changing the sampler, or only reduced the problem rather than eliminating it. All three new papers take the exact opposite approach.

OPSD-V: Self distillation that runs exactly like inference

OPSD-V is the cleanest engineering solution anyone has produced in this space. It does not retrain the base model. It does not change the sampler. It does not add a single operation at inference time.

The trick is almost offensively simple. During post-training distillation you run the student model exactly as it will run at inference. It generates every chunk using its own KV cache, its own mistakes, its own drift, everything. No ground truth history is ever shown to the student.

In parallel you run the teacher model at exactly the same denoising timestep, at exactly the same noise level. Then you silently swap out the oldest entries in the teacher's cache for real ground truth video. You do not tell the student this happened. You just give it the teacher output as the training target.

That is the entire method. The student learns to correct for drift, because during training it is always shown what it should have output, given exactly the bad state it just put itself into.

OPSD-V benchmark results

This is not an incremental improvement. This is a larger jump in long video quality than the entire gap between Sora 1.0 and Sora 1.5.

Blind user preference results were unambiguous. Across 20 matched video pairs, OPSD-V was preferred in 66% of all judgments. When ties were excluded this rose to 82.5%. No participant preferred the base model once drift became visible.

ARDY: Hybrid representation for motion that doesn't drift

ARDY solves exactly the same failure mode for 3D human motion. Until this paper the field had an enforced tradeoff: you could have good motion that ran at 0.8fps, or fast motion that fell apart after 2 seconds. There was no middle ground.

ARDY breaks this tradeoff with two changes. First they split the motion representation. Root position and orientation are stored explicitly as raw unquantized floats. All joint pose information lives in a compressed latent embedding. This single change eliminated 70% of observed drift, as the model can no longer slowly forget where the human is standing.

Second they train the autoregressive denoiser with variable history length. During training they randomly drop, corrupt, or replace old history entries. The model is explicitly trained to recover from bad state. Exactly the state it will encounter at inference time.

ARDY capability matrix

This is the first motion generation model that checks every required box for interactive use.

Capability	Offline diffusion baseline	Online autoregressive baseline	ARDY
Per frame inference latency	1210ms	14ms	11ms
Text prompt adherence	92%	47%	88%
Keyframe constraint accuracy	94%	31%	91%
Maximum stable rollout length	120 frames	32 frames	>1024 frames
Realtime interactive steering	No	Yes	Yes

It runs at over 90fps. It follows natural language. It hits arbitrary keyframes. You can steer the walking character with a mouse while it runs. It will run indefinitely without drifting off the ground or turning into a tangle of limbs.

Latent Memory Palace: This works for control policies too

This is the paper that will not get the attention it deserves. The exact same failure mode, the exact same class of fix, works for continuous robot control policies.

LMP does not use chain of thought. It does not reason in language tokens. It builds an autoregressive latent memory. At inference time it can choose to spend extra steps just updating its internal memory before outputting an action. It will do this automatically when the task is hard. It will skip it when the task is easy.

This behaviour was not programmed. It emerged during training.

Most importantly: error accumulates linearly. Not exponentially. A policy that had a 90% success rate over 10 steps now has a 78% success rate over 100 steps. Before this work that number would have been 2%.

The common thread no one mentioned

All three teams arrived at exactly the same conclusion independently. None of them communicated. None cited each other.

None increased model size. None added parameters. None changed the sampler. All of them just stopped lying to the model during training.

For ten years everyone was trying to build better samplers to compensate for the fact that the model had never seen its own output. No one just showed the model its own output during training.

What this changes

We no longer have a hard limit on video length. Before this week every autoregressive video model would reliably fall apart between 8 and 16 chunks. You could make 1 minute videos. You could not make 10 minute videos. Now you can. There is no known upper bound anymore.

For humanoid robots this is the enabling technology. Until now every policy would drift after 10-20 actions. You could not run an open loop policy for more than a few seconds. Now you can.

This is not something you will see in viral demo tweets next week. It will be buried inside every production model released 6 months from now.

Limitations and open questions

This is not perfect. OPSD-V still drifts, just much slower. ARDY still fails on extremely unusual motion sequences. LMP has only been tested on simulation and simple real world manipulation tasks.

No one has yet tested if this same approach works for audio. No one has tested it for long form text. There is every reason to believe it will.

The most important open question is not technical. Why did this take 12 years? The core idea is obvious once someone says it. Every single person working in this field had all the pieces required to build this in 2014. Everyone had just learned to accept exponential drift as an unavoidable law of nature.

Closing observation

This is how progress actually happens. Not with giant models, not with 100 million dollar training runs. Three separate teams all noticed the same obvious flaw that everyone had learned to ignore, all built the fix within a few months of each other, and all dropped their papers on the same day.

You will not see press releases about this. You will not see CEOs post about it. But this is the shift that will make 1 hour generated videos, real time humanoid animation, and general purpose robot control work.