GenRouter: Unified Workflow Routing for Agentic Image Generation

AI summary

Overview

Research area: Computer vision, specifically agentic text-to-image (T2I) generation and workflow/model routing for multimodal systems.

Technical level: Advanced. The paper assumes familiarity with diffusion/flow-based image generators, LLM-based agent pipelines, multi-objective optimization (Pareto dominance), and retrieval/memory-based routing.

One-sentence scope: The paper proposes GenCanvas, a standardized library of agentic image-generation primitives and workflow templates, plus GenRouter, a self-evolving router that assigns each prompt and image generator to an optimal workflow to trade off visual quality against cost and latency.

What This Paper Is About

Modern agentic image generation systems each build their own fixed pipeline — one always searches the web, another always reasons step by step, another always verifies and repairs — and then run every prompt through that same heavy pipeline. The authors argue this causes two problems: fragmentation (capabilities are siloed and hard to combine) and compute-mismatch (a trivially simple prompt is forced through expensive retrieval, reasoning, and iterative refinement). The goal is to build one unified space of workflows and a router that sends each heterogeneous prompt to the workflow (and generator) that is actually worth its cost.

Key Contributions

1. GenCanvas, a standardized workflow space. The authors deconstruct agentic image generation into eight foundational primitives — rewrite, decompose, search, reason, skill, verify, refine, sketch — and compose them into 9 reliable workflow templates organized into four cognitive levels: Semantic Alignment, External Grounding, Structural Reasoning, and Iterative Refinement. Existing frameworks (e.g., GEMS, GenClaw, Mind-Brush, SCOPE, Gen-Searcher, Self-CoT, BeautifulPrompt) are mapped onto this taxonomy for conceptual alignment.

2. GenRouter, a self-evolving workflow router. Operating over the joint plan space of workflow template and generator (p = (w, g)), the router combines (i) demand profiling, (ii) memory-guided matching, and (iii) Pareto filtering to select a Pareto-optimal plan per prompt.

3. A dual-memory experience system. Trajectory memory logs instance-level execution records and retrieves the top-k most similar historical prompts that used the exact same plan; route memory periodically distills those records into bucket-level statistics over coarse task categories, providing priors when exact matches are sparse. A confidence parameter weights the two.

4. Empirical validation and an open codebase. Experiments across mainstream and downstream benchmarks show large cost and latency reductions at competitive or better visual quality, plus self-evolution and zero-shot generalization results. GenCanvas is released as an extensible codebase with plug-and-play primitive and generator substitution, out-of-the-box evaluation suites, and native tracking of latency and token consumption.

Main Findings

• Large cost and latency savings at top performance. On the average across five benchmarks (Tables 2 and 3), GenCanvas + GenRouter with the Qwen-Image backend reaches the highest overall performance reported in the average column (71.3%) while reducing execution cost by over 95% ($2.97 vs. $59.70) and latency by 65% (4.68 h vs. 13.62 h) compared to GEMS. The abstract and introduction state the same headline figures: over 95% cost reduction and 65% latency reduction versus heavyweight static pipelines.

• Pareto-optimal routing on a mixed test set. On a 500-prompt mixed test set sampled from nine mainstream and downstream benchmarks, HybridGen and VerifyGen applied uniformly achieve high performance (73.53 and 73.11) but at exorbitant cost ($6.27 and $5.68) and significant latency (8.78 h and 6.94 h). GenRouter matches top-tier performance (73.52) with average cost of only $1.37 and latency of 1.76 h.

• Routing distributions track benchmark character. On the aesthetics-focused DPG-Bench, routing is dominated by lightweight templates — RewriteGen at 68.83% and SkillGen at 21.03% — with minimal heavy verification. Prompts from OneIG-EN and OneIG-CN, which feature complex spatial and logical constraints, trigger more structurally demanding templates, notably HybridGen (18.93% and 10.61%) and ReasonGen (28.48% for OneIG-CN).

• Self-evolution improves all metrics. After sequentially accumulating routing experience from up to three distinct benchmarks (OneIG-EN, OneIG-CN, LongText-CN), performance on the unseen mixed set improves from 73.5 to 75.2, while cost and latency drop by 8.7% and 7.9% respectively.

• Zero-shot domain transfer. Transferring prior experience distilled from WISE to DPG-Bench, a frozen GenRouter achieves an 87.1 performance score, beating a standard LLM-as-Router (86.4) while halving execution cost ($1.51 vs. $2.40). Allowing updatable experience during target evaluation raises performance to 87.7 and reduces cost to $1.34.

• Qualitative per-prompt savings. The paper reports a piano case study where GenRouter costs $0.18 versus $0.74 for the static pipeline, and states that static pipelines either fail on complex spatial constraints due to insufficient reasoning or over-complicate simple queries.

• Backend consistency. Gains are reported with both Qwen-Image (Qwen-Image-2512) and Z-Image (Z-Image-Turbo) backends and an additional merged variant; for example, on GenEval2 GenRouter reaches 71.6 with Qwen-Image and 67.5 with the merged configuration, versus 70.4 (GEMS) and 63.5 (GEMS) respectively, at far lower cost.

Methodology in Plain English

The authors first take the generative process apart. Instead of shipping another bespoke pipeline, they define eight reusable "primitives" — things like rewriting a prompt, decomposing it into entities and constraints, searching for external facts or visual references, reasoning about implicit visual implications, invoking a domain skill, verifying an output against a checklist, refining it, and compiling spatial intents into executable layout code (SVG, HTML/CSS, or Three.js). Stringing these primitives together in reliable patterns yields 9 templates, from a trivial DirectGen that just calls the generator up to HybridGen, which searches/sketches and then loops generation, verification, and refinement.

A plan is a pair: a template plus a terminal image generator. To pick a plan for a prompt, GenRouter does three things in sequence. First, demand profiling: a lightweight LLM (Qwen3.5-4B) is used strictly as a profiler, not as a decision-maker, to score the prompt on seven intent axes — semantic articulation, factual grounding, visual referencing, logical deduction, compositional heuristics, evaluative critique, and spatial layout — each on a 0–5 scale, with 3 or more counting as "high need." These scores prune the candidate set via capability compatibility (a template requiring visual conditioning is invalid for a generator that lacks it) and signature gating (e.g., HybridGen activates only if at least two of the six non-semantic axes score ≥ 3). Second, memory-guided matching: the system looks up similar past prompts and past plan outcomes, blending instance-level trajectory memory with bucketed route memory using a confidence weight that grows with the number of matching records; with no memory at all (cold start), it falls back to a deterministic threshold prior from the signature. Third, Pareto filtering: estimates of quality, cost, and latency are used to discard plans that are no worse on every dimension and strictly better on at least one, and the highest-utility survivor wins. Because every execution is logged and periodically distilled, the router refines itself over time without manual retraining.

Experiments unify the underlying LLM/MLLM engines across baselines and isolate generator-specific inference latency so comparisons are fair. The profiler is Qwen3.5-4B; general linguistic and visual primitives use Kimi K2.5 (following GEMS); external grounding uses Serper Search; the utility trade-off coefficients are λc = 5.0 and λl = 0.0006.

Why This Matters

Impact on research. The paper reframes agentic image generation as a routing problem over a shared abstraction rather than a race to build ever-larger fixed pipelines. GenCanvas gives the community a common vocabulary in which prior systems become specific instantiations of |P| = 1, and GenRouter demonstrates that experience-based routing — previously applied almost exclusively at the model level for language models — extends to the joint space of workflows and multimodal generators. The reported self-evolution and zero-shot transfer results suggest routing priors can be task-agnostic.

Real-world applications:

• Consumer and creative image tools, where a large fraction of prompts are simple and should not pay for retrieval, reasoning, and multi-round verification.
• Cost-sensitive API products, where per-prompt spend matters and routing directly controls token and API consumption.
• Text rendering and layout-critical design work, where SkillGen/SketchGen-style templates are invoked selectively for prompts that need them.
• Long-tail or knowledge-heavy requests (real-world entities, factual grounding), where SearchGen/RefGen templates can be activated only when the profile indicates a factual gap.

Industry relevance. The headline economics are the selling point: over 95% cost reduction and 65% latency reduction versus a heavyweight baseline in the reported average, while still attaining the highest average performance in the comparison. The framework's plug-and-play design — swapping base models for individual primitives and terminal generators — maps directly onto production stacks that already mix multiple generative backends.

Future Directions

• Broadening the plan space. Auxiliary primitive backends (search engines, verifiers) are deliberately held fixed under a given routing configuration; the paper does not report routing over them, leaving joint selection of tools and models as an open direction.
• Extending the primitive and template library. The paper explicitly positions GenCanvas as modular and extensible, with support for integrating new primitives and customized workflows.
• Scaling the experience memory. The dual-memory design mitigates sparsity through bucket-level aggregation, but the paper does not report how routing quality behaves as memory grows or as task distributions drift further from any seen bucket.
• Validating the reported gains more broadly. The paper notes additional ablations (bounded workflow space, individual routing components, dual-memory mechanism, utility sensitivity) and qualitative case studies in the appendix; independent reproduction across other generators and prompt distributions is not reported.

Target Audience

Researchers and engineers working on agentic generation systems, LLM-based orchestration, and inference-cost optimization will get the most from this paper. It is also relevant to practitioners who deploy text-to-image models at scale and care about per-prompt cost and latency, and to readers interested in experience-based routing and multi-objective (Pareto) selection. Readers without background in agent pipelines or multi-objective optimization will find the terminology dense, though the core intuition — match the effort to the request — is straightforward.

Authors’ abstract

The rapid evolution of text-to-image (T2I) generation models has effectively solved the foundational challenge of raw pixel synthesis, shifting the community's focus toward fulfilling increasingly intricate user requests. While recent agentic image generation workflows enhance static inference with advanced capabilities like external knowledge retrieval and iterative reasoning, they mostly operate in isolated silos with fixed ``one-size-fits-all" topologies. This inevitably leads to severe compute-mismatch, where simple queries are forced through computationally heavy pipelines. To bridge this gap, we present GenRouter, the first unified workflow routing framework for agentic image generation. We first formulate GenCanvas, standardizing diverse agentic pipelines into a universal set of foundational primitives and executable templates. Operating over this unified space, GenRouter adaptively routes heterogeneous prompts to their optimal workflows via (i) demand profiling, (ii) experience matching, and (iii) Pareto filtering. Extensive experiments across diverse benchmarks demonstrate that GenRouter achieves superior visual alignment while reducing execution costs by over 95% and latency by 65% compared to heavyweight static pipelines. Furthermore, the system continuously self-evolves via accumulated experience, enabling robust zero-shot generalization that boosts performance and halves computational overhead.