Anchors Enhance Controllability and Reasoning of Diffusion Language Models

arXiv:2610.15097 · cs.LG · Submitted 2026-10-10 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Today's paper: "Anchors Enhance Controllability and Reasoning of Diffusion Language Models".

Jane: The gist: AnchorDLM is a framework that trains an anchor generator to produce an anchor consisting of a short output fragment and its position for each query,

Tom: First, who's behind it and why it matters.

Title and authors: Tom: So we're looking at this paper, "Anchors Enhance Controllability and Reasoning of Diffusion Language Models." It sounds like they're tackling a big problem with these models.

Jane: What is that big problem, Tom? Like what can these diffusion language models do now that it’s hard to tell them *how* to do specific things reliably?

Tom: Well, the paper points out that controllability in diffusion language models is still underexplored. They define controllability as the ability to satisfy task constraints while keeping the model's original capabilities intact ><ref:2610.15097#pg1>.

Lu: What they're focusing on is that these models have bidirectional attention, which means control tokens can guide generation from any position in the output sequence ><ref:2610.15097#pg2>. But effective guidance seems to depend on whether the content of the control token matches where it's placed ><ref:2610.15097#pg2>.

Meng: So, if I’m trying to get a model to write code in a specific structure, it seems like putting the right piece of guidance in the right spot is key ><ref:2610.15097#pg2>. But how do we learn that pairing?

Jane: That's the main question, Meng. The paper proposes AnchorDLM as a framework where an anchor generator produces two things for each query: a short output fragment and its position ><ref:2610.15097#pg2>.

Tom: Exactly, that’s the core idea of AnchorDLM ><ref:2610.15097#pg2>. They place this anchor as control tokens at the specified position to initialize the output sequence of a frozen diffusion language model ><ref:2610.15097#pg1>.

Lu: They learn the anchor content and its placement together so that each anchor provides semantic guidance suited to its position ><ref:2610.15097#pg2>. That is what they are trying to achieve with this framework ><ref:2610.15097#pg2>.

Meng: So, instead of using generic structural templates for control, they want the anchor to actually provide the meaning or reasoning process needed for that specific query ><ref:2610.15097#pg2>.

Jane: Right, so it moves beyond just putting in some predefined JSON keys and delimiters to something that adapts to what the model needs for each request ><ref:2610.15097#pg2>. This makes the guidance semantic rather than just structural ><ref:2610.15097#pg2>.

Tom: The training part is interesting, too, because they use two stages: supervised fine-tuning and then reinforcement learning ><ref:2610.15097#pg3>. Supervised fine-tuning teaches the generator to produce anchors that are query adaptive and follow a valid format ><ref:2610.15097#pg3>.

Title and authors: Lu: And then they use reinforcement learning to optimize that generator further by rewarding answer correctness and constraint satisfaction from the frozen diffusion language model's outputs ><ref:2610.15097#pg3>. This is where they really learn what guidance to provide and where to place it ><ref:2610.15097#pg2>.

Jane: It’s like training a robot not just to follow commands, but to figure out the best command and the best time to issue it based on what the task actually demands ><ref:2610.15097#pg2>.

Meng: And they use a specific technique called Weighted Preference Optimization, or WPO, which accounts for how well the current generator matches the data collection policy ><ref:2610.15097#pg3>. That sounds complicated to run on a real scale ><ref:2610.15097#pg3>.

Tom: It’s about making sure we don't just train it for a specific test set, but that the learning generalizes to real use cases ><ref:2610.15097#pg3>. And the theoretical side is interesting too; they interpret anchor placement through discrete flow matching, or DFM ><ref:2610.15097#pg3>.

Lu: They see it as reshaping the initial velocity field that guides generation, which suggests a way to make more nuanced trajectory shaping during denoising ><ref:2610.15097#pg3>. This links the control tokens directly to how the model moves through its noise process ><ref:2610.15097#pg3>.

Jane: So, if you look at it from a flow matching view, placing an anchor is like changing the starting direction of that flow before it starts moving toward the final answer ><ref:2610.15097#pg3>. That’s a pretty cool way to think about it ><ref:2610.15097#pg3>.

Tom: And they show some solid results, showing that AnchorDLM improves controllability by eleven point three zero G-mean points on average across five different diffusion language model backbones ><ref:2610.15097#pg4>. That’s a tangible number ><ref:2610.15097#pg4>.

Meng: Eleven point three G-mean points is a decent gain, especially when they compare it to the strongest baseline for that same backbone ><ref:2610.15097#pg4>. But we need to see if this holds up when we try to deploy it at scale ><ref:2610.15097#pg4>.

Jane: And they showed that when trained for reasoning, AnchorDLM actually matches or even exceeds the strongest baseline in all twenty reasoning settings ><ref:2610.15097#pg4>. That’s pretty impressive for a model meant to reason ><ref:2610.15097#pg4>.

Tom: They also found that they can use the anchor generator trained on LLaDA-8B-Base and transfer it to LLaDA-8B-Instruct without retraining, which improves all evaluated metrics by fifteen point one nine to forty-two point four three points ><ref:2610.15097#pg4>. That’s a big win for deployment efficiency ><ref:2610.15097#pg4>.

Lu: The analysis on anchor content and placement compatibility is important because they found that just moving the same anchor content can actually hurt task performance, especially for code generation ><ref:2610.15097#pg4>. So matching content and placement matters a lot ><ref:2610.15097#pg4>.

Title and authors: Jane: That makes sense, because if the guidance itself isn't right for that specific spot, it just adds noise instead of helping ><ref:2610.15097#pg4>. And they noted that the predicted positions for these anchors are pretty broad, spanning over eighty tokens across different samples ><ref:2610.15097#pg4>.

Meng: Eighty tokens is a lot of variation to manage on a production system ><ref:2610.15097#pg4>. And they also found that the anchors only account for about four point three three to ten point eight eight percent of the output tokens on average across those benchmarks ><ref:2610.15097#pg4>. That suggests it’s a focused intervention, not a total rewrite of the output ><ref:2610.15097#pg4>.

Tom: The ablation studies were pretty telling because they showed that removing the query-anchor augmentation hurts performance by way of nearly eliminating the gain of AnchorDLM and even hurting task performance ><ref:2610.15097#pg4>. So having that anchor mechanism is really essential ><ref:2610.15097#pg4>.

Lu: And they found a specific case study with a comment anchor that showed the DLM could generate a correct solution with interleaved comments and code, satisfying both correctness and style constraints ><ref:2610.15097#pg4>. That shows the practical application of matching content and placement ><ref:2610.15097#pg4>.

Jane: So, to wrap up this part, AnchorDLM is a model agnostic framework that learns both the content and the position of an anchor for each query to guide generation from the initial state of a frozen diffusion language model ><ref:2610.15097#pg1>. It shows that learning position and semantic content end-to-end with feedback from downstream DLMs ><ref:2610.15097#pg3>.

Tom: So, in conclusion, this paper provides a new way to realize the potential of diffusion language models through template infilling, and it confirms that anchors significantly improve controllability and reasoning across diverse benchmarks ><ref:2610.15097#pg4>.

Lu: It really shows how learning both the position and the semantic content of placed anchors end-to-end with feedback from the downstream DLM ><ref:2610.15097#pg3>. This is a solid contribution to controlling these generative systems ><ref:2610.15097#pg4>.

Meng: For deployment, it means we can use this to add specific structural or reasoning guidance without needing to retrain the entire foundation model ><ref:2610.15097#pg4>. That’s something I can actually think about for production pipelines ><ref:2610.15097#pg4>.

Jane: It's definitely a framework that offers substantial diversity and flexibility of anchors, as predicted positions span over eighty tokens across samples ><ref:2610.15097#pg4>. We'll talk more about what those implications are in the next segment ><ref:2610.15097#pg4>.

The paper's summary: Tom: So, to recap, AnchorDLM is this framework that learns two things for every query: what kind of anchor content you need and exactly where to place it in the sequence of a diffusion language model so it can guide the denoising process.

Jane: Right, but what does that actually *mean* for someone just listening? It means we’re not just feeding the model a pre-written instruction like "write code here," but we’re giving it a tiny piece of guidance—the anchor—and telling it precisely which spot in the output sequence that guidance needs to land.

Lu: The core idea is using this learned anchor content and placement to reshape the initial velocity field during generation, according to discrete flow matching theory. It’s about controlling the direction of how the model moves through its noise process ><ref:2610.15097#pg3>.

Meng: So, if I’m trying to get a specific style for an AI output, say a particular commenting pattern or a complex mathematical structure, this lets me inject that structural knowledge right into the model's starting point without retraining the whole thing ><ref:2610.15097#pg4>.

Tom: Exactly. And they trained it in two ways—first supervised fine-tuning to learn the format of these anchors—and then reinforcement learning to actually optimize *what* those anchors should say and *where* they should go based on whether the model’s final output actually satisfied the constraints we set ><ref:2610.15097#pg3>.

Jane: I’m curious about the results for a minute. They found that across five different diffusion language model backbones, this method improved controllability by an average of eleven point three G-mean points over the strongest existing baselines ><ref:2610.15097#pg4>.

Lu: That improvement is substantial because it holds up even when they test it on reasoning tasks, where AnchorDLM actually matches or exceeds the best baseline in all twenty of those reasoning settings ><ref:2610.15097#pg4>.

Meng: But there’s a caveat on the results. They found that you can’t just move an anchor around; if you change the content but keep the same spot, it actually hurts performance, especially for code generation ><ref:2610.15097#pg4>. So matching the content and placement matters critically ><ref:2610.15097#pg4>.

Tom: And they found that transferring an anchor generator trained on one model base to another, like moving from LLaDA-8B-Base to LLaDA-8B-Instruct, actually improves all the metrics by a lot—from fifteen point nineteen up to forty-two point forty-three points ><ref:2610.15097#pg4>. That’s a big deal for deployment efficiency.

Jane: It sounds like they’ve managed to create something that is both very flexible—because the predicted positions span over eighty tokens across samples—and actually effective at teaching the model specific skills when it needs them ><ref:2610.15097#pg4>.

Lu: The theoretical interpretation through discrete flow matching shows that these anchor tokens create a persistent context that influences the velocity evaluations throughout the whole denoising process, which is what allows for that nuanced trajectory shaping you mentioned, Jane ><ref:2610.15097#pg3>.

Meng: What I worry about is how this runs in a real production pipeline. They noted that anchors only cover about four point three to ten point eight eight percent of the total output tokens on average across their benchmarks ><ref:2610.15097#pg4>. That means it’s a targeted intervention, not something that completely rewrites the whole thing ><ref:2610.15097#pg4>.

Tom: But the ablation studies back up the idea that this mechanism is necessary; removing the query-anchor augmentation nearly eliminates all those gains and actually hurts performance on its own ><ref:2610.15097#pg4>.

Jane: So, what does this mean for us if we’re building AI systems? It suggests we can stop relying only on massive re-training sessions and start using these learned anchors to inject specific structural or reasoning guidance right into the generation process on the fly ><ref:2610.15097#pg4>.

The paper's improvements: Tom: So, moving past the setup, they are showing how this entire AnchorDLM framework allows you to fine-tune controllability and reasoning separately using two distinct training stages – supervised fine-tuning and then reinforcement learning ><ref:2610.15097#pg3>.

Jane: It’s like they’re not just building one model that tries to do everything at once, but they can train a specific anchor generator for pure control, and then another one optimized specifically for complex reasoning tasks like mathematical problems ><ref:2610.15097#pg4>.

Lu: The key improvement is the joint optimization; the RL stage uses rewards based on answer correctness and constraint satisfaction from the frozen diffusion language model’s outputs to guide exactly what guidance to provide and where to place it ><ref:2610.15097#pg3>.

Meng: What this means for deployment is that you can get precise guidance during generation from an initial state without needing any update to the parameters of the main language model itself, which saves a ton of compute time on the heavy model side ><ref:2610.15097#pg4>.

Jane: That’s huge for engineers because it lets us satisfy those complex task constraints, like specific text structures or certain reasoning styles, while keeping the model's original capabilities totally intact ><ref:2610.15097#pg4>.

Tom: And the theoretical underpinning is really interesting; they use discrete flow matching to show that anchor placement is fundamentally about reshaping the initial velocity field that guides generation during denoising ><ref:2610.15097#pg3>.

Lu: They’re arguing that anchor tokens and the subsequent revealed tokens persist, providing context that influences those velocity evaluations all the way through the denoising steps, which is what helps control the trajectory in a mathematical sense ><ref:2610.15097#pg3>.

Jane: So they're essentially proving that you can learn both the position and the meaning of an anchor end-to-end, getting feedback directly from how well the downstream language model performs on its actual tasks ><ref:2610.15097#pg3>.

Tom: They also highlighted that matching content and placement is crucial for structured code generation because relocating the same anchor content actually degrades performance on those tasks ><ref:2610.15097#pg4>.

Meng: That’s a practical warning for us; if we just slap in random control tokens, it might be worse than doing nothing at all ><ref:2610.15097#pg4>.

Lu: And they found that optimizing anchors specifically for backward reasoning and formal math constraints shows superior performance when tackling those specific types of problems ><ref:2610.15097#pg4>.

Jane: It means this isn't just about making the AI generally better; it’s about giving it targeted, specialized superpowers for things like code or complex logic without needing a massive retraining effort ><ref:2610.15097#pg4>.

Tom: And they demonstrated that even transferring the trained generator from a larger base model to an instruction-tuned version works well, boosting metrics by over forty points in some cases ><ref:2610.15097#pg4>.

Jane: It sounds like this framework offers a lot of flexibility—the ability to use anchors that span over eighty tokens in predicted positions—which is pretty useful for handling varied inputs ><ref:2610.15097#pg4>.

Lu: The main limitation they point out is the dependence on those downstream outcomes; the whole system relies on having good feedback from the language model to learn what works, so it’s not a standalone solution for every single problem ><ref:2610.15097#pg3>.

Meng: So, it’s powerful for specific controlled tasks, but you still need a solid base model to start with and good test data to teach the generator what guidance is actually useful ><ref:2610.15097#pg4>.

Conclusion: Tom: So we’ve walked through how AnchorDLM works, from training an anchor generator to learn placement and content, to seeing how it boosts controllability by eleven point three G-mean points across five different diffusion language model backbones ><ref:2610.15097#pg4>.

Jane: It’s clear that this framework helps us achieve a level of control over these models that we couldn't get before because it learns the guidance directly from the downstream tasks, not just using some generic template ><ref:2610.15097#pg3>.

Lu: The big picture here is showing that learning both the position and semantic content of anchors end-to-end with feedback from those models is a solid way to realize the potential of diffusion language models through template infilling ><ref:2610.15097#pg4>.

Meng: For deployment, it means we can add specific structural or reasoning guidance without needing to retrain the entire foundation model, which is a big win for getting custom AI systems running faster ><ref:2610.15097#pg4>.

Lalam: I’m sure of this answer. AnchorDLM provides a new way to realize the potential of diffusion language models through template infilling because it learns anchor content and placement from preferences constructed using downstream outcomes in Section three point three ><ref:2610.15097#pg3>.

Jane: So, what’s the final word on how important matching content and placement is for things like code generation? We talked about that earlier, Tom.

Tom: Yeah, it’s pretty critical; if you just move the anchor around without changing what it says, task performance can actually get worse on code generation tasks ><ref:2610.15097#pg4>.

Lu: And they showed that anchors account for only about four point three to ten point eight eight percent of the output tokens on average across benchmarks, which suggests a very focused intervention ><ref:2610.15097#pg4>.

Meng: I just hope this doesn't become too complex to manage at scale; I still worry about how these specific constraints translate when you’re running massive inference pipelines ><ref:2610.15097#pg3>.

Lalam: The system is quite robust because the RL stage accounts for the mismatch between the current generator and the data collection policy using Weighted Preference Optimization, WPO ><ref:2610.15097#pg3>.

Jane: It sounds like we have a solid method here to get targeted, controllable generation by learning both where to put things and what to put there for every query ><ref:2610.15097#pg3>.

Tom: We’re wrapping up our look at AnchorDLM, which successfully shows that anchors enhance controllability and reasoning of diffusion language models ><ref:2610.15097#pg4>.

Lu: This work provides a new way to realize the potential of diffusion language models through template infilling because it learns anchor content and placement from preferences constructed using downstream outcomes in Section three point three ><ref:2610.15097#pg3>.

Jane: It really shows how learning both the position and the semantic content of placed anchors end-to-end with feedback from the downstream DLMs ><ref:2610.15097#pg3>.

Tom: I’m excited about what this means for fine-tuning diffusion language models using these learned anchor strategies.

Meng: It’s a promising direction for adding specific structural guidance to text generation with less overall model overhaul.

Lu: We’ll be keeping an eye on how this framework evolves and if we can push the boundaries further on what kind of control we can impose.

Feiyu Qu, Zheng Huang, Andrea Zanette

Dartmouth College · Carnegie Mellon University

cs.LG

Submitted: 2026-10-10

Updated: 2026-10-10

License: http://creativecommons.org/licenses/by/4.0/

The gist: The gist: AnchorDLM is a framework that trains an anchor generator to produce an anchor consisting of a short output fragment and its position for each query, which are then placed as control tokens

Key concepts

Anchor Generator (gθ): This is the component trained to produce an anchor, which is a pair of output fragment and its position for a given query. It's implemented as a lightweight LoRA adapter on top of a base language model, learning what kind of guidance (content) and where to place it in the diffusion process.
Frozen Diffusion Language Model (DLM): This is the main language model that remains unchanged during training. The anchor generator places control tokens at specific positions within this frozen DLM's initial state, which then steers the model's subsequent denoising steps to produce a controlled output.
Discrete Flow Matching (DFM) Interpretation: This theoretical lens views anchor placement as reshaping the initial velocity field that guides generation. Anchors persist and provide context throughout denoising, influencing how the model evolves towards the correct terminal distribution.

Summary

The gist: AnchorDLM is a framework that trains an anchor generator to produce an anchor consisting of a short output fragment and its position for each query, which are then placed as control tokens at specified positions in a frozen Diffusion Language Model to guide subsequent denoising.

How it works

AnchorDLM is designed to enhance the controllability of Diffusion Language Models (DLMs) by learning what guidance to provide and where to place it, so that each anchor provides semantic guidance suited to its position and can then improve constraint satisfaction without compromising task performance The framework consists of two components bridged by an anchor: an anchor generator gθ with parameters θ, implemented as a lightweight Low-Rank Adaptation(LoRA) adapter on top of a pretrained language model (Qwen3-1.7B-Base (Yang et al., 2025a)), and a frozen DLM with fixed parameters ϕ Given the query q, the anchor generator produces an anchor a = (p, c) = gθ(q) We place c at position p of the DLM’s initial state, keeping all remaining positions as the mask token M, yielding an anchored initial state x(a)1 in VL The frozen DLM then performs standard denoising starting from x(a)1 to produce x0 The single-step denoising transition can be written as pϕ(xt−h xt, q), x1 = x(a)1, (4) where pϕ(xt−h xt, q) denotes the single-step denoising transition of the frozen DLM

Training Stages

The training process for the anchor generator involves two main stages:

Supervised Fine-Tuning (SFT): This stage aims to equip the anchor generator with the ability to produce query adaptive and format valid anchors To teach the generator the required anchor format, it is trained on a rebalanced dataset where anchors are grouped by functional role
Reinforcement Learning (RL): This further optimizes the generator using rewards based on answer correctness and constraint satisfaction in the frozen DLM’s outputs Given the cost of DLM inference, offline RL with a fixed preference dataset is used, where 80% of preference pairs are constructed from queries with both successful and failed outputs The Weighted Preference Optimization (WPO) objective is used to account for the mismatch between the current generator and the data collection policy

Theoretical Interpretation

Through the lens of discrete flow matching (DFM), anchor placement is interpreted as helping to reshape the initial velocity field that guides generation For a fixed query q, let p0(· q) denote the unanchored terminal distribution With κt = 1 − t, the probability velocity for reverse updates from t to t − h is ν i t(v, xt, q) = 1/th p i0t(v xt, q) − δx it(v) i, 0 < t < 1 (7) Anchor tokens and subsequently revealed tokens therefore persist, providing context that can influence velocity evaluations throughout denoising For any correct controlled target x⋆ with x⋆ Sa = c, initialization also reduces the Hamming distance from dH(ML, x⋆) = L to dH(x(a)1, x⋆) = L − c This criterion motivates learning anchor content and placement from the preferences constructed using downstream outcomes in Section 3.3

Experimental Results

Experiments on code generation and mathematical reasoning across five DLM backbones show that AnchorDLM improves controllability by 11.30 G-mean points on average over the strongest same-backbone baselines and, when trained for reasoning, matches or exceeds them in all 20 reasoning settings Table 1 reports results with anchor generators trained separately for controllability and reasoning AnchorDLM achieves the highest G-mean in all 30 controllability settings across five DLM backbones, exceeding the strongest baseline for the same backbone in each setting by 11.30 points on average

Key Findings

The analysis of anchor content and placement compatibility shows that relocating the same anchor content can impair task performance, highlighting the importance of matching content and placement, particularly for code generation Anchor position distribution is broad, with predicted positions spanning over 80 tokens across samples Furthermore, anchors account for only 4.33–10.88% of output tokens on average across benchmarks Transferring the anchor generator gθ, trained using outputs from LLaDA-8B-Base, to LLaDA-8B-Instruct without retraining improves all evaluated metrics over the vanilla baseline, with controllability gains of 15.19 to 42.43 points Ablation studies confirm that removing the query-anchor augmentation is by far the most damaging, nearly eliminating the gain of AnchorDLM and even hurting task performance The case study illustrates that with a comment anchor (Case 1), the DLM generates a correct solution with interleaved comments and code, satisfying both correctness and style constraints

Conclusion

In this work, to address challenge of controllability of DLM, we introduced AnchorDLM, a model agnostic framework that jointly learns anchor content and placement for each query to guide generation from the initial state of a frozen DLM Our DFM analysis characterizes the persistent influence of anchors on the velocity field and their effect on the terminal distribution under idealized assumptions Across five DLM backbones, training for the respective objectives improves controllability by 11.30 G-mean points on average and matches or exceeds the strongest same-backbone baseline in every reasoning setting The framework demonstrates that learning both the position and the semantic content of placed anchors end-to-end with feedback from the downstream DLM The proposed method offers substantial diversity and flexibility of anchors, as predicted positions span over 80 tokens across samples AnchorDLM significantly improves controllability and reasoning performance across diverse benchmarks The framework successfully addresses the challenge of controllable text generation in DLMs by learning anchor content and placement from preferences constructed using downstream outcomes in Section 3.3 The study provides a new way to realize the potential of diffusion language models through template infilling The work concludes that anchors enhance controllability and reasoning of diffusion language models

--- Page 1 ---

ANCHORS ENHANCE CONTROLLABILITY AND REASONING OF DIFFUSION LANGUAGE MODELS

Training Stages

The training process for the anchor generator involves two main stages:

Supervised Fine-Tuning (SFT): This stage aims to equip the anchor generator with the ability to produce query adaptive and format valid anchors To teach the generator the required anchor format, it is trained on a rebalanced dataset where anchors are grouped by functional role

Improvements for AI systems

The AnchorDLM framework can be used to enhance controllability of Diffusion Language Models (DLMs) without any update to its parameters, allowing precise guidance during generation from an initial state. This enables the system to satisfy complex task constraints, such as specific text structures or reasoning styles, while preserving the model's original capabilities.
The system can be improved by learning what guidance to provide and where to place it by training an anchor generator with reinforcement learning (RL) using rewards computed from the DLM’s generated outputs based on answer correctness and constraint satisfaction. This joint optimization ensures that anchors provide semantic guidance suited to its position.
The system can be enhanced by incorporating a theoretical understanding of control through discrete flow matching (DFM), interpreting anchor placement as reshaping the initial velocity field that guides generation, which suggests a mechanism for more nuanced trajectory shaping during denoising.
The system can perform superior structured code generation by utilizing an anchor strategy where the anchor content and placement are matched, as relocating anchors can impair task performance, highlighting the importance of matching content and placement, particularly for code generation. This leads to higher scores on the Structured code (Str.) control metric.
The system can exhibit superior mathematical reasoning capabilities by employing anchors optimized specifically for Backward reasoning (Bwd.) and Formal math (math) constraints, as the RL stage optimizes anchors based on these specific downstream outcomes.

Abstract

Diffusion language models (DLMs) offer new opportunities for controllable text generation. However, their controllability, defined as the ability to satisfy task constraints while preserving their original capabilities, remains underexplored. DLMs' bidirectional attention allows control tokens to guide generation from arbitrary positions in the output sequence, but effective guidance depends on the compatibility between their content and placement. To this end, we propose AnchorDLM, a framework in which an anchor generator produces an anchor consisting of a short output fragment and its position for each query. The anchor is placed as control tokens at the specified position to initialize the output sequence of a frozen DLM and guide subsequent denoising. We train the anchor generator with reinforcement learning (RL) to jointly optimize anchor content and placement, using rewards computed from the DLM's generated outputs based on answer correctness and constraint satisfaction. Moreover, through the lens of discrete flow matching (DFM), we interpret anchor placement as helping to reshape the initial velocity field that guides generation. Experiments on code generation and mathematical reasoning across five DLM backbones show that AnchorDLM improves controllability and further yields gains in reasoning performance across diverse benchmarks.