Stop Asking AI to Draw Boxes: A Better Way to Prove Where an Answer Came From

Picture an expense-report bot that reads a scanned invoice and tells you the total is $482.17. It's correct. Now it draws a box around the vendor's logo and says that's where it found the number. The answer was right. The pointing was nonsense.

That's not a hypothetical. It's a documented failure mode in vision-language models (VLMs, the models that can read both an image and a text prompt together), and it has a name: Attribution Hallucination. A model gives you the right answer and then cites the wrong evidence for it, or evidence that isn't really there. A new paper, "Evidence Attribution in Visual Document Understanding without Coordinates or Region Labels" by Zhuchenyang Liu, Yao Zhang, and Yu Xiao, tracks this failure down to something surprisingly mundane: the way we've been asking models to point.

The part everyone glosses over: answering and citing are different skills

Most document question-answering systems today work like this. You show the model a page (an invoice, a contract, a scanned form), ask a question ("what's the total due?"), and the model gives you an answer plus a bounding box: a set of pixel coordinates marking the rectangle on the page where it supposedly found that answer. This is the coordinate interface, and it's the standard way benchmarks and products have asked models to show their work.

The problem is that reading a document and describing pixel coordinates are two different tasks bolted together. A model can genuinely understand that the total is $482.17 because it correctly parsed the table structure, and still be bad at translating "that number, in that cell" into "x=412, y=88, width=64, height=22." Coordinates are a language VLMs weren't primarily trained to speak. Text is.

The authors put this to the test on CiteVQA, a bilingual (English and Chinese) benchmark built specifically for evidence attribution, using a verified subset so the ground truth about which regions actually support each answer is trustworthy. Across six open VLMs, they found that letting a model draw a box gets you evidence recall (the percentage of questions where the model's cited region actually overlaps the true evidence) of at most 8 out of 100. Not 8 percent below some other method. Eight. Out of a hundred questions, the box is roughly right maybe eight times, even when the model's actual answer to the question is correct far more often.

What they tried instead: make the model quote, then go find the quote

The fix the paper proposes is almost embarrassingly simple to state, though it takes real infrastructure to make work: stop asking the model for coordinates at all.

Instead, the model answers the question and then quotes, verbatim, the piece of text it used as evidence, the way you'd copy-paste a sentence from a PDF into a chat message rather than describing where on the page it sits. That's the "language interface." A separate system then goes and finds that quote in the document. Specifically:

• A layout parser (a tool that segments a page into structural regions such as paragraphs, table cells, headers, and figure captions, the way a person would visually chunk a page into "this is a paragraph, this is a table") first breaks the document into candidate regions.
• A multimodal retriever (a matching system that can compare text against both the text and layout of a page) takes the model's quoted evidence and figures out which of those regions it came from, returning that region as the attributed location.
• Tables and figures, which don't have flowing prose you can quote directly, get handled through their captions or notes, so the quote-and-locate approach still works even outside plain paragraphs.

In effect, the model no longer has to do geometry. It does what it's actually good at: reading and repeating text. A retrieval system, built for exactly this kind of matching, does the geometry instead.

The numbers that make the case

Run across the same six open VLMs on the same CiteVQA subset, the language interface pushed evidence recall from that ceiling of 8 up to somewhere between 26 and 47, depending on the model. That's a jump of roughly three to six times, achieved purely by changing the output format the model is asked to produce, not by retraining it or giving it a better prompt about coordinates.

The hallucination rate (how often the model confidently attributes an answer to evidence that doesn't actually support it) roughly halved under the new interface. And the part that would normally be the catch: answer quality, meaning whether the model gets the actual question right, barely moved. You're not trading correctness for honesty about sourcing. You get most of the honesty back for close to free.

That's the headline finding, and it's worth sitting with for a second, because it reframes what "attribution hallucination" even is. It isn't necessarily a comprehension failure. In a lot of cases it looks more like an output-format failure: the model knew the right passage, and the coordinate interface just didn't give it a good way to say so.

Turning the pipeline into a teacher: GRPO without region labels

Recall in the 26-47 range is a real improvement, but it's not a solved problem. So the authors used the quote-and-retrieve pipeline for a second purpose: as a training scaffold to make the underlying model better at quoting good evidence in the first place.

This is where the paper reaches for GRPO (Group Relative Policy Optimization), a reinforcement-learning method that generates a batch of candidate outputs for the same input, scores each one, and nudges the model toward whichever ones scored best relative to the group. It's the same family of technique that DeepSeek used to train its R1 reasoning model, and it's become a popular way to fine-tune a model on a task where you can define "better" but don't have a large labeled dataset showing exactly what "better" looks like step by step.

The normal way to train an attribution model would be to hire annotators to draw ground-truth bounding boxes on thousands of document pages, marking exactly which region supports which answer. That's expensive and slow, especially for long, multi-page documents where a single answer might depend on evidence buried on page 14.

The paper sidesteps that entirely. Instead of region labels, the reward signal comes from a judge: another model that reads the gold (correct) answer to a question alongside cropped images of whatever regions the retriever pulled up for the trainee model's quoted evidence, and rates how well those crops actually support that answer. No human ever draws a box. The model is rewarded for quoting text that, once located and cropped, visibly backs up the right answer, and penalized when its quotes lead the retriever to irrelevant regions.

Applied to an 8B-parameter backbone model (8 billion parameters, a mid-sized open model by current standards), this training pushed what the paper calls "strict attributed accuracy," meaning the model has to get both the answer and the evidence right, or it doesn't count, from 22.4 up to 33.8. That's roughly a 50% relative improvement on the strictest, least forgiving metric in the paper, using a training signal built entirely from existing tools (a judge model, a layout parser, a retriever) rather than new human-labeled data.

Why it matters for anyone building or buying document AI

If you're building anything on top of OCR or document AI, the operative lesson here isn't "use this specific benchmark." It's that the interface you use to ask a model to justify itself changes how honest it can be, independent of how good the model actually is underneath.

A few concrete takeaways:

• If your product shows users "here's where I found that" on a document, check what interface is generating that citation. A bounding-box output from a general VLM is, per this paper, right at best 8% of the time on unseen documents, even when the stated answer is correct. That gap between "the answer is right" and "the citation is right" is exactly where user trust gets quietly burned, because a wrong highlight next to a right answer looks worse to a user than no highlight at all.
• Quote-then-locate is a pattern you can build today, without waiting for better foundation models. It doesn't require a custom-trained VLM. It requires a layout parser and a retriever wired around whatever model you're already using, since the improvement in this paper came from changing the interface, not the underlying weights, for five of the six models tested.
• Region-level labels are expensive, and this paper shows a path around them. If you're weighing whether to fund an annotation project to improve attribution quality versus building a judge-based reward pipeline, the GRPO result suggests the second route can get real gains (22.4 to 33.8 on strict attributed accuracy) without a single human-drawn box.

What's still unresolved

The paper is careful about scope, and it's worth being equally careful reading it. The gains were measured on CiteVQA, one bilingual benchmark, and while a verified subset is a meaningfully higher bar than an unfiltered one, it's still one dataset. Evidence recall in the 26-47 range is a big jump from 8, but it's also nowhere near saturated: over half the time, across most of the six models, the retrieved region still isn't the right one. And the retrieval step depends on the layout parser doing its job correctly. If a page is scanned at a bad angle, has an unusual layout, or has tables the parser can't segment well, the whole quote-and-locate chain inherits that error, in a way a hypothetical model correctly outputting pixel coordinates on a well-behaved page might not.

There's also a subtler dependency worth flagging: the GRPO training relies on a judge model to grade evidence quality, and judge models have their own blind spots. The paper doesn't claim the judge is a perfect proxy for human agreement, and it's a reasonable thing to press on if you're trying to reproduce this outside a research setting.

None of that undercuts the core finding. The interesting part of this paper isn't the specific accuracy numbers, it's the diagnosis: a chunk of what looked like a reasoning problem in document AI was actually an output-format problem, and reformatting the output moved the needle more than most architectural changes would have.