Search Beyond What Can Be Taught: Evolving the Knowledge Boundary in Agentic Visual Generation

Haozhe Wang, Weijia Feng, Jinpeng Yu, Che Liu, Ping Nie, Fangzhen Lin, Jiaming Liu, Ruihua Huang, Jimmy Lin, Wenhu Chen, Cong Wei

Co-training a generator and search-reasoner to dynamically manage the boundary between internal knowledge and external retrieval.

How can we build a visual generation system that dynamically decides when to search for external knowledge versus relying on its internal training?

Visual generators confidently fabricate details for entities or events outside their training data, yet naive search often injects noise that degrades performance on prompts the model already handles. The authors introduce a co-training framework that teaches the generator to internalize stable knowledge while calibrating an agentic reasoner to search only for contextual information that remains outside the generator's capacity. This approach produces monotonic quality gains, allowing smaller models to outperform generic search-augmented systems by respecting a generator-specific knowledge boundary.

Paper Primer

The core mechanism is a two-phase co-training loop: Phase 1 uses online Diffusion-DPO to expand the generator's internal knowledge and build noise-resistance to imperfect search inputs; Phase 2 uses rejection-sampling finetuning to calibrate the reasoner to the generator's new, expanded knowledge boundary. The reasoner acts as a gatekeeper: it identifies knowledge gaps, filters retrieved content to minimize noise, and integrates evidence into the generator's input via natural language citations.

Co-training achieves monotonic performance gains across all difficulty tiers, outperforming both pure generation and blind search.

On the SEARCHGEN-BENCH test set, the co-trained 4B generator and 8B reasoner reached an overall score of 31.8, exceeding the 24.4 baseline and the 31.2 score of a frontier oracle reasoner paired with the same base generator. +7.4 points over the baseline; +3.0 points over the initial SFT-reasoner phase.

The calibrated reasoner successfully learns to abstain from searching when the generator possesses sufficient parametric knowledge.

On the "NoSearch" subset, the co-trained system achieved a score of 56.9, a +7.0 gain over the no-search DPO baseline, demonstrating that the reasoner avoids the "concept corruption" typical of naive search. 7.0 point improvement on prompts where search is detrimental.

Why does "naive" search fail to improve visual generation?

Naive search triggers indiscriminately, injecting stylistic contamination and irrelevant visual noise into the generator's input. Because generators treat all conditioning signals as authoritative, this noise often overrides accurate internal knowledge, a phenomenon the authors call "concept corruption."

What is the "knowledge boundary" and why is it generator-specific?

It is the partition between knowledge a generator can reliably internalize (stable, low-dimensional) and knowledge that must remain contextual (evolving, rare, or compositional). This boundary shifts as the generator improves, meaning a search policy optimized for a weak model will be miscalibrated for a stronger one.

Introduction

We expose the world‑knowledge bottleneck in visual generation and propose a co‑training framework that makes generators search‑aware.

Visual generators produce impressive images, yet they confidently hallucinate facts they have never seen. User requests are unbounded, evolving, and lie deep in the long tail—new characters, recent events, niche cultural symbols—exposing a structural world‑knowledge bottleneck.

The knowledge boundary separates facts a generator has internalized from facts it must retrieve externally.

**Figure 1.** Representative search-augmented generations from SEARCHGEN-20K, spanning all twelve failure categories identified from 20,840 production prompts. SEARCHGEN-20K captures the production-scale diverse user requests that demand the unbounded, evolving, and deeply long-tail world knowledge.

**Figure 3.** Bilingual composition and prompt length distribution of SEARCHGEN-20K. Left: English (58%) and Chinese (42%) proportions. Right: bimodal prompt length distribution – Chinese prompts are concise (mean 89 characters) while English prompts are more elaborate (mean 266 characters), reflecting authentic cross-lingual user behavior rather than translated templates.

**Figure 4.** **SEARCHGEN-20K spans diverse, long-tailed domains.** Treemap of benchmark mass across domain categories (area reflects relative prompt counts). The cross-category severity structure between failure modes and domains is deferred to Appendix A.1 (Figure 10), where uniform severity across all cells rules out the hypothesis that failures concentrate in a few niche categories.

Naïve search—triggering a lookup for every prompt—degrades quality because the retrieved content often contains irrelevant visual detail or stylistic noise that the generator treats as authoritative.

A teach‑then‑search co‑training loop lets the generator absorb what it can while the reasoner learns to request only the missing knowledge.

The shift from static generation to agentic, search‑aware generation is the key to closing the world‑knowledge gap.

The World-Knowledge Bottleneck

Identifying why visual generators stumble on open‑world, long‑tailed prompts.

Visual generators are trained on a fixed corpus, yet user requests draw on an open‑ended, evolving world. This mismatch creates the world‑knowledge bottleneck.

The generator lacks a way to recognise when it does not know enough to render a request faithfully.

To quantify the problem we examined 20,840 prompts from a production text‑to‑image platform, revealing a diverse, long‑tailed demand space.

A large‑scale benchmark that explicitly annotates the visual and textual knowledge gaps each prompt exhibits.

Entity frequency is heavily skewed—93.1 % of entities appear only once—highlighting the long‑tailed nature of world‑knowledge demands.

**Figure 6.** The world-knowledge bottleneck: per-stratum collapse across nine generators. Grouped bars show the nine-component mean on NoSearch vs. Search-Intensive strata. Every generator, open-weight and commercial alike, collapses on the search-intensive subset, confirming the bottleneck is universal. Drop magnitudes range from $-0.1$ (GPT-Image-2) to $-39.1$ (Qwen-Image-2).

Prompts that require external world knowledge—visual references, factual text, or both—form a distinct evaluation slice.

Across the Search‑Intensive stratum, generators lose roughly 40 points compared to their NoSearch performance, exposing the bottleneck.

Naïve search—searching for every nominated gap—often harms performance, especially on prompts the generator already handles, revealing a second problem: the need for a gate‑filter‑integrate protocol.

Current generators fail on long‑tailed requests because they cannot detect unknown knowledge and therefore cannot retrieve the missing information, leading to hallucinations or severe quality drops.

The Co-Training Framework

We teach the generator to internalize knowledge, then align the reasoner to the new knowledge boundary.

Search‑augmented generation is only useful when the generator lacks the required knowledge. To avoid noisy retrieval, we design a mechanism that decides when to search, which modality to use, and how to integrate evidence.

We first expand the generator’s internal knowledge, then align the reasoner to the new boundary, so search is triggered only for truly missing information.

How does co‑training differ from simply fine‑tuning the generator on more data?

Fine‑tuning only expands parameters; it does not give the reasoner a calibrated policy. Co‑training explicitly teaches the reasoner when search is still required after the generator has absorbed new knowledge.

The reasoner runs a three‑stage loop—gate, filter, integrate—to turn raw search results into clean textual prompts that the generator can use without being polluted by visual noise.

Three‑stage agentic search protocol

Is this reasoner just another retrieval‑augmented generation (RAG) system?

No. Standard RAG appends raw retrieved documents directly to the prompt. Our reasoner first decides *whether* to search, then filters out noisy references, and finally rewrites the prompt in natural language, preventing visual shortcuts from corrupting generation.

Compare each gain to $\epsilon$: $k_1$ (0.02 < 0.05) → internalizable; $k_2$ (0.12 > 0.05) → contextual.

$k_3$ (0.03 < 0.05) → internalizable; $k_4$ (0.20 > 0.05) → contextual.

Thus $K_{\text{int}}(\theta)=\{k_1,k_3\}$ and $K_{\text{ctx}}(\theta)=\{k_2,k_4\}$.

The boundary cleanly separates knowledge that the model already knows from what still requires external search, enabling the reasoner to issue queries only for $k_2$ and $k_4$.

**Figure 2.** Two paradigms for visual generation. (Left) Prompt rewriting relies on an LLM to expand the user query into a longer textual prompt, which is then passed directly to the generator. (Right) In contrast, our approach equips an agent with a search tool to retrieve relevant knowledge and visual references from a web corpus; the agent then organizes the retrieved evidence into multimodal context and provides it to the generator.

**Figure 8.** Co-training framework: teach the generator what it can internalize, then calibrate the reasoner to search what it cannot. Given a user prompt, the VLM reasoner identifies knowledge gaps, executes modality-aware search (image or text), filters and integrates results into an enriched final prompt, and routes visual references to the generator. Co-training proceeds in two phases. Phase 1 (top): online DPO samples search-augmented generations and ranks them by generation quality, constructing preference pairs to push its knowledge boundary outward. Phase 2 (bottom): rejection-sampling finetuning recalibrates the reasoner to the strengthened generator, reinforcing trajectories where reasoned search improves output and discarding what causes degradation.

Validation and Results

Co‑training yields monotonic gains and expands the generator’s knowledge boundary.

We evaluate the three‑phase co‑training pipeline on two open‑weight generators—Flux.2‑Klein‑4B and Bagel‑7B—using the Gemini‑3‑Flash judge over a 751‑prompt test suite.

Co‑training yields a monotonic quality rise and the Phase 2 reasoner on Klein‑4B (31.8) slightly exceeds the frontier oracle (31.2) on the same generator.

Table 6 shows Phase 2 achieving 31.8 versus the oracle’s 31.2, confirming that a calibrated reasoner can match costly frontier reasoning.

**Figure 9.** Co-training progression and knowledge boundary shift. (a) Grouped bars show the three co-training stages (Reasoner SFT, Generator DPO, Reasoner RFT) for Set I (easiest), Set II, and Set III (hardest) search-intensive tiers (Klein-4B). All three tiers show monotonic improvement. (b) Cumulative distribution of per-prompt no-search quality scores for base vs. DPO-finetuned generators on the 647-prompt eval set. The DPO curve sits below the base curve, indicating a rightward shift: fewer prompts receive low scores and more receive high scores from parametric knowledge alone. The shaded region represents newly internalized knowledge: concepts that previously required search but now reside in generator parameters. The shift is consistent across both Klein-4B (top) and Bagel-7B (bottom), confirming that DPO expands the knowledge boundary regardless of architecture.

Table 6 details the full progression, including the cross‑check where the generator‑adaptive reasoner paired with the base generator underperforms the co‑trained pair, underscoring generator‑specific policy.

Co‑training improves performance on search‑intensive tasks without regressing on standard prompts.

Related Work

We position our adaptive retrieval approach among prior retrieval‑augmented, selective, and self‑improving visual generation systems.

Visual generators stumble on long‑tailed or evolving prompts because they cannot tell when they already know a concept versus when they must retrieve it; our work introduces a co‑training framework that learns this “knowledge boundary” to trigger search only when needed.

RAG equips a language model with an external memory: when the model is uncertain, it looks up relevant documents and incorporates that information into its generation.

Early works such as RAG and REALM introduced the idea of grounding language models in external documents at inference time. Later systems like Atlas and REPLUG train the retriever and generator jointly, showing that a tightly aligned retrieval distribution yields large quality gains over pipelines with a frozen search component.

Methods that learn a retrieval‑control signal so that search is invoked only when needed. Self‑RAG emits control tokens, FLARE triggers on low confidence, Toolformer learns API‑call policies, CRAG post‑hoc corrects retrieval, and Adaptive‑RAG routes queries to different strategies based on complexity.

Approaches that use LLM planning or external tools to improve compositionality and style but assume the generator already knows the visual concepts. Examples include GenAgent, RPG‑DiffusionMaster, LLM‑grounded Diffusion, IterComp, Instruct‑Imagen, and RationalRewards.

Standard visual generation benchmarks (GenAI‑Bench, T2I‑CompBench, DALL‑Eval, HEIM) test compositionality and aesthetics within known concepts. VLM‑based judges (TIFA, Gecko) provide automated faithfulness scores. SEARCHGEN‑BENCH specifically targets out‑of‑distribution concepts, exposing the knowledge‑absence gap.

Self‑Rewarding Language Models and SPIN illustrate self‑play or self‑evaluation loops that improve a model without external rewards. Our co‑training framework applies the same principle to visual generation: Phase 1 (DPO) teaches the generator from search‑augmented demonstrations, and Phase 2 (RFT) recalibrates the reasoner to the strengthened generator.

Benchmark and Failure Analysis

Appendix details benchmarks, failure analysis, and hardware limits.

This appendix follows the paper’s evidence chain, expanding on benchmark construction, failure analysis, and implementation limits.

Section A.1 describes how the SEARCHGEN‑20K benchmark was built. Two annotators labeled 2 000 failure cases, achieving Cohen’s $\kappa$ > 0.85, then applied the schema to all 10 840 prompts.

From the raw prompts we extracted 31 537 seed entities spanning 22 domains, then synthesized prompts in three stages: template instantiation, LLM rewriting with high temperature, and quality‑controlled filtering.

The benchmark deliberately covers global cultural diversity and is split into train (20 000), validation (128), and test (751) sets, ensuring long‑tail concepts are represented.

Section B.1 expands the failure analysis. “Concept corruption (gating)” occurs when the generator blindly incorporates external references even when its internal knowledge would suffice, degrading fidelity.

“Reference copying” stems from pixel‑level conditioning: the model copies background, lighting, and framing from the reference image because no semantic integration layer tells it which attributes to keep.

The paper shows that shallow surface cues (named entities) are poor proxies for the learned knowledge boundary: many proper nouns lie in the NoSearch stratum, while some high‑gap prompts contain few detectable entities.

In the TextualSearch stratum, both BLIND SEARCH and GENERATOR‑ADAPTIVE SEARCH underperform the no‑search baseline because the hardest prompts require compositional reasoning that neither single‑pass parameters nor single‑pass retrieval can resolve.

Section B.2 reports the Gemini‑3‑Flash VLM judge’s correlation with human ratings (Spearman $\rho$ = 0.87) on 500 prompt–image pairs, confirming its suitability as an automated evaluator.

Agreement is strongest on object‑centric NoSearch prompts and weakest on TextualSearch prompts where fine‑grained layout and glyph accuracy dominate, highlighting a known limitation of VLM judges on dense text.

**Figure 10.** The bottleneck is pervasive: every domain–category combination shows knowledge-driven degradation. Heatmap summarizing cross-category structure between failure modes and domain categories in SEARCHGEN-20K. The uniform severity across all cells rules out the hypothesis that failures concentrate in a few niche categories.

Table 1 summarizes the training workflow: Phase 0 (Reasoner SFT), Phase 1 (Generator DPO), Phase 2 (Reasoner RFT) each run on 8 × H20 GPUs; the VLM Judge serving uses a single H20 GPU. The total training cost is roughly 256 GPU‑hours.

Section E details the hardware stack (NVIDIA H20 GPUs, mixed‑precision training) and serving infrastructure (vLLM for the VLM judge). These specifications bound the reproducibility envelope for future work.

Sections F and G enumerate limitations (e.g., reliance on proprietary VLM judges), release safeguards (license restrictions), third‑party API caveats, and broader societal impact considerations.

Extended Quantitative Results

Full nine‑component evaluation reveals sharp performance drops on knowledge‑intensive prompts.

Table 7 expands the six‑component summary from the main paper with a full nine‑component evaluation across both the NoSearch and Search‑Intensive strata.

**Table 7.** The Search Bottleneck on SEARCHGEN-BENCH – Full Nine-Component Breakdown. Scores on a 0–100 scale (one decimal); higher is better. Every generator drops sharply on the Search-Intensive set, confirming that the bottleneck reflects missing knowledge rather than rendering ability. Knowledge-sensitive components (Checklist, Rubric, Visual Ref.) vary per prompt and measure knowledge presence; knowledge-invariant components (Text Rend., Phys. Plaus., Img. Qual.) measure rendering competence.

Workflow and Implementation Details

Details the end‑to‑end pipeline, evaluation protocol, and training setup.

This appendix spells out the three‑stage reasoner pipeline, the judge evaluation protocol, and the training infrastructure used for the VLM reasoner.

Gate: decide whether to invoke external search based on detected knowledge gaps.

Filter: retrieve candidate references and pick the one that best fills the gap.

Integrate: embed the chosen reference description into an enriched prompt for the generator.

Generator produces an image; a VLM judge scores it against a checklist and rubric.

We illustrate each stage with a concrete request, showing the input contract and the visible output fields.

Prompt: “Photorealistic dusk poster of the Shanghai Tower showing its actual spiral facade and correct height proportions.”

Detected knowledge gap: entity = Shanghai Tower, $severity$ = critical (visual‑identity gap).

Decision: $search\_decision$ = search; query generated with $modality$ = image → “Shanghai Tower full exterior dusk photograph”.

Prompt: “Photorealistic product shot of a blue and white porcelain teapot with bamboo motif on a marble tabletop, shallow depth of field, soft studio lighting.”

No knowledge gaps detected; $severity$ = minimal for all components.

Decision: $search\_decision$ = skip; no query issued.

User request: “Create a photorealistic render of the current Atlanta, GA UV index dashboard, showing both the real‑time UV reading and the daily maximum forecast value.”

Search query issued; three candidates returned (indices 0‑2).

Identified gap: missing city‑specific layout and branding.

Selected $selected\_index$ = 1 (the Atlanta‑specific dashboard).

User request: “Generate a photorealistic image of a polar bear standing in the Sahara Desert, looking confused as it searches for ice, with sand dunes and a single dead acacia tree nearby.”

Reference 1 retrieved: dead acacia tree image (branching silhouette, cracked bark, harsh midday light).

Prompt refinement: embed the tree description (“following Image 1, render the dead acacia tree with the same forked branches, dry cracked bark, and hard midday sunlight”) and match lighting on the polar bear.

Final enriched prompt sent to the generator.

The VLM judge follows a deterministic protocol to turn the enriched prompt and references into a numeric score.

Recover task requirements from the user prompt.

Separate reference images (used only for comparison) from the single image to be scored.

Extract observable evidence: subjects, attributes, scene, style, in‑image text, artifacts.

Compare evidence against references where checklist items depend on them.

Assign half‑point scores for checklist rows, rubric dimensions, and generic quality axes.

Emit scored blocks for reference alignment, checklist, rubric, visual‑reference fidelity, and text‑reference fidelity.

Scores are aggregated into the nine components listed in Table 8, each on a $[0,3]$ scale in $0.5$‑point steps.

**Table 8.** Judge scoring components. Each component is scored on [0, 3]. Components 1–2 are prompt-specific; components 3–8 are fixed generic dimensions scored for every image; component 9 is conditional on whether reference images are provided.

Prompts are split into three difficulty sets (I–III) by ranking their no‑search baseline quality from Nano Banana Pro; Set III contains the hardest third.

The judge achieves Spearman $\rho$ = 0.87 with human ratings on a held‑out set of 500 prompt–image pairs, confirming high fidelity.

All experiments run on NVIDIA H20 (80 GB HBM3) GPUs; training phases are detailed below.

**Table 9.** VLM reasoner SFT hyperparameters (Phase 0 and Phase 2).

The VLM reasoner (Qwen3‑VL‑8B) is fine‑tuned on ~20 k expert‑annotated trajectories (Tasks A/B/C) using ModelScope‑Swift; a 1 % validation split monitors over‑fitting.

**Figure 11.** The end-to-end example’s visual output. The three references the reasoner retrieved and selected (top: scene, costume, likeness) and the image the generator produced from the enriched prompt (bottom), for the Yang Chaoyue request traced in the box above. This is the section’s only image example; it grounds what “retrieved references” and “generation” concretely look like. The per-stage boxes that follow are text-only and use different prompts, each chosen to isolate one stage’s behavior.

Judge Scoring Components

Appendix details the evaluation checklist and the two‑stage DPO training pipeline.

This appendix enumerates the rubric used to verify generated images and documents the two‑stage DPO training pipeline that aligns the visual generator with the VLM judge.

Conclusion

We conclude that co‑training reveals a persistent knowledge boundary and outlines future research.

The central question is not to build a model that knows everything, but to build a system that knows what it does not know. This split creates a generator‑specific knowledge boundary that we discover through co‑training.

Our evidence shows that this self‑awareness emerges from the dynamics of co‑training rather than from sheer model scale.

We resolve the problem by co‑training the generator and reasoner around their shared boundary. Online DPO pushes the generator’s boundary outward while teaching it to use imperfect references safely, and Rejection Finetuning recalibrates the reasoner to search only what the strengthened generator still cannot render.

The monotonic progression from NO SEARCH through BLIND SEARCH to GENERATOR‑ADAPTIVE SEARCH, together with per‑stratum recovery on NoSearch prompts and consistent generator‑specific behavior across two architectures, provides converging evidence that the structural split is an operational design variable.

Our deliberately minimal recipe—one DPO pass, one RFT pass, a 4B generator, and an 8B reasoner—validates the principle at the smallest useful scale, and each further iteration can push the boundary outward and tighten the search policy.

A natural objection is that larger models will absorb more knowledge, making external search unnecessary. However, training data is finite while the world is unbounded; no model, regardless of scale, can internalize post‑cutoff events, ultra‑rare entities, or evolving cultural knowledge. The boundary may shift outward with scale, but it cannot disappear.

Future work includes probing the scaling law of the knowledge boundary—whether it expands uniformly or resists certain categories—predicting the boundary from model internals, and extending the approach to other modalities such as video, 3D, and music generation.

The knowledge boundary also serves as a general tool‑invocation principle. Beyond search, the same gate‑filter‑integrate protocol can be applied to image editing, render‑as‑code, 3D‑asset retrieval, and structural control, each contributing to a broader contextual knowledge set $K_{\text{ctx}}$.

We release the full dataset and corpora: 20,839 prompts, 90,452 reasoning trajectories, 281,925 generated images, and 145,642 archived search sessions that can be replayed without live API access.

Compute and Training Configuration

Broader impact, compute budget, and future directions are detailed.

The appendix first reports the end‑to‑end training compute. Phase 1 consumes 8 GPUs × 24 h wall‑clock, i.e., 192 GPU‑hours, while the RFT phase adds 4 × 8 = 32 GPU‑hours, for a total of roughly 224 GPU‑hours.

**Table 11.** Compute budget overview. Training GPU-hours are approximate.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers