Reviser: Teaching Text Generation Models to Revise Drafts Like Humans

From "One-Shot" to "Revisable" Text Generation

Today's mainstream large language models generate tokens one by one in an autoregressive manner — essentially writing from left to right in a single pass, with no ability to go back and revise previously generated content. This stands in stark contrast to how humans actually write: we typically draft something first, then insert additions, adjust phrasing, and cut redundancies. Enabling models to perform revision-capable generation has long been a research interest, since it allows inserting or revising content within earlier portions of the output for a more flexible generation process.

However, prior approaches to achieving this flexibility mostly came from non-autoregressive models or edit-based methods, which typically require repeated computation over the entire sequence — making inference expensive. A new paper on arXiv, "Reviser: Revision-Capable Text Generation via Autoregressive Cursor Actions", proposes a much lighter-weight alternative.

The "write-once" nature of autoregressive language models stems from how they factorize probability: decomposing the joint probability P(x₁, x₂, …, xₙ) into a product of step-by-step conditionals, where each token can only attend to what has already been generated on its left. In contrast, Non-Autoregressive Models (NAR) and discrete diffusion models allow simultaneous or multi-round modifications to the entire sequence. Discrete diffusion models (e.g., MDLM, SEDD) borrow ideas from image diffusion and define a noise-then-denoise process over discrete token spaces, progressively recovering the full sequence through multiple forward passes. Masked language models (BERT variants) achieve iterative refinement by filling in [MASK] positions across multiple rounds. The shared problem with these approaches is that inference requires repeated computation over the full sequence — costs that escalate sharply as sequences grow longer. Reviser was proposed precisely as a lightweight alternative in this context.

Reviser's Core Design: Cursor Action Sequences

Reviser is a decoder-only Transformer that reframes the process of generating a response as executing a series of relative cursor actions on a mutable canvas.

Three Action Primitives

At each step, Reviser predicts a single action token — one of the following three:

• INSERT(token): Insert a token at the current cursor position
• MOVE(Δ): Move the cursor relatively by Δ positions
• STOP: End generation

The key insight is that the model is autoregressive over the edit history of actions, not over the sequential order of the final text. This means Reviser can insert content anywhere in the canvas, move the cursor backward to revise earlier portions, and achieve truly non-monotonic generation — all while retaining a simple "predict the next action" interface.

This design elegantly combines revision capability with autoregressive simplicity: it requires neither the multi-pass iteration over the full sequence that diffusion models need, nor does it remain constrained by strict left-to-right ordering.

Reviser's training data requires converting ordinary text into action trajectories. One natural approach is to reverse-engineer cursor action sequences by comparing different draft versions of text (e.g., edit histories, diff sequences); another is to synthetically generate trajectories with insert and move operations. This is closely related to the concept of "incremental diffs" in code completion and collaborative editing — git diffs and document revision histories are natural real-world sources of such action sequences. Notably, the Δ in MOVE(Δ) can be negative, representing a leftward cursor retreat — the key mechanism that enables "going back to revise." Action sequences are typically longer than the final output text, since they include many move and intermediate edit steps, which is why the model must additionally learn to schedule operations efficiently.

Experimental Results: More Preferred and More Compute-Efficient

The paper validates Reviser's performance across multiple dimensions.

Generation Quality Comparison

In arena-style evaluations on continuation benchmarks, Reviser significantly outperforms SEDD and MDLM — two representative discrete diffusion / masked language model baselines — with human or automatic evaluators consistently preferring Reviser's outputs.

Even more telling are the trajectory statistics, which confirm that the model genuinely performs frequent backward moves and mid-canvas insertions rather than merely simulating traditional append-only decoding. In other words, Reviser doesn't just superficially support revision while quietly degenerating into ordinary left-to-right generation — it truly learns to go back and revise.

Scale and Compute Performance

Against autoregressive baselines of comparable parameter counts, Reviser remains competitive at both the 100M and 300M scales. This demonstrates that introducing editing capability does not come at the cost of sacrificing baseline generation quality.

On the inference compute side, the paper uses a unified FLOPs convention for comparison, showing that Reviser requires significantly less inference computation than multi-pass refinement methods and diffusion-based baselines. This point is particularly important — the value of revision capability is often offset by high inference costs, and Reviser aims to find a more favorable tradeoff between the two.

The "unified FLOPs convention" mentioned in the paper is a critical detail for cross-paradigm compute comparisons. The inference cost structures of different generation paradigms vary substantially: autoregressive models perform one forward pass per generated token, with total FLOPs scaling linearly with sequence length; diffusion models require a fixed number of forward passes (e.g., T=100 or T=1000 steps), each over the entire sequence, making total cost a function of steps × sequence length; multi-pass refinement methods (chain-of-thought refinement or self-refinement) are equivalent to calling the full model multiple times. Although Reviser's action sequences are longer than the final text, each step still involves a single token-level forward pass, avoiding repeated computation over the full sequence — resulting in lower total FLOPs for equivalent output quality. This comparison assumes equal FLOPs budgets rather than simply comparing parameter counts or generation speed.

Significance and Reflections

Reviser's approach represents a fundamental rethinking of the generation paradigm. While the current "one-shot" mode of LLMs is highly efficient, it is inherently limited for tasks requiring complex planning, structural adjustment, or after-the-fact correction. Having a model manipulate a mutable canvas through action sequences is, in some sense, closer to how humans cognitively approach writing and editing.

From an engineering standpoint, this cursor action-based framework preserves the mature training and inference infrastructure of autoregressive models while avoiding the complexity of non-autoregressive methods — lowering the barrier to practical deployment. Of course, the paper currently validates at the hundred-million parameter scale; whether this approach can scale to the size of mainstream large models, and whether it remains effective on more complex reasoning and long-text tasks, remains to be seen.

For researchers and engineers following the frontiers of text generation, Reviser offers a thought-provoking direction: revision capability doesn't have to come at the cost of abandoning the simplicity and efficiency of autoregressive generation.