Solving Constraint Drift in LLM Planning with Commitment Salience Control

Language models fail at long-horizon planning in a precise, measurable way. A model will declare a constraint early in a reasoning trace. Then, many steps later, it violates that same constraint. We name this failure constraint drift in LLM planning. It grows worse as the gap between constraint declaration and constraint-relevant decision widens.

Existing mitigations treat prior reasoning as passive text to reread. Scratchpads, self-consistency, and retrieval over the model's own trace all assume that availability equals influence. Our measurements show this assumption is false. A constraint can sit in context and still lose causal force on the next token.

At KriraAI, our generative AI development team proposes Commitment Salience Control, a lightweight module that changes how declared constraints influence generation. It extracts commitments into a differentiable ledger. It reinjects them through salience-gated cross-attention at decision points. It trains with a violation-aware objective that penalizes silent constraint breaks.

Across planning tasks spanning up to 30 steps, our method cut the constraint violation rate at long distances from 38% to 11%. That is a 71% relative reduction. It flattened the constraint decay slope by 74% while adding only 3.4% parameters. This post covers the mechanism behind the failure and the full design of our method. It then walks through our experiments, our ablations, and where the approach still breaks.

The Problem: Why Committed Constraints Decay in Long Reasoning Traces

Constraint drift is not random error. It has a mechanistic cause tied to how transformers route information. This distinguishes it from generic hallucination, which we address later.

The mechanistic cause: passive memory and attention dilution

A declared constraint lives in the key-value cache as ordinary tokens. As the trace grows, the number of competing tokens grows with it. The softmax over attention scores spreads probability mass across more positions. The effective weight on any single early constraint shrinks.

We measured this directly on a 32-layer decoder. In layers 18 through 24, average attention mass on constraint tokens fell by 61% between step 4 and step 20. The constraint was still present in context. Its influence on the residual stream had quietly collapsed. We call this attention dilution, and it is the core driver of chain-of-thought constraint violation.

There is a second effect that compounds the first. Constraints declared as natural language are not typed or addressable. The model cannot cheaply ask which constraints are active right now. It must reconstruct that set implicitly at every step. Reconstruction is lossy, and the loss accumulates over long horizons.

Why existing approaches fall short

The field has produced several partial mitigations. Each helps somewhat, and each leaves the core mechanism untouched. We tested the main families and found consistent ceilings across all of them.

• Scratchpad and structured prompting make constraints explicit once, but do nothing to sustain their attention mass as the trace lengthens.

• Self-consistency samples many traces and votes, which reduces variance but does not correct a bias shared across most of the samples.

• Retrieval over the model's own trace resurfaces constraint text, yet reinjecting raw tokens reintroduces the same dilution it tried to fix.

• Recurrent memory-style approaches compress history into state, but compression discards the very constraint specificity that planning needs.

The common thread is that all of these treat memory as availability. They make constraints present. None of them makes constraints enforced at the moment a decision touches them, a gap we unpack further in our analysis of transformer working memory in reasoning and how intermediate results decay. That gap is exactly what long-horizon planning in language models requires, and it is what our work at KriraAI targets.

Core Insight: Constraints Need Enforced Salience, Not Just Availability

Our central hypothesis is simple to state and consequential in practice. A constraint influences behavior only when it is salient at the decision that depends on it. Presence in context is necessary but not sufficient. Salience must be maintained actively, not left to a diluting softmax.

This reframing changes the design target. We stop trying to store more or retrieve better. We instead ask how to keep the right constraint loud at the right moment. That question led us to separate three concerns that prior work conflates. Extraction of commitments, maintenance of their salience, and enforcement at decision points became distinct, learnable components.

The insight also predicts a counterintuitive result that we later confirmed. Injecting all commitments equally should hurt, not help, because it recreates dilution inside the injection channel. Salience must be selective.

Methodology: Commitment Salience Control

Commitment Salience Control is a small set of trained modules wrapped around a frozen base model. It has four parts that work together. The design isolates the three concerns named above and adds a training signal that ties salience to real violations. Here we describe each part, why we chose it, and what we rejected.

The method attaches to a pretrained decoder without modifying its weights. This keeps the base model's general capability intact. It also makes constraint drift in LLM planning addressable as an adapter problem rather than a full retraining problem.

The Commitment Extraction Head

At each step boundary, the model may declare something durable. The Commitment Extraction Head reads the hidden states of the completed step. It classifies spans into commitment types and encodes each into a fixed vector. We support three types: hard constraints, subgoals, and asserted facts.

We implement the head as a two-layer classifier over pooled span representations. It writes one commitment vector per detected span into the ledger. We rejected an approach that parsed constraints with an external symbolic parser. That path was brittle across phrasings and could not backpropagate into the base representations.

The head reaches 88% F1 on commitment detection in our synthetic benchmark. Extraction errors matter, and we return to them in the limitations. When the head misses a constraint, that constraint receives no protection downstream.

The Ledger and Salience Dynamics

The ledger is an addressable slot memory of active commitments. Each slot stores a commitment vector, a type tag, and a scalar salience score. Salience is the mechanism that decides which commitments get enforced now. It is the heart of commitment salience control.

Salience evolves under two forces. It decays with token distance so that stale commitments fade unless reinforced, echoing the tradeoffs we cover in our breakdown of LLM context compression and its impact on long-context accuracy. It is reinforced whenever the current decision attends to a commitment or references it in text. A small learned controller updates each score from these signals at every step.

• Decay stops the ledger from treating a constraint declared 40 steps ago as urgently as the current subgoal.

• Reinforcement lets a genuinely recurring constraint stay loud across the whole trace without manual prompting.

• The learned controller lets the model discover, from data, which commitment types deserve slow versus fast decay.

We deliberately kept salience as a scalar per slot rather than a full vector gate. A scalar is interpretable, cheap, and sufficient for ranking urgency. Richer gates added parameters and gave no measurable benefit in early trials.

Commitment Gated Cross Attention

Reinjection happens through a cross-attention block we insert at three decoder layers. The current hidden state is fed from the residual stream into the ledger. Attention logits are biased by each slot's salience score. High salience commitments, therefore, pull more strongly on the next token.

We place these blocks at layers 12, 18, and 22 of the 32-layer model. Those depths are where planning decisions consolidate in our probing analysis. Injecting only at the final layers arrived too late to steer the computation.

This is the component that converts availability into enforcement. A ledger alone makes commitments retrievable. Commitment-gated cross-attention makes them act on the residual stream precisely where decisions form.

The Violation Aware Training Objective

Availability plus reinjection still does not guarantee obedience. The model can attend to a constraint and violate it anyway. We close this gap with a violation-aware loss. During training, a verifier labels each step as consistent or violating with respect to active commitments.

Our full objective combines four terms. Each term addresses a different requirement of the method. Together, they form a single weighted loss:

• A standard language modeling loss preserves fluency and base task ability.

• A violation loss penalizes hidden states that lead to verifier-flagged constraint breaks.

• A salience regularizer discourages the controller from keeping every slot maximally salient.

• A ledger reconstruction loss ensures commitment vectors retain enough information to be checked.

We combine them as the language modeling loss plus weighted violation, salience, and ledger terms. We set the violation weight to 0.5, the salience weight to 0.1, and the ledger weight to 0.2 after a small sweep. The violation term carries the most weight because silent violations are the failures we most want to remove.

We train only the new modules and LoRA-style adapters on the cross-attention layers. The base model stays frozen throughout. This design lets commitment salience control generalize the fix without disturbing the model's broader competence.

Experimental Setup

We designed experiments to test one claim above all. Does enforcing salience reduce constraint violations that grow with horizon length? Every dataset, baseline, and metric serves that question.

Datasets and task design

We built three synthetic planning suites and one semi-realistic task. Synthetic control lets us vary horizon length and constraint count independently. That control is what makes the constraint decay slope measurable in the first place.

• Constrained scheduling assigns tasks to slots while honoring declared timing and exclusivity rules across up to 30 steps.

• Guarded blocksworld extends classic blocksworld with declared invariants that must hold at every intermediate state.

• Itinerary planning builds a multi-day plan under budget, timing, and preference constraints declared upfront.

• A policy compliance task requires drafting decisions that respect a set of stated business rules.

Each item declares its constraints early and forces relevant decisions later. This structure is what exposes long-horizon planning in language models to drift. We generated 40,000 training items and 4,000 held-out test items.

Baselines

We compared against five baselines chosen to represent the main mitigation families. Each is a fair comparison because each targets the same failure with a different mechanism. We selected them so that gains could not be attributed to a weak or unfair comparison.

• Vanilla chain of thought with no memory augmentation serves as the performance floor.

• Structured scratchpad prompting makes constraints explicit but static.

• Self-consistency with 20 samples tests whether variance reduction alone helps.

• Retrieval over the model's own trace resurfaces constraint text on demand.

• A recurrent memory baseline compresses reasoning history into a fixed state.

Metrics

Our primary metric is the constraint violation rate as a function of steps since declaration. We also report the constraint decay slope, the linear rise in violation rate per step. We separately track silent violations, meaning breaks that the model never flags. The final task success measures whether the full plan satisfies all declared constraints.

Compute and training configuration.

We ran all experiments on a 32-layer decoder with 7 billion base parameters. Training used 16 A100 80GB GPUs for 60 hours. We trained the modules with AdamW at a peak learning rate of 0.0002 and cosine decay. Batch size was 256 sequences with gradient checkpointing on the cross-attention layers.

Results and Analysis

Commitment Salience Control reduced constraint violations most where drift was worst. The gains were concentrated at long distances, exactly as the salience hypothesis predicted. Short-range behavior barely changed, which is the correct signature of a targeted fix. Below,w we report the main numbers and then decompose them.

Main results on constraint violation and task success

The baseline model's violation rate rose sharply with distance. At 2 steps since declaration, it was 4%. By 12 or more steps, it reached 38%. Our method held the same long-distance ratof 11%1%, a 71% relative reduction.

The constraint decay slope tells the same story more compactly. The baseline slope was 0.031 violations per step. Our method reduced it to 0.008, a 74% flattening. Final task success on the 30-step suites rose from 42% for vanilla chain of thought to 68% with our method. Self-consistency reached only 51% despite 20 times the inference cost.

The most striking result was in silent violations. These are the dangerous ones, since the model never signals a problem. Silent violation rate fell from 29% to 7%. The base model was already fair at flagging violations it noticed. Our gain came almost entirely from recovering breaks that previously slipped by unnoticed.

Ablation study

We removed one component at a time to attribute the improvement. The ablations confirmed that no single part carries the method alone. Salience and enforcement are both necessary.

• Removing salience decay and reinforcement erased about 60% of the total gain, confirming that uniform injection recreates dilution.

• Removing the violation loss left the model attending to constraints while still breaking them, so violations persisted.

• Replacing commitment-gated cross-attention with plain prepended ledger text retained only 22% of the gain.

• Removing the ledger reconstruction loss degraded verifier checkability and slightly raised silent violations.

The prepended text ablation is the most instructive of the four. It shows that mere availability, even of clean extracted constraints, is not enough. Enforcement in the residual stream at decision depth is what moves the numbers.

Failure cases and where the method underperforms

Our method is not uniformly better. On tasks with very few constraints and short horizons, it added latency for no benefit. In roughly 6% of long items, it suppressed a genuinely relevant but low-salience constraint. We call this salience starvation, and it is the mirror image of dilution.

Constraint revision was a second weak spot. When a task required retracting an earlier constraint, the ledger clung to the stale slot. The controller learned decay but not clean deletion. These cases capped our task success below what the violation numbers alone would predict.

Discussion and Implications

Our results reframe constraint drift as a salience problem rather than a memory problem. The field has largely assumed that longer context and better retrieval will fix long-horizon reasoning. A constraint already in context can still fail to bind, and adding more context can make binding worse.

The practical implication for practitioners is direct. If you build agentic systems that plan over many steps, such as the automation features increasingly embedded in modern SaaS products, the availability of prior constraints is not a guarantee of compliance.  You need a mechanism that keeps the relevant constraint loud at the deciding step.

There is a deeper implication for how we think about working memory in transformers. Human planning relies on holding a small set of active goals under interference. Our ledger and salience controller are a crude computational analog of that maintenance.

Finally, the silent violation result changes how we would evaluate planning systems. Aggregate accuracy hides the failures that matter most in deployment. We believe constraint decay slope and silent violation rate deserve a standard place in long-horizon evaluation.

Limitations and Future Work

This research does not solve constraint drift in general open domains. Our training signal depends on a verifier that labels violations, and reliable verifiers exist mainly for structured tasks. Extending the violation-aware objective to fuzzy natural language constraints is an open problem.

Several other limitations bound our claims honestly. Each one narrows the settings where the method applies cleanly. We list them so readers can judge the approach fairly.

• The Commitment Extraction Head reaches only 88% F1, so missed constraints receive no protection at all.

• Salience starvation suppressed genuinely relevant constraints in about 6% of the long test items.

• Constraint retraction is handled poorly, since the ledger decays stale slots but never cleanly deletes them.

• The method adds roughly 9% inference latency, which matters for tight real-time budgets.

Our next research directions follow from these gaps. We are building an explicit retraction operation so commitments can be revised, not just faded. We are training a learned consistency critic to relax the verifier dependency. We are also studying whether salience should be vector-valued for tasks with many interacting constraints. KriraAI will report these results as they mature.

Conclusion

This research makes three contributions that we believe reshape how the field should approach long-horizon planning in language models. First, we identified constraint drift in LLM planning as a salience problem, showing that attention dilution, not context loss, drives horizon-dependent violations. Second, we designed commitment salience control, a lightweight module that enforces constraints through a ledger, salience dynamics, and commitment-gated cross-attention. Third, we showed it cuts long-distance chain-of-thought constraint violation by 71%. It also flattens the constraint decay slope by 74% while adding only 3.4% parameters.

The broader lesson is that reliable planning depends on maintenance, not just memory. Keeping a small set of active constraints salient under interference is closer to how robust reasoning actually works. We think future planning systems should be judged on silent violation rate and constraint decay, not aggregate accuracy alone.

At KriraAI, we conduct original applied AI research and publish our findings openly. We then bring those insights into the production systems we build for enterprise clients. This post is one piece of a broader program on reasoning reliability in deployed AI. We would welcome discussion of these results, critique of the method, or collaboration on extending it to open-domain constraints. If you are working on long-horizon agents and care about constraint reliability, we would like to hear from you.