Free Drafter: Automation & Inference

• Free Drafter is a design objective aimed at reducing the cost and specialization burden in drafting, applicable to both document engineering and inference tasks.
• It automates the creation and revision of formal artifacts—such as legal definitions, technical diagrams, and civil-engineering drawings—thereby saving manual effort.
• In inference, Free Drafter methods use training-free verification and cache reuse to reduce runtime costs while maintaining target model accuracy.

Free Drafter is not a single standardized architecture. The literature suggests at least two major usages of the term. In document engineering and task automation, it denotes systems that draft or revise formal artifacts such as legislative Definitions articles, draw.io diagrams, or civil-engineering drawings. In inference research, especially speculative decoding and speculative diffusion, it denotes a drafter whose training burden, model-specificity, or marginal runtime cost is reduced through training-free verification, self-speculation, vocabulary bridging, parameter-efficient integration, or cache reuse, while the target model still governs the final output distribution or correction step (Chouhan et al., 2024, Li et al., 28 Nov 2025, Timor et al., 31 Jan 2025, Soen et al., 11 Jun 2026).

1. Terminological scope and recurring meanings

The literature suggests that “free” rarely means the complete absence of a drafter. In most inference papers, it instead means one of three narrower properties: no additional training, no separate auxiliary model, or negligible marginal drafting overhead. FLy is “training-free” because it composes with arbitrary draft-target pairs and makes acceptance decisions from the target model’s runtime outputs rather than from a learned verifier (Li et al., 28 Nov 2025). FlexDraft is “near-free” in a different sense: it removes the need for a standalone drafter by tuning only mask-specific attention projectors in the final few target layers, adding trainable parameters equivalent to only about 6% of the target model size (Zhang et al., 19 May 2026). The diffusion “Free Drafter” is “free” because it reuses target-model outputs already computed during the previous round’s parallel verification pass, so the marginal cost of drafting becomes negligible compared to a full target-model evaluation (Soen et al., 11 Jun 2026). OmniDraft pushes a complementary “one drafter for all” paradigm, where a single small drafter is reused across different target families and adapted online (Ramakrishnan et al., 3 Jul 2025).

A second recurrent meaning appears outside inference acceleration. LexDrafter is a specialized assistant for drafting Definitions articles in EU legal acts, not a general free-form legislative drafter (Chouhan et al., 2024). GenAI-DrawIO-Creator generates editable draw.io XML from natural language, code, or images, making “drafting” mean generation of a source representation rather than acceleration of another model (Yu et al., 8 Jan 2026). DrafterBench uses “drafter” in the occupational sense: an agent that revises civil-engineering drawings through tool calls (Li et al., 15 Jul 2025). The common thread is reduction of human or model-side drafting cost, but the technical mechanisms differ substantially.

2. Drafting and revision systems for formal artifacts

LexDrafter is a narrow but concrete example of drafting assistance in law. It assumes a corpus $D=\{d_1,\ldots,d_n\}$ of legal documents, models each document as a sequence of sections, and extracts reusable “definition elements” $f_i=\langle id_i, t_i, e_i, r_i\rangle$, where $t_i$ is the defined term, $e_i$ the explanation, and $r_i$ a list of references to other definition elements (Chouhan et al., 2024). The system is explicitly limited to Definitions articles: the substantive parts of a legislative draft are assumed to exist already, the user manually selects candidate terms, and LexDrafter either retrieves an existing definition or generates a new one by lexical retrieval over drafted sections plus LLM prompting. In the energy-domain corpus, the authors crawled 551 legal acts from 1949–2023, processed 539 HTML acts, identified 108 acts with a Definitions article, and extracted 1330 definition fragments corresponding to 1007 legal terms. The evaluation compares generated definitions to human-written ones using BLEU, BERTScore, and BLEURT; Vicuna slightly outperforms LLaMA-2, while the paper stresses that semantic similarity does not guarantee legal adequacy (Chouhan et al., 2024).

FormaLex represents a different tradition of legal drafting assistance. It is an LTL-based language and companion tool set for finding normative incoherences in regulations, contracts, and other legal documents through model checking rather than natural-language generation (Gorín et al., 2011). The system supports obligations, prohibitions, permissions, contrary-to-duty structures, intervals, counters, and background automata, and is best understood as a formal verification assistant for drafting rather than a text-generating drafter. Its significance for the broader Free Drafter idea lies in its insistence that drafting support can be analytical and constraint-oriented, not only generative (Gorín et al., 2011).

GenAI-DrawIO-Creator moves drafting into structured visual authoring. It uses Claude 3.7 via Amazon Bedrock to generate draw.io-compatible XML, validates the XML, repairs malformed outputs, and renders them in an embedded draw.io editor (Yu et al., 8 Jan 2026). The prototype supports infrastructure diagrams, flowcharts, org charts, UI wireframes, and image-based reconstruction of simple diagrams. In simulated evaluations over 10 benchmark tasks, first-pass semantic coverage averaged 94% of required components and relations, structural validity was 9/10 on the first try, layout clarity averaged 4.34/5 from five human evaluators, and average generation time was 7.4 seconds (Yu et al., 8 Jan 2026). The paper’s central design choice is that the output remains editable XML rather than a flat image.

DrafterBench does not itself implement a drafter, but it defines a benchmark for one-turn technical drawing revision in civil engineering (Li et al., 15 Jul 2025). It contains 12 task types, 46 customized functions/tools, and 1920 tasks, covering text, table, and vector-entity revisions under adding, content modification, mapping, and format updating. The benchmark emphasizes code-based tool calling, dual tools that record operation paths instead of directly editing files, and evaluation by executability plus target completeness rather than by rendered output alone. That design reflects a drafting reality in which a visually plausible result can still be procedurally wrong (Li et al., 15 Jul 2025).

3. Training-free and drafter-invariant speculative decoding

FLy, or “Training-Free Loosely Speculative Decoding,” does not introduce a new drafter architecture. Its contribution is a semantics-aware acceptance rule that loosens exact-match verification without additional training (Li et al., 28 Nov 2025). The method adds a two-tier mechanism: an entropy-level gate

$$\textsf{Gate}(j)= \begin{cases} \textsf{Strict}, & h_j<\theta\ \textsf{Defer}, & h_j\ge\theta \end{cases}$$

and a token-level deferred window that accepts a mismatch only if it passes the entropy gate and yields no further mismatches in the next $W$ positions. Because FLy reads only target-model logits, entropy, and short-horizon continuation behavior, it is drafter-agnostic and training-free. Experiments report more than 99% recovery of target accuracy with average speedups of $2.81\times$ on Llama-3.1-70B-Instruct and $5.07\times$ on the 405B variant, with particularly strong out-of-domain robustness relative to training-based methods (Li et al., 28 Nov 2025).

A more radical notion of drafter freedom appears in “Coupling without Communication and Drafter-Invariant Speculative Decoding” (Daliri et al., 2024). That paper asks whether speculative decoding can be made invariant to drafter choice under a fixed random seed. The answer uses communication-free coupling based on shared randomness. For target and drafter distributions $\mathcal P$ and $f_i=\langle id_i, t_i, e_i, r_i\rangle$0, the paper proves the agreement guarantee

$f_i=\langle id_i, t_i, e_i, r_i\rangle$1

and shows this worst-case bound is optimal for communication-free protocols (Daliri et al., 2024). In speculative decoding terms, the target model’s sampled output becomes fixed by the target distribution and the random seed, not by the chosen drafter. This does not make drafter quality irrelevant for speed, but it makes the realized target sequence invariant under drafter swaps.

4. Near-free drafter architectures for LLM inference

Several papers pursue a near-free drafter by shrinking drafting overhead rather than eliminating the drafter. ParallelSpec replaces autoregressive drafting with a parallel drafter that predicts multiple future tokens in one forward pass using mask tokens, achieving latency improvements up to 62% over baseline methods and $f_i=\langle id_i, t_i, e_i, r_i\rangle$2 overall speedup on Llama-2-13B (Xiao et al., 2024). Cascade Speculative Drafting goes further through a vertical cascade, which pushes autoregressive work down to cheaper models and ultimately to a statistical model, and a horizontal cascade, which allocates stronger draft models only to early, high-value positions. The paper reports up to an 81 percent additional speedup over speculative decoding while maintaining the same output distribution as the target model (Chen et al., 2023).

SpecBlock and DDTree both target the drafter bottleneck more structurally. SpecBlock introduces block-iterative drafting, where each drafter forward predicts a block of dependent positions and repeated block expansions form a tree. Its within-block layer-wise shift and cross-block hidden-state inheritance preserve path dependence while reducing drafting cost to 44–52% of EAGLE-3’s, improving mean speedup by 8–13% over EAGLE-3 and by 11–19% with cost-aware adaptation (Shi et al., 8 May 2026). DDTree starts from a one-pass block diffusion drafter and argues that its per-position marginals should be converted into a draft tree rather than wasted on a single trajectory. Under a fixed node budget $f_i=\langle id_i, t_i, e_i, r_i\rangle$3, it optimizes

$f_i=\langle id_i, t_i, e_i, r_i\rangle$4

with $f_i=\langle id_i, t_i, e_i, r_i\rangle$5, and uses a best-first heap algorithm to recover the top-$f_i=\langle id_i, t_i, e_i, r_i\rangle$6 prefixes (Ringel et al., 14 Apr 2026). Empirically DDTree improves all 60 benchmark settings reported in the paper.

VocabTrim addresses an even narrower bottleneck: the drafter LM head (Goel et al., 28 Jun 2025). It reconstructs the drafter’s language-model head to include only the $f_i=\langle id_i, t_i, e_i, r_i\rangle$7 most frequent tokens under calibration counts $f_i=\langle id_i, t_i, e_i, r_i\rangle$8,

$f_i=\langle id_i, t_i, e_i, r_i\rangle$9

which reduces memory-bound overhead at the cost of a slight acceptance-rate drop. For Llama-3.2-3B-Instruct on Spec-Bench, the paper reports a 16% improvement in memory-bound speed-up (Goel et al., 28 Jun 2025). This is “free drafter” in the narrow sense of turning a full-vocabulary drafter into a specialized low-overhead token suggester.

5. Cross-vocabulary, adaptive, and integrated drafters

A major obstacle to reusable drafters is vocabulary mismatch. “Accelerating LLM Inference with Lossless Speculative Decoding Algorithms for Heterogeneous Vocabularies” removes the shared-vocabulary requirement through three exact methods: String-Level Exact Match, Token-Level Intersection, and String-Level Rejection Sampling (Timor et al., 31 Jan 2025). The most distinctive construct is the string-induced proposal mass

$t_i$0

which allows lossless rejection sampling in target-token space even when the drafter and target tokenize text differently (Timor et al., 31 Jan 2025). The paper reports speedups up to $t_i$1 over standard autoregressive decoding and argues that any off-the-shelf model can now serve as a drafter, subject to tokenizer accessibility and method-specific assumptions.

OmniDraft pursues the same goal operationally rather than purely algorithmically. It uses a single Llama-68M drafter with an online n-gram cache, hybrid distillation, and adaptive drafting, enabling the same drafter to pair with Vicuna-7B, Qwen2-7B, and Llama3-8B (Ramakrishnan et al., 3 Jul 2025). The cache stores mappings $t_i$2 from target tokens to draft-token n-grams, thereby handling cross-vocabulary mismatch and false rejections caused by different tokenization granularity. The paper reports up to $t_i$3 speedup and frames the result as a practical “one drafter for all” paradigm, albeit with target-specific runtime state and online adaptation (Ramakrishnan et al., 3 Jul 2025).

FlexDraft collapses the external drafter into the target model itself (Zhang et al., 19 May 2026). Its Attention Tuning keeps the autoregressive path frozen while training only mask-specific attention projectors in the final few layers on mask tokens, and its Bonus-guided Calibration adds a lightweight two-layer MLP that adjusts draft logits after the bonus token is resolved: $t_i$4 The system then switches between parallel draft-and-verify at small batch sizes and sequential draft-then-verify at large batch sizes. On Qwen3-8B, the paper reports an average $t_i$5 speedup over autoregressive decoding without quality loss (Zhang et al., 19 May 2026). FlexDraft therefore exemplifies a near-free integrated drafter: no standalone draft model, but not zero extra parameters or zero extra training.

6. Diffusion-model free drafters, limits, and outlook

In Diffusion Transformers, FREE introduces a lightweight drafter that autoregresses in the top-block feature space rather than in output-noise space (Wen et al., 25 Nov 2025). The drafter predicts the next top-block feature and noise estimate, is trained against a frozen DiT teacher with

$t_i$6

and is verified by the full DiT using reflection maximal coupling. FREE reaches up to $t_i$7 acceleration on ImageNet-$t_i$8, while FREE (relax) uses timestep-dependent uncertainty-guided acceptance relaxation and reaches $t_i$9 (Wen et al., 25 Nov 2025). This is a feature-space analogue of a near-free drafter: the draft model is lightweight, but still explicit and trained.

“Accelerating Speculative Diffusions via Block Verification” defines a different Free Drafter for continuous diffusions (Soen et al., 11 Jun 2026). The paper first derives an exact sampler for the continuous residual needed by speculative sampling, then uses it to enable block verification for diffusion trajectories. Free Drafter itself is a heuristic self-speculative drafter that reuses target-model scores already computed during the previous round’s parallel verification pass, making drafting overhead negligible beyond the existing verification. In idealized analysis, the paper contrasts Frozen and Free through

$e_i$0

showing why lower block efficiency can still translate into better wall-clock speed when draft overhead collapses (Soen et al., 11 Jun 2026). Empirically, the combination of block verification and Free Drafter yields up to a 6.3% speedup over existing speculative methods with no additional training (Soen et al., 11 Jun 2026).

The literature also clarifies several misconceptions. A common misconception is that “Free Drafter” implies a complete general-purpose drafting agent. LexDrafter explicitly does not draft full legal acts and does not identify terms automatically (Chouhan et al., 2024). Another misconception is that final visible output alone is an adequate benchmark for drafting automation; DrafterBench instead evaluates executability, operation-path correctness, and policy compliance (Li et al., 15 Jul 2025). In inference, “free” often coexists with approximations or trade-offs. FLy preserves more than 99% target-model accuracy but is not exact in the distribution-preserving sense of vanilla speculative decoding (Li et al., 28 Nov 2025), whereas FlexDraft and the heterogeneous-vocabulary algorithms retain losslessness by leaving target-side verification exact (Zhang et al., 19 May 2026, Timor et al., 31 Jan 2025).

Taken together, these works suggest that Free Drafter is best understood not as one architecture but as a design objective: reduce the cost, coupling, or specialization burden of drafting while preserving either formal correctness, target-distribution exactness, or editable artifact quality. The resulting systems range from narrow legal-definition assistants to cross-vocabulary speculative decoders and self-speculative diffusion drafters, but they converge on the same engineering question: how much of drafting can be made reusable, training-free, or effectively amortized without surrendering control over the final artifact or output distribution.