STRIDE: step-by-step infographic polishing with a checklist, choosing the scale of each fix, and an "accept only improvements" rule

STEP 0: Generate K variants (6 in the paper) → pick the best by checklist = "champion"

REPEAT up to 3 rounds (or until every item passes):
  STEP 1: VERIFIER — check the champion against the checklist → "yes/no" per item + reason
  STEP 2: PERCEPTOR — describe the image by region (what sits where, what text) → map failures to locations
  STEP 3: LEAD EDITOR — read the attempt history → choose: REDRAW or TARGETED FIX → issue instructions
  STEP 4a: COMPOSER (if broken globally) → original prompt + a "fix this" block → 4 new images
  STEP 4b: RETOUCHER (if broken locally) → 4 parallel edits to individual text blocks
  STEP 5: Check all candidates → the champion changes only if the score is STRICTLY higher; on a tie the old one stays
  STEP 6: Log what was tried and what was rejected → next round

In the paper these are separate model calls orchestrated by code.

In the paper STRIDE runs as code. But you can run the framework by hand in a chat with an image generator: ChatGPT with images, Gemini, or Midjourney plus a chat with a vision model. Caveat: image generators are still weakest at small text and exact numbers, so for precise copy you'll need the retoucher (editing a block) or a manual text swap.

Task: An Amazon seller is making an infographic for a travel mug listing. The generator keeps mixing up numbers, dropping icons, or writing "$42.99" instead of "$24.99".

Prompt (the checking step, sent along with the image):

<Role>You are the VERIFIER. You strictly check the image against the checklist.</Role>

<Checklist>
1. The headline "Frost Travel Mug 16 oz" is spelled without errors.
2. The price "$24.99" is shown exactly, with no garbled digits.
3. There are exactly 4 benefit icons: "Hot for 12 hours", "304 Stainless Steel", "Leak-Proof", "16 oz".
4. The captions under the icons match the icons in meaning.
5. Top left — a spot reserved for the logo, and it's empty.
6. The mug fills the right half of the frame and isn't cropped by the edges.
7. The background is light and all text is readable.
</Checklist>

<Task>
For each item output a line: number | YES/NO | reason in one sentence.
At the end — the total: how many YES out of 7.
Don't fix the image and don't give advice.
</Task>

Then take the role of PERCEPTOR: describe the image by region (where each text block sits, exactly what it says, where the icons are) and for each failed item state which region the problem is in.

From there, you play the "lead editor" yourself:

1. If 3+ items failed or the composition is broken, ask the generator to redraw.
2. If one caption failed, fix only that.
3. Accept the new version only if the YES count went up.

Result: The model returns a table of the 7 items with reasons and a total score. Then comes a region-by-region description of the image with failures mapped to locations. Instead of "looks fine," you get a concrete list: what's broken and where. From it, it's easy to put together precise instructions for a redraw or a fix.

The weakness. An image generator doesn't "know" what it got wrong. An overall "pretty good" doesn't tell you what to fix. The fix itself is random too: the next attempt might repair the price and break the icons. Without a selection rule, the system goes in circles.

The strength. A multimodal model is good at answering narrow yes/no questions about an image. It can also describe where things are located. A narrow question is more reliable than "rate this image from 1 to 10." The comparison with human ratings shows it too: the verifier's agreement with human judgment was substantial, though not perfect.

How the method uses this. It splits the work into roles: - Checking answers "what's wrong." - Localization answers "where." - The editor chooses "how to fix it." - The champion rule keeps a regression from eating your progress.

In the experiment, forcibly replacing the leader with the best newcomer did worse than "keep the old one unless the new one is better." Several candidates per round raise the odds of finding an improvement.

Control levers: - Candidates per round (4 in the paper) → better odds of finding something better, but more expensive. - Number of rounds (3 in the paper) → quality rose with every round: 1 → 2 → 3. - Checklist granularity → the more atomic the items, the more precise the diagnosis. - Priority tiers for items (e.g., price and headline matter more than the background) → comparison goes by item importance from the top down. - Confidence in facts → if the model isn't sure about a name, date, or number, it's allowed to search the web.

The roles and the selection rule are preserved. Run the method step by step, across several messages.

<Role>
You are the LEAD EDITOR refining an image. You have four helpers:
VERIFIER, PERCEPTOR, COMPOSER, and RETOUCHER. You decide whom to call.
</Role>

<Task>{image description: what must be in the picture}</Task>

<Checklist>
{atomic items, each a question with a YES/NO answer}
</Checklist>

<State>
Champion: {the current best version or its description}
Champion score: {number of YES out of N}
History: {what was tried, what was rejected, what regressions occurred}
</State>

<ReasoningLogic>
Step 1. VERIFIER: go through every Checklist item → "number | YES/NO | reason".
Step 2. PERCEPTOR: describe the image regions (object placement, verbatim text,
        "attribute–region" links) and map each failure to a region.
Step 3. DECISION:
  - If the failures are global (missing object, wrong composition, several items
    failing at once) → call the COMPOSER.
  - If the failures are local (a typo, a wrong number, one attribute) → call the RETOUCHER.
  Take {History} into account: don't repeat rejected edits, heed the regression warnings.
Step 4a. COMPOSER: keep the original {Task} description verbatim at the start, then add
        a block of imperative instructions "fix only this: …" for the failed items.
        Provide {number_of_candidates} variants of that block.
Step 4b. RETOUCHER: provide {number_of_edits} edits of the form "block N → exact corrected text".
        One edit — one block. Remove duplicates.
Step 5. CHAMPION RULE: after generating the candidates, check them against the Checklist.
        The champion changes ONLY IF a candidate's score is STRICTLY higher.
        On a tie, the previous champion stays.
</ReasoningLogic>

<StopCondition>
Stop when every item passes, or after {number_of_rounds} rounds,
or if two rounds in a row brought no improvement.
</StopCondition>

<OutputFormat>
Output: the check table; the decision (composer/retoucher) with a one-sentence rationale;
the instruction text for the helper; the updated history.
</OutputFormat>

What to fill in: - {image description} — the original prompt for the generator. - {atomic items} — 5–10 yes/no questions, one per requirement. - {number_of_candidates}, {number_of_edits}, {number_of_rounds} — for example 4, 4, 3.

🚀 Quick start — paste into a chat:

Here's an image-refinement template based on the STRIDE method. Adapt it to my task: [your task — what image you need].
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask which requirements must be met (text, numbers, layout, object count) and which of them are critical. That's how it builds a checklist of atomic questions: the whole method rests on it. It will keep the role structure and the champion rule from the template and adapt them to your task.

⚠️ Engineering required: In the paper this is a pipeline with several large models, parallel branches, and a programmatic tool for editing text on the image. In a chat you can reproduce the logic by hand, but without automation it's slow.

⚠️ Quality depends on the checklist: The method works when requirements can be broken into checkable yes/no items. For a subjective "beautiful" or "eye-catching" it barely helps.

⚠️ The verifier makes mistakes: Agreement with human ratings was substantial but not complete. The checking model can itself miss an error or nitpick for no reason, and then the loop chases a false target.

⚠️ Expensive in number of calls: Each round means several candidates and repeated checks of each. For a single image that's a lot of requests.

⚠️ Local edits cover only text and formulas: The retoucher in the paper can change text blocks. Errors in shape, objects, or style are fixed only by a full redraw.

⚠️ Text in other languages: The paper tested on English and Chinese benchmarks. For other languages and scripts, check the effect yourself.

The team took three open image generators and three benchmarks. Two benchmarks cover infographics (BizGenEval and IGenBench: slides, web pages, posters, charts). The third (WISE) covers general knowledge, to check that the method isn't tailored to infographics. They compared against the "bare" generator, other agentic methods, and closed systems, including Nano-Banana-2.0, Seedream-5.0-Pro, and GPT-Image-2.0.

The result: on BizGenEval the overall score with one generator rose from 22–28 to 51.1, and with another by 28.4 points, to 69.5. That's above the closed Nano-Banana-2.0 (68.5) and Seedream-5.0-Pro (65.7). On IGenBench, per-question accuracy rose from 0.72 to 0.84, and whole-image accuracy from 0.17 to 0.38, on par with GPT-Image-2.0. The strongest competing agentic method trailed by 23–26 points.

The most interesting part is the ablations (parts of the system switched off one at a time). Simply "6 attempts, keep the best" raised the score from 28.0 to 34.7. That's far below the full system's 51.1. So it's not about the number of attempts but about the diagnosis and choosing the scale of the fix. The champion strategy gave 51.1, random selection 40.4. Forced replacement with the newcomer without comparison gave 39.4–45.4. Quality grew with rounds: 46.4 → 48.1 → 51.1. Detector models and OCR as the "eyes" lost to a strong multimodal model. Human evaluation confirmed the gain: the verifier and the official evaluators correlated with people at 0.65–0.85.

🔧 Technique: keep the original prompt intact and append a block of fixes → less drift

In the paper the composer doesn't rewrite the prompt; it keeps the original at the start and adds a block of instructions. You can carry this over to any regeneration:

Copy

{original prompt, unchanged}

FIX IN THIS VERSION (leave everything else alone):
— {failure 1, in the imperative}
— {failure 2}

The effect: what already worked breaks less often on the next attempt.

Extrapolation: the champion principle for text. In the paper it's about images, but the logic transfers to editing text drafts (posts, customer emails):

I have a champion text and an 8-item checklist (YES/NO).
1. Check the champion and count the YES answers.
2. Make 3 edit variants that fix only the failed items.
3. Check each one against the checklist.
4. Replace the champion only if a variant has strictly more YES. On a tie, keep the old one.
5. Output what you rejected and why, so it isn't repeated.

• Paper title: STRIDE: Scale-Aware Multi-Agent Evolutionary Refinement for Infographic Generation
• Code: https://github.com/SJTUSAI/Stride
• Authors: Yan Zhou, Yang Yang (School of Artificial Intelligence, Shanghai Jiao Tong University)
• Benchmarks: BizGenEval, IGenBench, WISE
• Generators and agentic methods mentioned: ERNIE-Image, Infographic-V2, Qwen-Image-2512, PaperBanana, AutoFigure, Gen-Searcher, ReflectionFlow, T2I-Copilot