Qwen-Image-Agent wraps a text-to-image model in a planner that asks “what’s missing from this prompt?” then fills the gap via reasoning, web search, memory, and a verifier-style feedback loop. On the authors’ own IA-Bench, it lifts the underlying renderer’s score from 17.4 to 45.4.
You’ve shipped a product that turns customer prompts into marketing images. A user types “make a poster showing today’s top three trending stocks.” Your image model doesn’t know today’s prices, can’t count reliably, and won’t ask. It just renders something plausible-looking and wrong. The dominant fix in the T2I world has been to bolt on one capability at a time: a planner here (PhotoAgent), a web search there (GenSearcher), a reasoning step (MindBrush). This paper argues those are all symptoms of one disease, a mismatch between what the user typed and what the generator actually needs, and proposes a single framework that handles all of them.
The core move is to stop treating the user prompt as the generation condition. Instead, treat it as partial context and build the rest before rendering. The authors call the missing piece the Context Gap, and the pipeline has two halves.
First, Context-Aware Planning runs at three levels. Information-level planning reads the prompt and writes out explicit questions like “what does the user mean by ‘recent’?” or “what does this character look like?” Each question is routed to a grounding strategy. Content-level planning then assembles the answers into a detailed prompt covering subject, attributes, layout, style, and text. Generation-level planning handles multi-image and multi-turn cases, trimming irrelevant history so the context doesn’t blow up.
Second, Context Grounding answers those questions from four sources: reasoning via a VLM for implicit intent, web and image search for facts and visual references, memory for prior turns and user profile, and a feedback loop that checks the rendered image against a generated checklist and retries up to three times.
questions = plan_info(user_prompt) # what's missing?
ctx = {}
for q in questions:
route = decide(q) # reason | search | memory
ctx[q] = ground(q, route)
prompt = plan_content(user_prompt, ctx) # rewrite into full spec
for _ in range(3):
img = render(prompt)
misses = check_against_checklist(img, prompt)
if not misses: break
prompt = revise(prompt, misses) # feedback loop
The whole thing is training-free. It uses GPT-5.5-0424 as the planning brain and Qwen-Image-2.0 as the renderer.
The prevailing approach in T2I research is to push the renderer harder: bigger models, better instruction following, more knowledge baked into weights. This paper shows the opposite. The bottleneck for real-world requests isn’t rendering quality, it’s the missing context the user never typed, and that’s a planning and retrieval problem, not a generation problem. The cleanest evidence is the ablation where swapping the planner LLM hurts every dimension more than swapping the renderer does on most tasks.
The load-bearing result is the ablation table. Removing the reasoning context drops Plan pass-rate from 45.3% to 24.7% and Reason from 43.7% to 29.7%, because implicit constraints like “how many objects” get resolved during reasoning. Removing search collapses the Search dimension from 46.1% to 7.8%. Removing memory zeroes out the Memory dimension. Each grounded context is doing the specific work the framework claims.
•
On IA-Bench, Qwen-Image-Agent scores 45.4 IA-score, ahead of Nano Banana Pro at 42.6 and GPT-Image-1.5 at 35.7. The base renderer alone scores 17.4.
•
On WISE-Verified, it hits 0.902 overall, beating the prior best Nano Banana Pro at 0.876.
•
On MindBench, it reaches 0.42 overall, tying or exceeding Nano Banana Pro at 0.41, and improves over its own renderer baseline by 82.6%.
•
Swapping the planner LLM to a weaker pair drops the IA-score from 45.4 to 27.8, a bigger hit than swapping the image backbone (45.4 to 28.3).
Reach for this design when you’re shipping any agent that produces a high-cost artifact from an underspecified user request, image generation, slide creation, document drafting, where the user routinely omits facts the generator can’t infer. The pattern is: enumerate explicit “missing info” questions before generating, route each to reason/search/memory, then assemble a fully-specified prompt. The feedback-checklist loop is cheap to copy: have a VLM write a checklist from the assembled prompt, score the output, retry on misses.
The paper contributes IA-Bench, with 730 instances across Plan, Reason, Search, Memory and 1801 checklist items, which is directly useful if you’re evaluating an image agent rather than a raw T2I model. The paper doesn’t link a code or benchmark release in the text provided, so availability of the bench and framework code isn’t stated here.
For underspecified user requests, the win comes from constructing the missing context before generation, not from a stronger generator. A weaker renderer with a strong planner often beats the reverse, because most real-world failures happen before the first pixel.
•
The framework leans heavily on a strong planner LLM. Substituting a weaker model collapses search and memory performance, so this isn’t a free wrapper, it’s a frontier-LLM tax on every generation.
•
Latency and cost are substantially worse than one-shot generation, since each request may trigger planning, multiple searches, reasoning, generation, and up to three feedback retries. The authors flag this as an open problem.
•
The feedback loop’s contribution is the smallest of the four grounding sources in the ablation. The authors attribute this to using a generic VLM checklist rather than task-specific reward signals, so domains without good automatic verifiers may see even less benefit.
•
IA-Bench is built by the same authors who built the system, and they tune image-search policies to their renderer’s IP weaknesses. Cross-team replication on neutral benchmarks would strengthen the case.