Which Constraints Belong in the Draft? Scale-Dependent Constraint Routing for Two-Stage Instruction Following

Language models handle one instruction well and many instructions badly. A request such as "write a product summary in a friendly tone, under 120 words, as JSON with keys title and body, never using the word 'cheap'" bundles semantic, stylistic, numeric, lexical and structural rules, and models increasingly drop some of them as the bundle grows. A separate line of work shows that forcing a model to obey output formats while it reasons costs accuracy. The fix there is to let the model write a free draft first and then convert it into the required form in a second pass. This note asks a question neither literature has posed: when a request carries a bundle of constraints, which constraints should the model see while drafting, and which should be deferred to the second, rewriting pass?

Our claim is that the best split is not a fixed rule. It moves with model size in a predictable direction. Small models should draft against almost nothing but the content request and push surface-form rules (length, banned words, format, punctuation) into a verifier-backed rewriting stage. Large models can carry more rules into the draft without loss. The best split for a given model can be found cheaply, from about a hundred calibration prompts, and it transfers across benchmarks for that model but not across model families. If this holds, practitioners get a concrete, low-budget recipe for multi-constraint generation that adapts to the model in hand. If it fails, the failure itself settles an open tension in the literature.

What prior work establishes, and what it leaves open

The motivating evidence comes from three places. First, the multi-constraint literature documents how models degrade under dense bundles. Can Large Language Models Understand Real-World Complex Instructions? finds that models keep structural formats while quietly violating numeric and semantic rules. InFoBench decomposes prompts into yes/no requirements and finds that even GPT-4 misses over 10% of them as density rises. Order Matters shows that simply reordering constraints from hardest to easiest swings accuracy by up to 25%. All three study single-pass generation.

Second, the two-stage literature supplies the mechanism we reuse.

  • Let Me Speak Freely? shows that forcing JSON before reasoning collapses GPT-3.5-Turbo's last-letter accuracy from about 56% to 25%, and that a natural-language-then-format pipeline removes this cost. It tests only two-field schemas.
  • Draft-Conditioned Constrained Decoding frames constrained decoding as pulling the model's distribution onto valid outputs. It shows that drafting first lifts a 1B model's structured GSM8K accuracy from 15.2% to 39.0%.

Both treat the constraint as a single syntactic schema. Neither asks how to split a heterogeneous bundle across stages.

Third, the scale and model-specificity literatures constrain the design.

  • The Prompt Complexity Penalty in Small Language Models finds that elaborate instructions and reasoning scaffolds hurt sub-10B models.
  • CRUXEval shows chain-of-thought helping GPT-4 but hurting smaller Code Llama models.

These results sit in direct tension with the draft-conditioned decoding result that drafting helps 1B models. We think the tension resolves once one asks what the draft is asked to satisfy. A draft burdened with every rule is exactly the "complex prompt" small models choke on. A draft asked only for content is not.

PromISe and When Does LLM Orchestration Pay Off? show that optimal prompts and workflows barely overlap across model families. The orchestration study also shows that a workflow helping one backbone can harm another. This is why we expect the split to be model-specific. It is also why our search budget must be far smaller than PromISe's search over 15% of a dataset.

The closest existing system is Divide-Verify-Refine. It decomposes the instruction, checks a full output with external tools, and refines with retrieved examples. That design avoids the "feedback hallucination" of self-critique, and we adopt its tool-based checking. DVR still asks the first pass to satisfy every constraint and then repairs violations after the fact. We instead decide which constraints the first pass never sees, and we treat that decision as the object of study.

Core Claim

We group constraints into five classes, following the InFoBench and TRACE categories:

  • content and semantic coverage,
  • style and persona,
  • structural format,
  • lexical rules (required or banned words, characters, punctuation),
  • quantitative rules (word, sentence and paragraph counts).

A routing assigns each class to the draft stage, the rewrite stage, or both. In the rewrite stage, the model rewrites its own draft conditioned on the deferred constraints. Every constraint that can be checked by a script is verified there, with retries. Format is additionally enforced by draft-conditioned constrained decoding.

We make three predictions. First, the routing that maximizes satisfaction shifts with scale: more classes move to the rewrite stage as models shrink. Second, a routing chosen per model on a small calibration set beats every fixed routing, including the two extremes of "everything in the draft" (single pass) and "everything in both stages" (DVR-like). Third, routings transfer poorly across model families even at matched size.

Research Program

The first piece of work is an instrumented pipeline. Stage one receives the original request with the deferred classes removed and paraphrased out. Stage two receives the draft, the deferred constraints, and a short instruction to preserve content. For the checkable constraints (IFEval-style length, keyword, format and punctuation rules), a deterministic checker reruns stage two up to a fixed budget, and failures are fed back as concrete error messages. Constraint classes that cannot be checked by script, such as style and tone, are left to the model, and we report them separately because they are where feedback hallucination bites.

The second piece is the routing study. There are 32 draft-only/rewrite-only assignments of the five classes plus a "both" setting per class. We evaluate all 32 pure assignments exhaustively on calibration prompts and use greedy search for the "both" extensions.

The study covers two scale ladders with shared training recipes:

  • Qwen2.5 at 0.5B, 1.5B, 3B, 7B, 14B, 32B and 72B,
  • Llama at 3.2-1B, 3.2-3B, 3.1-8B and 3.1-70B,
  • Mistral-7B as a third family at matched size.

Sweeping size within a family and varying family at fixed size lets us separate scale effects from family effects.

The third piece is analysis. We will fit, per family, the fraction of classes routed to the rewrite stage as a function of log parameter count. We will measure where in the pipeline errors arise, that is, whether violations originate in draft content or in rewriting. We will test whether the rewrite stage damages content: a draft can be correct and the rewrite can still drop facts, which is the error-propagation risk the two-stage literature flags. As a secondary question, we will also cross drafters and rewriters across sizes and families, with a large drafter feeding a small rewriter and the reverse. This tests whether a mismatch between the drafter's and rewriter's natural phrasing degrades compliance, as In Their Own Words would suggest for traces outside a model's own distribution.

Baselines

The naive reference point is single-pass generation with the benchmark's own prompt. Its strongest single-pass variant applies Hard-to-Easy constraint ordering from Order Matters. Ordering is free and well documented, so any pipeline that cannot beat it at a fraction of the cost is not worth deploying.

The strongest prompt-only competitor is an optimized single call. We give a reflective prompt-search loop, in the spirit of the GEPA optimization used in When Does LLM Orchestration Pay Off?, exactly the same calibration prompts and the same number of model calls our routing search consumes. That study found optimized single calls leave multi-step workflows under 5 points of headroom, so this baseline is a real test.

The strongest existing multi-constraint pipeline is Divide-Verify-Refine. We reimplement it with the same tool checkers and the same retry budget, and we match total generated tokens per prompt. The file reports DVR tripling Mistral-7B and doubling Llama-3.1-8B on hard ComplexInstruct tasks, but it gives no absolute number for DVR on ComplexInstruct. We will therefore report our reproduction against those relative gains.

We add best-of-N sampling with the same script checkers, selecting the output that passes the most checks, with N chosen to match our token budget.

For absolute reference points, the file gives the following:

Two ablations isolate the key ingredient. The first is the pipeline with a fixed universal routing chosen on a single model. The second is the pipeline with every constraint visible in both stages, which matches our architecture but removes the routing decision. Beating these baselines means the calibrated routing improves prompt-level strict IFEval accuracy and ComplexInstruct satisfaction over the best of them at matched tokens, with confidence intervals excluding zero on at least the sub-8B models, and without lowering content quality as judged on InFoBench content questions.

Why not just…?

Why not just fine-tune on multi-constraint data instead? IOPO, ECD and From Complex to Simple all improve compliance through training. Even so, the best 7B result in the file still leaves about 30% of IFEval prompts failing, and these methods require training each model, IOPO at roughly four times SFT memory. Routing is an inference-time choice and complements training rather than competing with it. To show this, we will train a DPO model on TRACE data for one 7B backbone and run the routing study on it too. If the optimal routing collapses to "everything in the draft" after training, that is an honest finding that training absorbs what routing provides.

Why not just optimize a single prompt and reorder constraints? This is the most serious threat. The orchestration study found optimized single calls nearly match multi-step workflows on single-objective tasks, at a quarter of the tokens. The difference in our setting is that surface constraints such as exact counts and banned strings are hard for any single sampled pass because of sub-word tokenization, while a checker in the rewrite stage turns them into a retry loop. The matched-budget optimized-prompt baseline settles this directly. If it wins on large models, we expect that, and the claim narrows to the regime where it loses.

Why not just run Divide-Verify-Refine, which is already multi-stage? DVR is the direct competitor, and our "everything in both stages" ablation is essentially DVR with our rewrite stage. If that ablation matches the calibrated routing at every scale, routing adds nothing beyond verification, and we will report it that way. Our reason to expect otherwise is the prompt complexity penalty: a small model drafting against six constraints writes worse content than one drafting against one. The content-quality measurements will show whether that is the mechanism.

Why not just use constrained decoding? Grammar masking guarantees valid JSON, but it covers only the format class. It also carries a measured cost: draft-conditioned decoding work reports a 14B model falling from 76% to 47% on MATH500 under standard constrained decoding. We use masking only inside the rewrite stage, where the draft already exists.

Proposed Experiments

The main benchmarks are IFEval for checkable constraints, ComplexInstruct for bundles of up to six constraints, TRACE's 1,000 human-verified evaluation prompts for out-of-domain bundles, and InFoBench for style and content requirements scored by DRFR with a GPT-4 judge. We also use PBIF to test whether routing removes order sensitivity: if order effects shrink when surface constraints are deferred, that supports routing as a cure for interference rather than a mere repackaging. Calibration prompts for the routing search come from a held-out slice of ComplexInstruct, so the transfer test on IFEval, TRACE and InFoBench is genuine. We report token counts and wall-clock latency for every method.

Three outcomes are decisive. First, the routing-by-scale interaction should be significant within both the Qwen and Llama ladders, with the rewrite share falling monotonically in log parameter count. A flat or reversed curve falsifies the core claim. Second, the calibrated routing should beat the universal routing and the DVR-like ablation at matched tokens on sub-8B models, with the gap shrinking at 70B. Third, a routing calibrated on Qwen-7B and applied to Llama-8B should lose measurably against Llama's own routing. If cross-family transfer is lossless, the model-specific half of the claim fails and the recipe simplifies to a single size-indexed rule, which is still a useful result to publish.