Text-to-image models do well on short descriptive prompts and fail on dense ones. A prompt like "five labeled boxes, the red one left of the two blue ones, the arrow touching both, the legend not overlapping anything" usually comes back with some constraints silently dropped. The current fix is reasoning-guided generation. A language model first writes a plan, such as object coordinates, a layout, or a code sketch, and an image generator then renders the picture from that plan. This helps, but planning many interacting spatial constraints at once is not a language task. It is a packing problem. Each object wants some region of the canvas, some objects are worth more placed together, and no two objects can occupy the same space. That is the structure of a combinatorial auction, a market where bidders bid on bundles of items. Choosing the best set of non-conflicting bids, called winner determination, is NP-hard in general.
This note proposes treating the planning step of reasoning-guided image generation as a winner-determination problem. The language model proposes bundle "bids": alternative placements for each object, plus joint placements for objects whose constraints couple them. An exact integer-programming solver then selects the consistent layout that satisfies the most weighted constraint value. The proposal also borrows the auction field's way of generating test instances with controlled structure. That lets us check a sharper claim than "solvers help". If dense-prompt failures are computational, single-pass language-model plans should fall behind exact solving on instance classes that are hard to pack, and keep up on classes where greedy packing is near-optimal.
Core Claim
Planning failures in reasoning-guided generation on dense compositional prompts are largely failures of combinatorial search, not of language understanding. We expect two consequences. First, the gap between a language-model planner and an exact winner-determination solver should grow with how entangled the constraints are, as measured by the overlap structure of their bundles, and not with prompt length alone. Second, replacing the planner's final layout choice with exact winner determination over planner-proposed bids should raise constraint satisfaction in the final image, with the gain concentrated on the entangled classes.
Prior work motivates the claim. WISE and GIR-Bench document an "understanding-generation gap": models comprehend a prompt yet fail to realize it visually. FLUX-Reason-6M & PRISM-Bench reports that across 19 models the text-rendering and long-instruction tracks score lowest. Those benchmarks show where models fail; they do not say why. The auction literature supplies a candidate reason. Truthful pricing stays NP-hard even when allocation is approximated greedily (Fotakis et al.), and optimal parameter search for combinatorial auctions is NP-hard (Likhodedov et al.). Together these results say the underlying allocation problem should not be expected to yield to a single forward pass. We use only the allocation half of that machinery; incentives play no role here because the "bidders" are prompt constraints, not strategic agents.
Research Program
The first artifact is a layout benchmark built on combinatorial-auction instance generators. The Combinatorial Auction Test Suite, used in BundleFlow, includes a "Regions" distribution that models synergies between spatially adjacent items. It also includes an "Arbitrary" distribution with unstructured complementarities. We map items to cells of a coarse canvas grid and bidders to prompt objects. Each sampled bid becomes a natural-language constraint: "the clock occupies the upper band and touches the shelf". The bid value becomes the constraint's stated importance. We add a third class whose bundles are contiguous intervals along one axis. Interval-structured packing is solvable in polynomial time, so this class serves as a control where greedy-style planning should not lose much. Every instance comes with its exact optimum, computed offline. This gives a planning ground truth that the existing vision benchmarks lack.
The second artifact is the planner. A vision-language model reads the prompt and emits, for each object, a small set of exclusive alternative placements (an "XOR bid"), plus joint bids for constraint pairs or triples that only make sense together. The model also emits weights inferred from the prompt's emphasis. A mixed-integer solver then solves
$$\max_{x \in \{0,1\}^{B}} \sum_{b=1}^{B} v_b x_b \quad \text{s.t.} \quad \sum_{b \ni c} x_b \le 1 \;\; \forall c, \qquad \sum_{b \in \mathcal{X}_o} x_b \le 1 \;\; \forall o,$$
where $B$ is the number of proposed bids, $x_b$ indicates that bid $b$ is selected, $v_b$ is its weight, $c$ ranges over canvas cells, and $\mathcal{X}_o$ is the set of alternative bids for object $o$. When a prompt is over-constrained, the solver's choice of which constraints to drop is explicit and auditable. A free-form plan, by contrast, simply forgets them. The solved layout is serialized back into the same textual plan format the renderer already consumes. This keeps the renderer unchanged.
The third component is the renderer. It stays fixed across all planners so that only the plan varies. We use Bagel fine-tuned on FLUX-Reason-6M with generation chain-of-thought supervision, following FLUX-Reason-6M & PRISM-Bench. For structured visuals we also render through executable plotting or SVG code, in the spirit of Factuality Matters and SVGThinker. Code rendering lets us score plans with no rendering noise at all.
Evaluation separates two error sources. Plan satisfaction is checked exactly against the instance's constraints. Image satisfaction is checked by a vision-language judge, following the PRISM-Bench protocol, and by StructScore-style question answering on StructBench. Measuring both lets us say whether a failure happened in the plan or in the transition from plan to pixels.
Baselines
The naive reference point is direct generation with no explicit plan. We run the same Bagel renderer, plus Qwen-Image as the strongest open model on PRISM-Bench. PRISM-Bench reports overall scores of 65.1 for base Bagel and 79.9 for Qwen-Image (FLUX-Reason-6M & PRISM-Bench).
The strongest existing method on our question is planning by free-form generation chain-of-thought. Bagel fine-tuned on FLUX-Reason-6M scores 73.3 overall on PRISM-Bench, an 8.2-point gain from structured reasoning supervision (FLUX-Reason-6M & PRISM-Bench). We found no reported per-track Composition or Long-text score for this model on Lacuna. We therefore re-run it ourselves on those tracks with the same judge. For context, closed systems reach 86.3 (GPT-Image-1). On StructBench the reported ceiling is below 50% accuracy for the best closed models, and test-time reasoning gives open models "nearly 30%" gains on editing (Factuality Matters). No exact per-model StructBench figure was found on Lacuna.
We also include a reinforcement-learned planner in the style of T2I-R1 and GoT-R1. These systems train the planning stage with rewards for spatial and attribute correctness, which makes them the most direct competitor to a solver. We train this planner with the same base model and a decompositional verifiable reward like that of AlphaGRPO. The reward is computed against our exact constraint checker, so the learned planner sees the same signal our solver optimizes.
Fairness controls are as follows. All planners share one vision-language model and one renderer. Each gets an equal planning-token budget and an equal number of renderer calls. Tuning budgets are matched across the reinforcement-learned planner and our bid-generation prompts.
Two ablations isolate the key ingredient. In the first, the language model generates the same bids and then picks the layout itself, either greedily or by chain-of-thought. This separates "good candidate placements" from "exact selection among them". In the second, joint bids are removed and only per-object alternatives remain. This tests whether encoding complementarities as bundles matters.
Beating the strongest baseline means two things. On the entangled CATS-derived classes, plan satisfaction must improve by a margin that exceeds seed variance and survives into image satisfaction. On PRISM-Bench Composition and Long-text, and on StructBench, the system must improve over the re-run chain-of-thought Bagel without losing aesthetic score.
Why not just…?
Why not just scale or reinforcement-train the reasoner instead? This is the real threat. If the reinforcement-learned planner matches the solver on the Arbitrary and Regions classes, the computational-bottleneck claim is wrong for realistic instance sizes, and we will report that outcome. The benchmark is built to settle it. Hardness theory predicts that the learned planner's deficit grows with bundle overlap and object count and stays near zero on the interval-structured control. A flat gap across classes would falsify the claim.
Why not just sample many images and keep the one a vision-language judge likes best? Best-of-N sampling searches in pixel space with a noisy judge, and its cost scales with renderer calls. We give it the same number of renderer calls as our method. We then compare plan satisfaction, which best-of-N cannot directly control, against image satisfaction. If best-of-N matches us only at many times our compute, that is an efficiency result, not a refutation.
Why not just translate the prompt into a generic constraint program, such as weighted MaxSAT, without any auction framing? For the selection step this is close to equivalent, and we concede it. The auction lens contributes two things. The first is the bid representation: exclusive alternatives plus joint bundles that encode complementarities, which the joint-bid ablation tests directly. The second is the instance generators, which give controlled hardness. We include a direct prompt-to-constraint-program baseline. If it matches the bid-based planner, the contribution narrows to the diagnosis and the benchmark, and we will say so.
Decisive Checks
The central experiment plots plan satisfaction against bundle-overlap density for each planner across the three instance classes, at 5 to 30 objects. The proposal stands if three things hold. The free-form and reinforcement-learned planners must track the exact optimum on interval instances and diverge on Regions and Arbitrary instances. Bid-plus-solver must stay near the optimum on all three classes. That plan-level gain must carry into image satisfaction under the fixed renderer.
A second check determines whether the remaining errors live in rendering. The check uses StructBench logic puzzles and tables, where code rendering removes rendering noise. If code-rendered solver plans approach full accuracy while diffusion-rendered ones do not, the residual gap is the understanding-generation transition, not planning.
Finally, on PRISM-Bench Composition and Long-text, we measure how often each system drops a constraint without stating it. The solver should drop fewer, and every dropped constraint should be one it chose to sacrifice explicitly.
References
- WISE: World Knowledge-Informed Semantic Evaluation for Text-to-Image Generation
- GIR-Bench: Versatile Benchmark for Generating Images with Reasoning
- FLUX-Reason-6M & PRISM-Bench: A Million-Scale Text-to-Image Reasoning Dataset and Comprehensive Benchmark
- The Power of Verification for Greedy Mechanism Design
- Methods for Boosting Revenue in Combinatorial Auctions
- BundleFlow: Deep Menus for Combinatorial Auctions by Diffusion-Based Optimization
- Factuality Matters: When Image Generation and Editing Meet Structured Visuals
- SVGThinker: Instruction-Aligned and Reasoning-Driven Text-to-SVG Generation
- T2I-R1: Reinforcing Image Generation with Collaborative Semantic-level and Token-level CoT
- GoT-R1: Unleashing Reasoning Capability of Autoregressive Visual Generation with Reinforcement Learning
- AlphaGRPO: Unlocking Self-Reflective Multimodal Generation in Unified Multimodal Models via Decompositional Verifiable Reward