Apply to my task
arXiv:2607.15565 ★ 86 Jul 17, 2026

Prompt Echoing: put your question before AND after the image — the model stops ignoring it

Key result

The paradox: a question placed before an image improves how the model 'sees' the picture — and simultaneously worsens the answer. This isn't random. It's a systemic problem across every vision model tested. Prompt Echoing lets you ask questions about images in a way that gets the model to both look at the picture correctly and hold onto the question by the time it answers. The trick: write the question twice — before the image and after. The first copy steers perception. The second one ends up right next to the answer — where the model actually reads.

01

TL;DR

Prompt Echoing is a technique for image-based prompts: write your question both before and after the image. This fixes a paradox the authors found in every image-capable model they tested: putting the question before the image hurts answer accuracy, even though intuition says the opposite should be true.

The key finding: When you write the question before the image, the model actually does steer its "attention" correctly — the image patches get encoded around the right concepts. But the answer still comes out worse. Why? The image eats up hundreds of tokens. A question written before it ends up far from the point where the answer gets generated — the model barely "reads" it when producing the final tokens. It answers based on the image alone, and often gets it wrong. Better perception gets wasted on poor access.

The fix is elegant: write the question twice — once before the image (steers what the model "sees") and once after (restores proximity between the question and the answer). Both mechanisms fire at once. Even stronger: duplicate the image itself too — [image][question][image][question]. The second image instance gets access to the entire first block plus the question, giving a fuller, integrated understanding of the scene.

Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.

02

Method Blueprint

Approach A — Question Echoing (STIT):
[Question] + [Image] + [Question]
Question before → steers perception of the image
Question after → sits next to the answer, model reads it

Approach B — Image + Question Echoing (SITIT) [better]:
[Image] + [Question] + [Image] + [Question]
First image copy → in-distribution format
Second copy → sees the entire first block + the question right next to it

Both variants are a single request. No separate steps — just message structure.

03

Example Use Case

The task: Max just launched a landing page for his accounting-automation SaaS. He screenshots the hero section and wants an honest breakdown of what's killing conversions.

❌ The usual approach (worse):

What's hurting conversion on this landing page? Are there 
issues with the hero section?

[landing page screenshot]

✅ Prompt Echoing (better):

What's hurting conversion on this landing page? Are there 
issues with the hero section?

[landing page screenshot]

Again: what specifically is hurting conversion on this landing 
page? Break down the hero section point by point.

✅✅ Image + Question Echoing (best):

[landing page screenshot]

What's hurting conversion on this landing page? Are there 
issues with the hero section?

[landing page screenshot]

Again: what specifically is hurting conversion on this landing 
page? Break down the hero section by element — headline, CTA, 
visuals, trust signals.

Result: The model produces a structured breakdown of specific hero-section elements, tied to visible details in the image. The second format works especially well: the question repeats twice with a slight refinement (point by point), which sharpens the focus further. In the standard version (question only before the image), the model often gives generic advice not grounded in the actual image details.

04

Why This Works

The model's weak spot: When generating an answer, a model looks primarily at nearby tokens. In a chat, an image unfolds into hundreds of tokens. If the question is written before it, that question ends up hundreds of positions away from where the answer is generated. The model barely "reads" it there — and answers based on the image in a vacuum.

The model's strong suit: Anything written right before the answer gets read well. That's the core mechanism here — question next to the answer = question gets taken into account. Meanwhile, a question placed before the image genuinely acts as a filter — image patches get encoded in a way that's more relevant to the question. The authors proved this with a logit lens (a tool that reveals which concepts the model "decodes" image patches into, layer by layer).

How Echoing exploits both mechanisms: The first copy of the question captures the steering mechanism ("look here while processing the image"). The second copy captures the read-out mechanism ("the answer gets read from right here"). No single position pulls off both at once. The duplicate does.

Levers you can pull:

Lever Effect
First question broad, second one specific Sharpens the focus of the answer
Second question requests a point-by-point breakdown Structures the output
Upload the image twice (SITIT) Better for complex visual scenes
Both questions identical Baseline version, works reliably
05

Prompt Template

Option A — Question Echoing (simple):

{question about the image}

[upload {image}]

{same question or a refinement}

Option B — Image + Question Echoing (best):

[upload {image}]

{question about the image}

[upload {the same image} again]

{same question or a refinement with details: specify the answer format, what to focus on}

Placeholders: - {image} — a screenshot, photo, diagram, design mockup, chart — any image - {question} — exactly what you need to understand/evaluate/find in the image - {refinement} — you can repeat the question verbatim or add an answer format ("point by point," "briefly," "with examples")

When to duplicate the image: when it's complex — lots of detail, data, a diagram, multiple objects. For a simple photo, Question Echoing alone is enough.


🚀 Quick start — paste into chat:

Here's the Prompt Echoing template. Adapt it to my task: {your task with an image}.
Ask me questions to fill in the fields.

[upload image]

{question about the image}

[upload the same image again]

{same question or a refinement with details}

The LLM will ask what question you want to ask about the image and whether you need a specific answer format — because the second block should refine or sharpen the first one, not just repeat it. It'll take the "question → image → question" pattern and build it around your task.

06

Limitations

⚠️ Only for image-based prompts: This technique doesn't apply to text-only conversations. If there's no image in your prompt, you don't need Echoing.

⚠️ Not for Gemini Deep Research and similar tools: In some models, the "question-first" paradox barely shows up. The authors found one exception — Gemma-3-27B. Echoing still helps a bit there, but the effect is smaller.

⚠️ Uploading two copies isn't convenient in every interface: In the mobile ChatGPT/Claude apps, uploading an image twice in one message can be awkward. In that case, Question Echoing (question before and after a single image) is enough.

⚠️ The paradox is stronger in weaker models: The less capable the model, the more a question-before-image order can break the answer. On stronger models the gap is smaller, but Echoing still improves results.

07

How It Was Studied

Researchers at Carnegie Mellon took five families of open VLMs (Qwen3-VL, Qwen2.5-VL, InternVL3, LLaVA-1.5, Gemma-3) and ran them on three benchmarks — NaturalBench, POPE, and Winoground. The idea was simple: keep the content identical and change only the order. Question before the image, or after — nothing else changes. The difference turned out to be huge: an 8–17 percentage-point accuracy loss from reordering alone.

Next, the team opened up the model's internals. The logit lens tool "reads" what each image patch encodes at every transformer layer. It turned out that putting the question before the image really does change perception — patches start encoding into thematically relevant concepts. The model is literally "looking where it should." But the answer is still wrong. That pointed straight at the mechanism: perceiving the image and reading the question during answer generation are two separate processes, and a question placed far from the end gets lost.

To prove causation (not just correlation), the researchers ran a "knockout" experiment: they blocked the model from directly reading a specific segment while generating the answer, leaving everything else intact. When they blocked access to the question in the question-last setup (SIT), accuracy dropped. When they blocked access to the question in the question-first setup (STI), almost nothing changed — the answer wasn't reading the question anyway. Diagnosis confirmed.

One neat detail: a similar effect was documented in educational psychology 50 years ago — when people are given a question both before and after a passage, comprehension beats either single placement. Same logic — attention priming plus consolidation at answer time.

08

Straight From the Research

The authors describe four prompt structures (S = System, T = Task/Question, I = Image):

STI  — System, Task, Image        (question-first — worse)
SIT  — System, Image, Task        (question-last — better)
STIT — System, Task, Image, Task  (question echoing — even better)
SIT IT — System, Image, Task, Image, Task  (image+question echoing — best)

The numbers (Qwen3-VL-8B, NaturalBench group accuracy):

STI  (question first)          → 0.270
SIT  (question last)           → 0.351  (+0.081)
STIT (question echo)           → ~0.351 (= SIT, closes the gap)
SITIT (image+question echo)    → 0.375 (+0.024 on top of STIT)

On Winoground (the hardest benchmark), Qwen3-VL climbed from 0.223 to 0.410 — a 19-percentage-point gain from reordering alone, with zero changes to the model itself.

09

Adaptations and Extrapolations

💡 Adaptation for data analysis / dashboards

If you regularly send screenshots of analytics, spreadsheets, or financial reports:

Looking at November's metrics — are there any anomalies that 
need attention?

[dashboard screenshot]

Again: what anomalies are visible in these metrics? What 
should I check first?

The first question focuses the model on "anomalies," the second adds prioritization. Result: an answer with concrete numbers pulled from the screenshot, not generic commentary.


💡 Adaptation for UX/design review

When you need to break down a mobile screen, a prototype, or a mockup:

Where could a user get lost in this interface?

[app screen screenshot]

Where could a user get lost in this interface? Break it down 
by element: navigation, buttons, copy, visual hierarchy.

🔧 Technique: different phrasing in the two question copies → deeper analysis

Make the first question broad (what's happening in this photo?) and the second one narrow (what specifically grabs attention in the first split-second?). It works like a zoom: wide view while processing the image, tight focus when forming the answer.


🔧 Technique: second question with an explicit format → structured output

[image]

{question}

[image]

{same question}. Answer in this format:
— Issue 1: [description]
— Issue 2: [description]
— Top priority action: [action]

The format structure pulls double duty: it's both an instruction and an extra anchor sitting right next to the answer.

10

Resources

Title: Ask Twice, Look Twice: Prompt Echoing Resolves the Question-First Paradox in Vision-Language Models

Authors: Rakshanda Hassan Abhinandan, John Galeotti, Deva Ramanan, Gautam Rajendrakumar Gare

Institution: Carnegie Mellon University, USA

Related work mentioned in the paper: - Logit Lens — a tool for interpreting transformer hidden states - "Lost in the Middle" — the phenomenon of models ignoring text buried in the middle of a context - Adjunct Questions from educational psychology (roots go back to the 1970s) - LLaVA, Qwen2.5-VL, InternVL3, Gemma-3 — the models tested

Research digest

Key result

The paradox: a question placed before an image improves how the model 'sees' the picture — and simultaneously worsens the answer. This isn't random. It's a systemic problem across every vision model tested. Prompt Echoing lets you ask questions about images in a way that gets the model to both look at the picture correctly and hold onto the question by the time it answers. The trick: write the question twice — before the image and after. The first copy steers perception. The second one ends up right next to the answer — where the model actually reads.

Principle

Why does the question get lost? An image in the prompt unfolds into hundreds of tokens. A question written before it ends up hundreds of positions away from where the answer gets generated. When answering, the model mainly reads what's nearby. Picture a student: you give him a task, then hand him a 500-page report, and only afterward ask him to answer. By that point he's forgotten the task. And yet the question before the image really does work as a filter — it shapes how the model encodes different regions of the image. Without the first copy, perceptual focus is lost. Without the second, access at answer time is lost. The echo pulls both levers at once.

Why it works

The authors proved this using the logit lens — a tool that shows which concepts the model 'decodes' image regions into at each processing layer. A question placed before the image genuinely changes what the model 'sees' in the picture: regions start getting encoded in terms tied to the question. But that effect doesn't carry through to answer generation — only what's nearby makes it there. Echoing solves this head-on: the first copy steers perception, the second steers reading at generation time. Neither position alone can do both. That's why either variant on its own falls short — you need the duplicate.

When to apply

Any request involving an image — breaking down a UI from a screenshot, analyzing a diagram or chart, evaluating a design, diagnosing from a photo, reading a table. Especially when you need a specific, detail-grounded answer rather than generic advice. The more complex the image and the more objects it contains, the stronger the effect from duplicating the image itself. NOT needed for text-only prompts without images. On very powerful models the difference is smaller, but Echoing still improves the answer.

Mini recipe

1. Write the question before the image: a general statement of what to find, assess, or understand in the picture. 2. Upload the image. 3. Repeat the question afterward: word-for-word or with an added format hint — 'as a bulleted list,' 'briefly,' 'with examples from what you see.' 4. For complex images — upload the picture twice: `[image] → [question] → [same image] → [follow-up question]`. The second instance of the image sees everything from the first copy plus the nearby question — and delivers a full scene breakdown.

Examples

[BAD]: `[landing page screenshot] What's hurting conversion on the first screen?` [GOOD]: `What's hurting conversion on the first screen? Look at the headline, the call to action, and the trust block. [landing page screenshot] One more time: break down the first screen point by point — headline, call to action, visuals, trust signals. What exactly is killing conversion?`

In plain words

Multimodal models like GPT-4o or Claude don't work the way our brain does: they don't "see" an image as a whole, they turn it into an endless sheet of hundreds or thousands of tokens. When you ask a question and then toss in an image, your request ends up buried under that avalanche of data. From the model's point of view, it's like someone whispered something to it and then dumped a ton of bricks on top — by the time it's supposed to open its mouth and answer, it's basically forgotten what the question even was. That's the question-first paradox: the earlier you ask, the worse the result, even though logic says it should be the opposite.

It's like walking into a doctor's office, yelling from the doorway, "Doc, why does my side hurt?", and then silently dumping five hundred pages of ten years' worth of lab results on the desk. By the time the poor doctor finishes reading, he's forgotten what you were even complaining about and just starts rattling off your blood counts. Technically he's working with the data, but in practice he's spouting nonsense, because his attention has shifted to the last pages he read, not to your actual problem.

The fix is almost laughably simple, and it's called Prompt Echoing — you literally repeat your question twice, like an echo: once before the image and once right after it. First you set the context, then you feed in the visual data, and finally you duplicate the task so it's the last thing the model "saw" right before it starts generating an answer. Researchers tested this across all the top models, and the result was consistent everywhere: repeating the question at the end sharply boosts accuracy, because the model stops hallucinating and stops reasoning off an "image in a vacuum."

This principle applies universally to any content that eats up a lot of the model's memory. Doesn't matter if you're analyzing a landing page screenshot, a massive Excel spreadsheet, or a long PDF — if you only ask once at the beginning, the model will probably fumble the details. The "echo" method guarantees the key instruction sits in the nearest tokens, so the AI doesn't have to frantically dig through its memory trying to recall why it was made to read all this in the first place.

Bottom line: skip the polite, lengthy intros — just copy-paste your question to the end of the prompt. It's the cheapest, fastest way to squeeze a real, substantive analysis out of the model instead of a generic brush-off. If your question isn't the last thing in line, you might as well not have asked it at all. Asking twice is the only reliable way to make the model actually look at the image through your eyes, instead of just listing off what's drawn on it.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Prompt Echoing: put your question before AND after the image — the model stops ignoring it arXiv:2607.15565

Sign in to apply this study New accounts get 50 free credits.