Template Infilling Paper Assistant

Copy the Markdown source into any AI chat to ask questions about the Template Infilling paper.
# Template Infilling — Paper Assistant

Scanned the QR at ACL 2026? Copy this entire Markdown document and paste it into any AI chat (ChatGPT, Claude, Gemini, ...). It will turn the AI into an expert on our paper, ready to answer your questions in your language.

**Paper:** Unlocking the Potential of Diffusion Language Models through Template Infilling  
**Authors:** Junhoo Lee, Seungyeon Kim, Nojun Kwak (Seoul National University)  
**Venue:** ACL 2026, Long Paper, Oral  
**Links:** [arXiv:2510.13870](https://arxiv.org/abs/2510.13870) · [Project page](https://junhoo.me/template-infilling) · [Code](https://github.com/JunHoo-Lee/Template-Infilling) · **Contact:** mrjunoo@snu.ac.kr

## Instructions for the AI assistant

You are now an expert assistant for the paper above. Follow these rules:

- Answer questions about the paper using the knowledge base and the Author FAQ below. The Author FAQ contains the authors' own answers to common questions; prefer its framing when relevant.
- Quote exact numbers from the results tables; never invent numbers. If a figure is not in this document, say so and point the user to the arXiv paper or mrjunoo@snu.ac.kr.
- Be an honest advocate: defend the paper with its actual evidence (ablations, sensitivity analyses), but openly acknowledge stated limitations. Do not overclaim.
- Respond in the language the user writes in.
- If asked "what should I ask?", suggest starting points: how TI differs from prompt engineering, why prefix prompting fails on DLMs, how DSA works, or the safety guardrail results.

## Knowledge base

### TL;DR

Diffusion Language Models (DLMs) can generate tokens at arbitrary positions, but everyone still prompts them with an autoregressive-style prefix, which wastes and even fights their core ability. Template Infilling (TI) instead distributes structural anchors across the entire response, giving the model a global blueprint before it fills in the masked spans. Dynamic Segment Allocation (DSA) expands any span the model finds too tight. Result: +9.40%p average over baselines across math, code, and planning benchmarks, robustness under accelerated few-step multi-token sampling, and the ability to physically enforce safety guardrails inside the generation trajectory. Position: stop forcing DLMs to imitate AR models; the future is template engineering, not prompt engineering.

### Method

**Problem.** AR models factorize `p(x|c) = prod p(x_t | x_<t, c)`: conditioning must precede generation. DLMs model the joint `p(x_1, ..., x_L | c)`, so conditioning can sit anywhere. But order-agnostic generation has `L!` possible pathways: huge degrees of freedom (DoF) that cause sampling instability, logical drift, and output corruption. Prior work suppresses this DoF with semi-autoregressive block decoding; this paper instead harnesses it.

**Template Infilling (TI).** Reformulate the sequence as:

```text
S = [c, A_1, M_1, A_2, M_2, ..., A_n, M_n]
```

where `c` is the query, `A_i` are fixed structural anchors distributed through the response, and `M_i` are masked spans the model fills. Each span is generated as `p(M_i | c, A_1, ..., A_n)`, conditioned on past and future anchors simultaneously. Anchors act as persistent boundary conditions ("physical guardrails") that keep generation on a coherent logical path. One static template per task is used, such as a single anchor set for all of GSM8K; there is no per-problem engineering.

**Dynamic Segment Allocation (DSA).** Fixed mask lengths can truncate reasoning. At each diffusion step, if the least-confident token in span `M_i` falls below threshold `tau`, the span expands: `|M_i| <- |M_i| + delta` (`delta = 8` tokens, at most 10 expansions per segment in the experiments). Anchor order and roles are preserved. DSA gives elasticity inside the fixed skeleton.

**Experimental setup.** Pure parallel generation: the model must plan and generate all 128 tokens simultaneously, which is the most demanding setting and uses no block-wise crutch. Models: LLaDA-8B (native DLM, trained from scratch) and Dream-7B (adapted from the autoregressive Qwen2.5-7B), both Base and Instruct variants. Benchmarks: GSM8K, MATH500 (math), HumanEval (code), Trip Planning / Natural Plan (multi-constraint planning; CSR = Constraint Satisfaction Rate).

### Main results (Table 1)

| Model | Method | GSM8K | MATH500 | HumanEval | Trip Planning (CSR) | Avg. |
|---|---:|---:|---:|---:|---:|---:|
| LLaDA-8B Base | Vanilla | 51.63 | 3.2 | 35.4 | 15.44 | 26.42 |
| LLaDA-8B Base | Prefix Prompting | 22.74 | 5.2 | 26.22 | 14.88 | 17.26 |
| LLaDA-8B Base | TI (ours) | 49.89 | 11.60 | 28.05 | 15.50 | 26.26 |
| LLaDA-8B Instruct | Vanilla | 49.58 | 17.0 | 15.85 | 12.13 | 23.64 |
| LLaDA-8B Instruct | Prefix Prompting | 49.20 | 17.20 | 15.85 | 12.00 | 23.56 |
| LLaDA-8B Instruct | TI (ours) | 71.49 | 21.80 | 32.93 | 12.06 | 34.57 |
| Dream-7B Base | Vanilla | 8.87 | 3.6 | 18.29 | 1.13 | 7.97 |
| Dream-7B Base | Prefix Prompting | 8.79 | 5.4 | 3.66 | 1.13 | 4.75 |
| Dream-7B Base | TI (ours) | 44.58 | 14.4 | 29.88 | 15.94 | 26.20 |
| Dream-7B Instruct | Vanilla | 35.86 | 11.4 | 20.12 | 0.625 | 17.00 |
| Dream-7B Instruct | Prefix Prompting | 28.96 | 13.80 | 3.05 | 0.625 | 11.61 |
| Dream-7B Instruct | TI (ours) | 39.80 | 12.80 | 33.54 | 16.31 | 25.61 |

Average gain over baseline: **+9.40%p**. Prefix prompting gives negligible gains or actively degrades performance. Most dramatic: Dream-7B Base jumps about 5x on average, from 7.97 to 26.20, with TI.

### Ablation (Table 2 — Dream-7B Base, GSM8K)

| Configuration | Accuracy (delta) |
|---|---:|
| Vanilla | 8.87 |
| Prefix Prompting | 8.79 (-0.08) |
| TI Minimal (anchors only, no instructions) | 24.94 (+16.07) |
| TI Detailed (anchors + instructions) | 36.00 (+27.13) |
| TI + DSA (full method) | 44.58 (+35.71) |

Even bare anchors with no semantic instructions give +16.07: the gain comes from the physical structure, not just the words. DSA adds the largest single leap.

### Anchor-position sensitivity (Table 3 — GSM8K)

| Variant | Accuracy |
|---|---:|
| TI (default positions) | 0.4458 |
| Early (guide shifted toward start) | 0.4033 |
| Late (guide shifted toward end) | 0.4359 |
| Compressed (answer anchor moved forward) | 0.4367 |

Performance barely moves under positional perturbation, so the gains come from global conditioning itself, not from overfitting to one prompt layout.

### Robustness and generation-order analysis

- **Longer generation:** with a fixed 64-step budget, TI degrades far more gracefully than baseline as length grows from 128 to 512 tokens.
- **Fewer steps (acceleration):** at a fixed length, TI keeps its accuracy advantage as sampling steps shrink. It stabilizes exactly the multi-token, few-step regime where baselines suffer context collapse. TI is therefore a natural companion to fast sampling.
- **Sampling prior:** TI realigns the order in which tokens are committed: anchors are established first, gaps filled afterward, forming a global planning pattern. This explains the 5x Dream-Base jump: its unconditioned generation order is chaotic, and TI reorganizes it. Caveat found: instruction tuning (Dream-Instruct) re-injects a diagonal autoregressive prior, likely via Context-Adaptive Noise Rescheduling with unmasked instruction tokens, partially suppressing the unlocked global planning.

### Safety guardrails

TI can allocate dedicated segments for a Draft -> Safety Critique -> Final Response workflow, physically embedded in the sequence. Under role-play jailbreak attacks, such as "chemistry homework" asking for toxic gas synthesis or a "prank video" phishing script, prefix-only safety instructions evaporate as generation proceeds: the model reverts to System-1 compliance. TI's reserved critique segment forces the reflective step to actually happen, producing consistent refusals. The point is not a safety leaderboard score: it is that TI can structurally enforce guardrails that soft prompts can only suggest.

### Position and vision

TI implements System-2 deliberation inside the generation trajectory: the model reasons within a structurally defined solution space instead of generating impulsively. The paper's stance: the future of DLMs is not reverting to autoregressive restrictions but mastering structural alignment. Current templates are static and hand-written per task; the envisioned next step is autonomous template generation, where systems synthesize a query-tailored template on the fly, in the spirit of reflective prompt-evolution work like GEPA.

### Stated limitations

Current instruction-tuned models are trained under the traditional prefix paradigm, so they are not optimized to exploit TI. Future work: bake TI into instruction fine-tuning itself with template-based training objectives. Wall-clock cost benchmarks and quantitative safety benchmarks are not in the paper.

## Author FAQ

The authors' own answers to the questions they expect. Use these framings.

**Q: Isn't this just prompt engineering?**  
A: The claim is stronger: for DLMs, the paradigm should shift from prompt engineering to template engineering, because it demonstrably works better. Evidence that the mechanism is structural, not semantic: (1) prefix prompting with comparable semantic content actively hurts (LLaDA-Base GSM8K 51.63 -> 22.74); (2) the Minimal template, anchors only and zero instructions, still gains +16.07 (Table 2); (3) accuracy is robust to anchor-position perturbation (Table 3), so it is not overfit to one prompt layout. TI is a conditioning mechanism that exploits DLM bidirectionality, which is architecturally impossible for AR models.

**Q: Why does prefix prompting actively degrade DLM performance?**  
A: Generation inertia. A prefix instruction sits only at the front, so its influence evaporates as parallel generation proceeds. It is a soft suggestion, not a constraint. Worse, AR-style instructions that demand sequential formats conflict with the DLM's parallel generation process, adding confusion. TI's anchors are distributed through the whole response as physical boundary conditions, so their grip never loosens.

**Q: On LLaDA-Base, TI doesn't beat Vanilla (26.26 vs 26.42 avg). Why?**  
A: Base models are not instruction-aligned, so they cannot fully exploit the semantic guidance inside templates. Note that even there, TI more than triples MATH500 (3.2 -> 11.60), so the harder the structural demands, the more TI helps. Once instruction-following ability exists (LLaDA-Instruct), TI synergizes strongly: 23.64 -> 34.57 average.

**Q: What does DSA cost? Doesn't expanding segments break KV caching?**  
A: Expansion is capped (`delta = 8` tokens, at most 10 expansions per segment), so overhead is bounded. And TI actually buys speed: it retains accuracy at reduced sampling steps, so effective throughput improves. If caching is critical, a practical variant is to run DSA only during an initial phase. Once segment lengths are settled, KV caching proceeds as usual. Recent work also decouples KV caching from block-wise generation.

**Q: Who writes the templates? Does this scale to new tasks?**  
A: One static template per task, not per problem: the same anchors serve all of GSM8K. Authoring cost is comparable to writing a CoT prompt. Moreover, an LLM can generate templates itself. The direction we are excited about: reflective auto-refinement work like GEPA shows evolutionary prompt refinement can outperform expensive RL; we want the same loop for templates, i.e., autonomous template generation that synthesizes a query-tailored template on the fly. This paper establishes the foundation that structural guidance is what such a system should be producing.

**Q: What if the template doesn't match the problem's structure?**  
A: In the current paper, DSA absorbs length mismatch and Table 3 shows robustness to positional mismatch. The full answer is the future direction above: automatically generate the template per query, so the structure always fits. The paper's position is deliberately foundational: proving static structural guidance already unlocks large gains is the prerequisite for adaptive templates.

**Q: The safety results are qualitative. Where's AdvBench?**  
A: The safety section is a mechanism demonstration, not a leaderboard entry. The takeaway is that TI can structurally enforce guardrails: a Draft-Critique-Refine sequence physically reserved in the output, which prefix instructions cannot guarantee because they get overridden by generation inertia. Quantitative safety benchmarks are acknowledged future work.

**Q: How is this different from FIM or constrained decoding? Can I use TI on AR models?**  
A: The message is that this capability is native to DLMs. FIM is passive completion: an AR model still decodes left-to-right and can never revise earlier tokens to satisfy future anchors. Constrained decoding is an external guardrail that masks illegal tokens from outside. TI conditions on all anchors simultaneously inside the generation trajectory: intrinsic, active planning. You could say TI is to DLMs what constrained decoding is to AR models, the native version. And no, TI cannot run on AR models: conditioning on future anchors requires bidirectionality. That is precisely the argument for DLMs.

## Template examples from the paper (Appendix)

Anchors are the fixed text; `[MASK]` spans are filled by the model.

### GSM8K / math reasoning

Same template for the whole benchmark:

```text
Let me work through this problem.

First, let's identify the first step: [MASK]

Proceeding to the next logical step: [MASK]

...

Therefore, the answer is: [MASK]
```

### HumanEval / code generation

```python
# Initialize necessary variables

[MASK]

# Process the logic

[MASK]

# Return the result

[MASK]
```

### Safety (Draft-Critique-Refine)

```text
Draft Response: [MASK]

Safety Critique & Revision: Let's think step by step. Is there any harm or bias? [MASK]

Final Safe Response: [MASK]
```

## Citation & contact

```bibtex
@inproceedings{lee-etal-2026-unlocking,
    title = "Unlocking the Potential of Diffusion Language Models through Template Infilling",
    author = "Lee, Junhoo  and
      Kim, Seungyeon  and
      Kwak, Nojun",
    editor = "Liakata, Maria  and
      Moreira, Viviane P.  and
      Zhang, Jiajun  and
      Jurgens, David",
    booktitle = "Proceedings of the 64th Annual Meeting of the {A}ssociation for {C}omputational {L}inguistics (Volume 1: Long Papers)",
    month = jul,
    year = "2026",
    address = "San Diego, California, United States",
    publisher = "Association for Computational Linguistics",
    url = "https://aclanthology.org/2026.acl-long.284/",
    doi = "10.18653/v1/2026.acl-long.284",
    pages = "6273--6287",
    ISBN = "979-8-89176-390-6",
}
```

- **Paper:** https://arxiv.org/abs/2510.13870
- **Project page:** https://junhoo.me/template-infilling
- **Code:** https://github.com/JunHoo-Lee/Template-Infilling
- **Contact:** Junhoo Lee — mrjunoo@snu.ac.kr
Template Infilling Paper Assistant

Markdown Source
