Iterative Document Generation Overview

• Iterative document generation is a draft–refine paradigm that produces documents through repeated cycles of planning, retrieval, drafting, and revision.
• It leverages structured intermediate states and evaluators to localize errors and apply targeted corrections across iterations.
• Recent systems like MED-VRAG, ViDoRAG, and AIR demonstrate improved retrieval accuracy, rendering quality, and compliance through iterative workflows.

Searching arXiv for recent and foundational papers relevant to iterative document generation and document-centric iterative generation workflows. Iterative document generation denotes a class of generation processes in which a document, document-derived artifact, or document-grounded output is produced through repeated cycles of planning, retrieval, drafting, evaluation, and revision rather than a single-pass decode. Across recent work, the term spans several technically distinct paradigms: iterative multimodal retrieval-augmented reasoning over document pages for question answering; iterative polishing of document representations for summarization; iterative constrained refinement for copy and instruction generation; human-agent workflows with inspectable intermediate specifications; and document automation pipelines in which validation and human feedback trigger targeted regeneration. In each case, the common structure is a stateful loop in which intermediate artifacts are exposed to evaluators or users, failures are localized, and subsequent iterations selectively update either the query, the internal document state, the output draft, or the workflow specification (Chen et al., 30 Apr 2026, Achachlouei et al., 2023).

1. Conceptual scope and definitions

Within document automation, document generation is defined as the automation of creating and integrating inputs from different sources and assembling documents according to pre-defined templates, with a document understood as the union of content and presentation (Achachlouei et al., 2023). Against that background, iterative document generation can be characterized as a draft–refine paradigm in which an initial output is repeatedly revised in response to validations, retrieved evidence, additional constraints, or human review until quality and structural criteria are satisfied. The survey on document automation explicitly contrasts this with one-shot template filling and emphasizes the enabling roles of human-in-the-loop review, validation against templates and ontologies, multi-source integration, and workflow traceability (Achachlouei et al., 2023).

Recent systems instantiate this iterative principle at different granularities. MED-VRAG performs iterative evidence retrieval and answer generation over multimodal page images, allowing up to 3 reasoning rounds in which a vision-LLM either emits an answer or a refined query plus notes (Chen et al., 30 Apr 2026). ViDoRAG uses a multi-agent exploration–inspection–verification loop in which a Seeker Agent, Inspector Agent, and Answer Agent iteratively refine candidate evidence over visually rich documents (Wang et al., 25 Feb 2025). AIR treats document-grounded complex instruction synthesis as an iterative process in which a guidance model identifies constraints missing from a current instruction and appends them over a fixed maximum number of iterations $n = 5$ (Liu et al., 25 Feb 2025). ViviDoc organizes the process as plan $\rightarrow$ spec $\rightarrow$ execute $\rightarrow$ evaluate $\rightarrow$ revise, with a human-editable intermediate representation called DocSpec (Tang et al., 2 Mar 2026).

A useful distinction is between document generation as output production and document generation as document-grounded reasoning. The former includes HTML/CSS document generation, interactive article synthesis, summarization, and copywriting (Lin et al., 26 Mar 2026, Tang et al., 2 Mar 2026, Chen et al., 2018, Vasudevan et al., 14 Apr 2025). The latter includes systems that iteratively generate answers, plans, or instructions from source documents while preserving provenance and evidence state (Chen et al., 30 Apr 2026, Wang et al., 25 Feb 2025, Liu et al., 25 Feb 2025). This suggests that “iterative document generation” now functions as an umbrella concept whose operational meaning depends on what is iteratively updated: retrieval queries, document representations, output drafts, workflow graphs, or layout code.

2. Core iterative mechanisms

A recurring pattern across the literature is the decomposition of generation into explicit state transitions. MED-VRAG formalizes the process with query state $q_t$, retrieved evidence $E_t$, memory state $M_t$, and a VLM reasoning function $F$, using

$A_t = F(q_t, E_t, M_{t-1}),$

where $\rightarrow$0 is either an answer or a tuple $\rightarrow$1, and memory is updated as

$\rightarrow$2

with refined queries generated by

$\rightarrow$3

when refinement is emitted (Chen et al., 30 Apr 2026). This formulation makes the iteration explicit: retrieval and reasoning are not separable one-shot modules, but alternating operators over a persistent state.

ViDoRAG uses an analogous but agentic decomposition. The Seeker Agent performs coarse exploration, the Inspector Agent performs high-resolution review and either drafts an answer or returns feedback, and the Answer Agent verifies the final answer against reference images. The update step is written as

$\rightarrow$4

with separate branches for Inspector reflection and answering (Wang et al., 25 Feb 2025). The practical significance is that token budget and perceptual fidelity are distributed asymmetrically across rounds: coarse reasoning prunes the search space, while expensive high-resolution inspection is reserved for promising evidence.

In iterative summarization, the same logic appears in representational form rather than retrieval form. ITS proposes that a model should read a document multiple times and “polish” the document representation on many passes rather than build a fixed representation in a single pass. The details block only supports the general mechanism—iterative polishing with a selective reading mechanism that decides the extent to which each sentence should be updated—because the exact architecture and equations from the original paper content were not available in the provided material (Chen et al., 2018). Even with that limitation, the central claim remains that multiple passes improve salience estimation and summary extraction by allowing sentence states to be updated in light of an evolving global document representation (Chen et al., 2018).

In constrained generation, iteration often consists of evaluator-driven repair. AIR first generates an initial instruction $\rightarrow$5 from a document $\rightarrow$6, refines the document to a reference-like representation $\rightarrow$7, and then iteratively constructs

$\rightarrow$8

where the new constraint $\rightarrow$9 is induced by comparing the current model response to $\rightarrow$0 (Liu et al., 25 Feb 2025). In marketing copy generation, a generator produces candidate copy, a sequence of evaluators returns pass/fail signals and structured feedback, and a refiner LLM edits only the failed aspects until all constraints pass or the iteration budget $\rightarrow$1 is exhausted (Vasudevan et al., 14 Apr 2025). Both systems exemplify an important design principle: iteration is most effective when failures are factored into modular, actionable constraints rather than treated as a monolithic quality score.

3. Retrieval-augmented iterative generation over documents

A major recent direction treats document generation as iterative retrieval-augmented reasoning over multimodal documents rather than over OCR text alone. MED-VRAG is the clearest example. It retrieves and reasons over PMC document page images instead of OCR’d text, motivated by the observation that medical pages encode critical information in tables, figures, and structured layouts, and that OCR and chunking linearize these structures and lose layout cues (Chen et al., 30 Apr 2026). Its Stage-1 retrieval uses ColQwen2.5 patch-level page embeddings, PCA-reduced to $\rightarrow$2, with approximately $\rightarrow$3M patch entries across approximately $\rightarrow$4K pages and about $\rightarrow$5 patches per page on average (Chen et al., 30 Apr 2026). The exact late-interaction score is

$\rightarrow$6

and Stage-1 returns $\rightarrow$7 pages in approximately $\rightarrow$8 ms using a coarse-to-fine index with $\rightarrow$9 centroids per page, ANN over centroids, and exact two-way scoring on a small shortlist (Chen et al., 30 Apr 2026).

Stage-2 then applies a sharded MapReduce LLM filter over offline summaries, reducing $\rightarrow$0 to $\rightarrow$1 pages. A VLM, Qwen2.5-VL-32B-Instruct, consumes the medical question and options, the top-10 page images, the top-20 summaries, and the memory bank. Per iteration, the full loop costs approximately $\rightarrow$2 s, with approximately $\rightarrow$3 s spent on VLM reasoning and approximately $\rightarrow$4 s on the Stage-2 filter; the full 3-round pipeline costs approximately $\rightarrow$5 s on $\rightarrow$6A100 (Chen et al., 30 Apr 2026). The system achieves $\rightarrow$7 average accuracy across MedQA, MedMCQA, PubMedQA, and MMLU-Med, and ablations attribute $\rightarrow$8 point to page-image versus text-chunk retrieval, $\rightarrow$9 points to iteration, and $\rightarrow$0 point to the memory bank (Chen et al., 30 Apr 2026).

ViDoRAG addresses a closely related problem for visually rich documents such as slide decks. Its retrieval stage uses a GMM-based adaptive recall procedure over similarity sets

$\rightarrow$1

with

$\rightarrow$2

and selects a dynamic top-$\rightarrow$3 by identifying the high-similarity component (Wang et al., 25 Feb 2025). Text and visual retrieval are run independently, and results are merged by union and then sorted by original document sequence rather than score-level fusion (Wang et al., 25 Feb 2025). On the ViDoSeek benchmark, ViDoRAG improves over VisualRAG by $\rightarrow$4 points for Llama3.2-Vision-90B and by $\rightarrow$5 points for GPT-4o, reaching $\rightarrow$6 accuracy with GPT-4o and improving over TextRAG by $\rightarrow$7 points (Wang et al., 25 Feb 2025).

These systems jointly establish a more general point: when iteration is coupled to page-level or image-level evidence, the retrieved object is not merely text but a visually organized document unit. This changes both the retrieval function and the semantics of memory. MED-VRAG’s memory bank explicitly stores key_findings with round labels such as "[Round k] ...", plus a reasoning_history of iteration–notes pairs (Chen et al., 30 Apr 2026). ViDoRAG similarly keeps a short summarized memory and retained images across rounds (Wang et al., 25 Feb 2025). In both cases, evidence accumulation is not just a larger context window; it is a structured trajectory over document artifacts.

4. Iterative refinement of drafts, constraints, and specifications

Another major family of methods uses iteration to improve an already generated draft or instruction set. AIR is explicitly framed as automatic iterative refinement of complex instructions grounded in documents. After density-based sampling and filtering of source documents, the Initial Instruction Generation stage produces $\rightarrow$8 and a refined document representation $\rightarrow$9; the Iterative Instruction Refinement stage then compares model outputs to $q_t$0 and accumulates constraints into $q_t$1 and $q_t$2 over a maximum of 5 iterations (Liu et al., 25 Feb 2025). The resulting AIR-10K dataset contains 10K complex instruction–response pairs, and finetuning with AIR-generated data improves instruction-following metrics relative to several baselines. For example, with Llama-3-8B + Ultrachat, AIR reaches CFBench CSR $q_t$3, ISR $q_t$4, PSR $q_t$5, FollowBench HSR $q_t$6, SSR $q_t$7, and AlpacaEval2 LC $q_t$8 compared with lower baseline values listed in the paper details (Liu et al., 25 Feb 2025). The important methodological point is that iteration is used not to rewrite a response directly, but to grow the instruction space in a document-grounded way.

LLM-driven constrained copy generation uses a more operational loop: generator, formatter, evaluator sequence, and refiner. For each context, evaluators check length, topics, keywords, lexical ordering, tone of voice, style, and coherence, returning $q_t$9 where $E_t$0 and $E_t$1 is structured feedback (Vasudevan et al., 14 Apr 2025). The refiner then edits the current copy using instructions distilled from that feedback. Success is measured as the fraction of outputs passing all evaluators. Iterative refinement increases the success rate by $E_t$2–$E_t$3 percentage points across the reported campaigns, and the winning copy in pilot multi-armed bandit studies improves click-through rate by $E_t$4–$E_t$5 (Vasudevan et al., 14 Apr 2025). This is a particularly clear instance of iterative document generation as constraint satisfaction under small iteration budgets.

Iterative text editing in data-to-text generation provides an earlier, lower-level variant. The system first transforms data items into text using trivial templates, then iteratively improves the text through a sentence-fusion editor, heuristic filtering, and GPT-2 reranking (Kasner et al., 2020). The procedure is deterministic in its coverage schedule: after initializing with a lexicalization of the first data item, each additional item is appended, fused, filtered for semantic completeness, and reranked. The language-model score is

$E_t$6

and if all edited candidates fail the semantic filter, the system falls back to plain concatenation to preserve correctness (Kasner et al., 2020). On WebNLG, in-domain fusion improves BLEU from $E_t$7 to $E_t$8 and CIDEr from $E_t$9 to $M_t$0 relative to the template-only baseline; on Cleaned E2E, BLEU improves from $M_t$1 to $M_t$2 and CIDEr from $M_t$3 to $M_t$4 (Kasner et al., 2020). The general lesson is that iteration can be organized around conservative local edits with hard validity checks rather than around unconstrained redrafting.

These approaches share a common architecture: generate a minimally valid initial artifact, externalize failures through evaluators or reference comparisons, and only then permit localized revision. This suggests that iterative generation is often best understood not as deeper sampling but as the coupling of generation to an external repair operator.

5. Human-in-the-loop and workflow-oriented iterative generation

A distinct strand of work emphasizes transparency, inspectability, and user control. “Doc To The Future” introduces “infomorphs,” defined verbatim as “modular, AI-augmented transformations that users can flexibly compose to guide document synthesis across diverse formats and modalities. Infomorphs provide discrete, composable units of information transformation, balancing user intent with AI-driven automation” (Kumaravel, 14 Dec 2025). The associated system, DocuCraft, represents workflows as a canvas-based DAG whose nodes perform Scatter, Gather, and Transduce operations. Sources, extractors, planners, viewers, and builders can be connected, reconfigured, and selectively recomputed; approved nodes remain frozen until explicitly unapproved (Kumaravel, 14 Dec 2025). Iteration here is not merely prompt refinement but workflow refinement with explicit intermediate artifacts, previews, and provenance.

The design space in DocuCraft organizes iterative generation along five dimensions: information scent, user agency, interaction granularity, infomorph type, and input/output modality (Kumaravel, 14 Dec 2025). Relevant Page Extractors operate as a two-stage pipeline with fast RAG followed by multimodal LLM verification; planners transform selected content into structured drafts; builders export approved drafts into .docx, .pptx, or .xlsx with formatting rules or templates (Kumaravel, 14 Dec 2025). The system’s example scenario demonstrates partial updates, branching, late-stage merging of new sources, and approval-based freezing of prior nodes, making iteration an explicit property of the computation graph rather than an opaque internal reasoning process (Kumaravel, 14 Dec 2025).

ViviDoc applies a similar philosophy to interactive educational documents. The central intermediate representation is DocSpec, in which each knowledge unit includes a unit summary, a text description, and an Interaction Specification decomposed into State, Render, Transition, and Constraint (SRTC) (Tang et al., 2 Mar 2026). The Planner outputs a schema-conforming DocSpec, educators can modify it before any code is emitted, the Executor generates text and visualization code in two stages with validation and retry, and the Evaluator checks coherence, HTML validity, and correctness against constraints (Tang et al., 2 Mar 2026). A concise formalization provided in the details is: given topic $M_t$5, Planner produces DocSpec $M_t$6, Executor synthesizes document $M_t$7, Evaluator computes violations $M_t$8, and the human refines $M_t$9 until $F$0 (Tang et al., 2 Mar 2026).

The empirical evaluation shows large gains over naive agentic generation. In blind expert evaluation, ViviDoc scores $F$1 versus $F$2 on Content Richness, $F$3 versus $F$4 on Interaction Quality, and $F$5 versus $F$6 on Visual Quality (Tang et al., 2 Mar 2026). In the user study, “Easy to learn” and “Easy to use” both receive $F$7, while “DocSpec editing is intuitive” and “Interface satisfying” receive $F$8 (Tang et al., 2 Mar 2026). The broader implication is that iterative document generation need not be an autonomous loop; it can instead be a controlled collaboration structured around typed intermediate specifications.

The document automation survey reinforces this point from a systems perspective. Its reference architecture includes templates and schemas, external data sources, document generation and assembly, content and document processing, conversion, analysis, storage/version control, and authentication, all of which support iterative cycles through validation, exception handling, and human approval (Achachlouei et al., 2023). This suggests that workflow-level iteration is not peripheral but foundational in enterprise document systems.

6. Structured representations, layout generation, and multimodality

Iterative document generation is increasingly tied to structured output representations rather than plain text. AnyDoc uses a unified HTML/CSS representation across intention-to-document, document derendering, and element-to-document tasks (Lin et al., 26 Mar 2026). The framework first constructs DocHTML, a synthetic dataset with 265,206 document samples spanning 111 categories and 32 styles, then finetunes Qwen2.5-VL-7B-Instruct and applies Height-Aware Reinforcement Learning (HARL) to mitigate overflow (Lin et al., 26 Mar 2026). HARL samples multiple code candidates, renders them with Playwright, measures realized height $F$9 relative to target height $A_t = F(q_t, E_t, M_{t-1}),$0, and assigns a reward based on the ratio $A_t = F(q_t, E_t, M_{t-1}),$1. The reward is given as

$A_t = F(q_t, E_t, M_{t-1}),$2

(Lin et al., 26 Mar 2026)

This is an iterative training-time generation loop rather than an inference-time editing loop, but it still fits the topic because the policy is progressively updated based on repeated rendering and constraint evaluation. HARL substantially improves layout metrics: on E2D, “HTML/CSS Full w/o HARL” has Height $A_t = F(q_t, E_t, M_{t-1}),$3 and Overlap $A_t = F(q_t, E_t, M_{t-1}),$4, while the full AnyDoc system reaches Height $A_t = F(q_t, E_t, M_{t-1}),$5 and Overlap $A_t = F(q_t, E_t, M_{t-1}),$6 (Lin et al., 26 Mar 2026). On I2D, AnyDoc achieves Height $A_t = F(q_t, E_t, M_{t-1}),$7, compared with $A_t = F(q_t, E_t, M_{t-1}),$8 for GPT-4o and $A_t = F(q_t, E_t, M_{t-1}),$9 for InternVL3-78B (Lin et al., 26 Mar 2026). A plausible implication is that iterative document generation in layout-rich settings is increasingly becoming render-in-the-loop optimization over structural code.

Graph-based layout generation offers a different notion of iteration. The invoice layout generator based on GraphRNN represents documents as visibility graphs, with nodes as layout entities and edges as spatial visibility relations, and generates adjacency vectors sequentially using a graph-level and edge-level GRU hierarchy (Biswas et al., 2021). The sequence factorization

$\rightarrow$00

formalizes an iterative construction process in which a partial graph is progressively expanded (Biswas et al., 2021). Although this is layout synthesis rather than document-grounded reasoning, it illustrates a broader use of the term: documents can be generated iteratively in structural spaces before content is rendered.

FlexDoc likewise treats synthetic document creation as an iterative, parameterized sampling pipeline over schema $\rightarrow$01, layout $\rightarrow$02, content $\rightarrow$03, rendering $\rightarrow$04, and annotations $\rightarrow$05, with periodic parameter refinement to satisfy diversity and coverage targets (Dua et al., 2 Oct 2025). Its factorization

$\rightarrow$06

and its explicit batchwise refinement of parameters distinguish iterative dataset generation from iterative inference-time editing (Dua et al., 2 Oct 2025). The framework reports up to $\rightarrow$07 absolute F1 improvement on KIE tasks and over $\rightarrow$08 reduction in annotation effort relative to hard-template methods (Dua et al., 2 Oct 2025). This suggests a broader ecosystem view in which iterative document generation includes the generation of training corpora that later support downstream document understanding and synthesis.

7. Empirical patterns, limitations, and open issues

Across the literature, several empirical regularities recur. First, iteration usually helps, but gains often plateau after a small number of rounds. MED-VRAG reports that $\rightarrow$09 of questions use more than one round, that Round-2 corrects approximately $\rightarrow$10 of initial errors on MedQA, and that Round-3 shows diminishing returns of approximately $\rightarrow$11 (Chen et al., 30 Apr 2026). AIR reports that performance improves through the first two or three iterations and then plateaus (Liu et al., 25 Feb 2025). Constrained copy generation deliberately keeps the refinement budget small, typically $\rightarrow$12–$\rightarrow$13, for scalability (Vasudevan et al., 14 Apr 2025). This convergence pattern suggests that the primary value of iteration lies in targeted correction of the most salient omissions or misretrievals rather than indefinite deliberation.

Second, memory and intermediate state matter. MED-VRAG isolates a $\rightarrow$14 point gain from its memory bank (Chen et al., 30 Apr 2026), while ViDoRAG emphasizes short summarized memory and retained images as a way to allocate reasoning tokens efficiently (Wang et al., 25 Feb 2025). ViviDoc and DocuCraft externalize state into inspectable artifacts—DocSpec and canvas nodes—so that humans can intervene before downstream errors compound (Tang et al., 2 Mar 2026, Kumaravel, 14 Dec 2025). This suggests that “iteration” is rarely beneficial without a stable state representation that persists across rounds.

Third, constraints and validators are not optional in high-stakes or structured settings. MED-VRAG explicitly notes medical safety risks: the system is not clinically validated, and hallucinations or misinterpretations of tables or diagrams can be harmful, motivating clinician-in-the-loop review, calibrated uncertainty, and conservative answer policies (Chen et al., 30 Apr 2026). The document automation survey similarly stresses XML DTDs, RDF/OWL ontologies, legal markup such as Akoma Ntoso, and compliance checks as central to reliable document generation in regulated domains (Achachlouei et al., 2023). AnyDoc relies on render-based height checking and data cleaning rules for overflow, missing src or alt, zero-height elements, and body-dimension mismatch (Lin et al., 26 Mar 2026). Copy generation uses explicit evaluator sequences and human/legal review before deployment (Vasudevan et al., 14 Apr 2025). A common misconception is that stronger base models can substitute for explicit validation; the surveyed work uniformly argues the opposite.

Fourth, multimodality changes the failure modes. MED-VRAG’s error taxonomy on MedQA attributes approximately $\rightarrow$15 of errors to retrieval miss, $\rightarrow$16 to filter miss, $\rightarrow$17 to VLM misinterpretation, and $\rightarrow$18 to iteration drift (Chen et al., 30 Apr 2026). ViDoRAG identifies an integration gap in purely visual retrieval and insufficiency of shallow reasoning tokens in prior systems (Wang et al., 25 Feb 2025). AnyDoc shows that layout compliance cannot be read off token log-probabilities alone; it must be measured in rendered space (Lin et al., 26 Mar 2026). This suggests that iterative generation over documents is increasingly an interaction between symbolic constraints, visual structures, and language-model reasoning rather than a purely textual revision process.

Finally, the meaning of “document generation” itself remains heterogeneous. In some papers, it refers to generating new documents or document-like artifacts such as HTML/CSS pages, interactive articles, or synthetic forms (Lin et al., 26 Mar 2026, Tang et al., 2 Mar 2026, Dua et al., 2 Oct 2025). In others, it refers to generating grounded answers, instructions, or summaries from source documents (Chen et al., 30 Apr 2026, Liu et al., 25 Feb 2025, Chen et al., 2018). A plausible implication is that future work will need a clearer taxonomy separating at least four cases: iterative document-grounded response generation, iterative document transformation, iterative document layout synthesis, and iterative document workflow orchestration.

From the current evidence, the strongest general design principles are consistent across these variants. Iteration is most effective when retrieval or planning is decomposed into typed stages, when intermediate state is explicit and auditable, when failures are localized by validators or judges, and when only affected components are regenerated. Whether the underlying object is a medical QA answer, a marketing banner, an interactive article, or an HTML/CSS document, the modern iterative paradigm replaces monolithic end-to-end generation with controlled state transitions over structured evidence and structured outputs (Chen et al., 30 Apr 2026, Kumaravel, 14 Dec 2025, Tang et al., 2 Mar 2026, Achachlouei et al., 2023).