Vision-language models (VLMs, models that answer questions about images by passing image features to a language model) work well on scenes with a handful of objects and collapse on crowded ones. On scatter plots they count one or two points correctly but fall to near zero at sixteen. In comparisons of near-identical images they spot a missing object almost perfectly with four objects and fail with thirty-two. The standard fix for small details is to zoom: scan a low-resolution copy, pick a region, and re-read that region at full resolution. Zooming has been built for one target at a time, though. Crowded scenes have no single target, and cutting them into a fixed grid splits objects across tile borders, which leads to double counting.
This note proposes treating the dense-scene collapse as a per-pass load limit, meaning a maximum number of objects the model can handle in one look, rather than as a resolution limit. Each model's limit is measured once on synthetic scenes. At test time, the image is split recursively until every crop is estimated to contain fewer objects than that limit. Only then does the model look at each crop at native resolution and point at what it sees. Overlapping crops plus a simple "each object belongs to the crop that contains its center" rule remove double counts without an external segmenter. The pointed objects form an entity list that a separate reasoning step answers questions over. The same experiment that tests the method also answers a question no existing study has isolated: whether zooming helps crowded scenes because objects get more pixels or because the model sees fewer objects at once.
Core Claim
Every existing dense-scene fix changes two things at once. Cropping a region both enlarges each object and removes most other objects from view. The prior systems sit at different corners of this confound. LVLM-COUNT divides images along object-avoiding paths found with GroundingDINO, SAM, clustering, and A* search. It reduces objects per pass but does not magnify. VISER draws three horizontal lines and asks the model to scan row by row. It reduces effective load with no added pixels and degrades past roughly fifty objects. SPARC magnifies one or two evidence regions found in a low-resolution scan, and it is built for sparse targets. VisualOverload reports that feeding 4K images into tiling models does not rescue dense scenes. That result suggests resolution alone is not the binding constraint, but it does not show it.
Our claim is that, once each object exceeds a modest pixel size, accuracy is governed mainly by the number of objects in a single pass, $n$. Each model has a capacity $K^*$, defined as the largest $n$ at which its accuracy stays above a fixed threshold. If this holds, crop sizes should be chosen by estimated object count, not by pixel area or a fixed grid. A recursive split-until-under-capacity procedure should then beat both fixed grids and full-resolution input at matched token cost.
Research Program
The first component is a factorial diagnostic on procedurally generated scenes, in the spirit of the binding-problem generator in VISER and the scatter plots of FUGU. We vary objects per image, $n$, and pixels per object, $p$, independently, holding the rendered image size fixed. Tasks are counting, attribute binding (which color goes with which shape), and extremum finding. We fit accuracy surfaces over $(n, p)$ for open models with native pointing ability (Qwen2.5-VL, Qwen3-VL, InternVL3) and for GPT-4o.
The load hypothesis predicts accuracy contours that become nearly vertical in $n$ once $p$ passes a threshold. The resolution hypothesis predicts contours that track $p$. The fitted surface yields $K^*$ for each model. We also repeat the linear-probe analysis of Tartaglini et al.. They found that the vision encoder holds point coordinates almost perfectly while the language model fails to use them. We test whether that encoder-to-decoder gap shrinks as $n$ falls at fixed $p$, which would place the load limit at the handoff rather than in the encoder.
The second component is the inference procedure, which requires no training. It runs in four steps.
- Coarse count. The model gives a count estimate $\hat c$ for a region. Global passes are known to underestimate in dense scenes (WS-COC), so we split whenever $\hat c > \alpha K^*$ with a safety factor $\alpha < 1$, also fixed on synthetic data.
- Split. A region that is over capacity is divided into four quadrants that overlap by a margin of about one typical object size.
- Point. Leaf crops are read from the original full-resolution image, and the model points at every instance it sees.
- Deduplicate. A point is kept only if it falls in the crop's non-overlapping core. This is the standard ownership rule from tiled detection, and it addresses the "fragmentation trap" that LVLM-COUNT solves with SAM and A* paths.
The recursion is driven by the model's own coarse counts, not by a separately trained density network as in DMNet. Crowded clusters therefore get small crops and empty background gets none. Fixed grids, such as the 2×2 partition in WS-COC, cannot do this.
For non-counting questions, the leaf pass also returns a short attribute string for each pointed entity. A frozen reasoning pass then answers the question from the low-resolution global view plus this entity list. This extends SPARC's split between perception and reasoning from a few boxes to hundreds of entities without flooding the reasoning context with image crops.
Baselines
The naive reference is a single pass of the same base model at its default dynamic-resolution setting on the full image. We also run a token-matched variant that feeds the full image at the highest resolution whose token count equals our method's total. This variant isolates whether we win by spending more tokens.
The strongest training-free competitor is LVLM-COUNT. It is the only published method that both partitions dense scenes and avoids cutting through objects. It reports FSC-147 mean absolute error (MAE) falling from 25.57 to 17.86 with GPT-4o, and Emoji-Count MAE falling from 78.05 to 24.43 with Qwen2-72B. We rerun it with our base models and identical prompts so the comparison isolates the division strategy. We count its GroundingDINO and SAM compute as cost. Beating it means lower MAE on FSC-147 and Emoji-Count with the same base model, at equal or lower wall-clock time, with the largest gains in the over-100-object regime.
The strongest trained competitor is WS-COC, which reports FSC-147 test MAE of 13.91 (down from 38.19 zero-shot) and 54.37 on scenes with more than 100 objects. Because it uses LLaVA-OneVision-7B with count-supervised tuning, we run two comparisons. First, we compare against its reported numbers. Second, we apply our procedure on top of its released model in place of its global-local averaging step. Matching 54.37 on the over-100 subset without training would be a strong result. Improving on it when stacked would show the two approaches are complementary.
For binding and reasoning, the baseline is VISER. It reports 2D synthetic counting accuracy rising from 5.8% to 40.8% for Qwen2.5-VL and from 12.0% to 38.8% for GPT-4o. We run it on our factorial scenes so its reported degradation past fifty objects can be compared directly with ours.
Three ablations isolate the key ingredients. The first is crop-without-magnify: the same recursive crops are downsampled so pixels per object match the global view. If the load claim is right, it should retain most of the gain. The second is a fixed uniform grid with the same ownership rule and the same total number of crops, which tests whether adaptivity matters. The third removes the ownership rule and sums per-crop counts, which shows how much the deduplication contributes.
Why not just…?
Why not just feed the full 4K image to a high-resolution VLM? VisualOverload evaluates exactly this setting on 4K paintings. The best counting accuracy among 37 models is 41.7% (Gemini 2.0 Flash), and o3 reaches 19.6% on the hardest split. Our token-matched full-resolution baseline tests this directly on our benchmarks. If it matches our method, the load claim is wrong and we will report that.
Why not just use a finer uniform grid with overlap and center ownership? This is the real threat, because it inherits our deduplication rule and only drops adaptivity. On roughly uniform scenes it may match us. Our argument is cost: on clustered scenes such as aerial imagery and paintings, a grid fine enough for the densest cluster wastes crops on empty background, which is the inefficiency DMNet documented for classical detectors. The uniform-grid ablation, reported as accuracy versus number of model calls, settles this. If the curves coincide, we will recommend the grid with a capacity-derived tile size. The scientific claim, that tile size should be set by $K^*$, would survive even if the adaptive recursion does not.
Why not just let a reasoning model think longer or zoom on its own? ChartMuseum reports that extended thinking added only 1.4% for Claude-3.7-Sonnet on visual-heavy questions. SPARC reports that interleaved "thinking with images" is beaten by 4.6 points on XLRS at a 200× smaller token budget. We include a long-reasoning run on VisualOverload as a check, but the cited evidence suggests it will not close the gap.
Why not just draw scaffold lines, as VISER does? Lines lower load without adding pixels, and VLM-SubtleBench found that pixel-level visual tricks such as concatenation and difference overlays can hurt accuracy. Our crop-without-magnify ablation is effectively a cleaner version of VISER's mechanism, with no drawn artifacts. Comparing the two separates "fewer objects per look" from "lines on the image."
Proposed Experiments
The decisive first experiment is the $(n, p)$ factorial. If contours track pixels per object rather than object count, we abandon load-bounded splitting in favor of pure magnification. We then run end-to-end evaluations on four benchmark groups.
The first group is counting: FSC-147, stratified by object count with the over-100 bin reported separately, and Emoji-Count, reported as MAE. The second is the counting, extremum, and mean tasks of FUGU, where InternVL3 averages 69.3%. The third is the counting and attribute categories of VisualOverload. The fourth is the density-stratified visual questions of ChartMuseum, where Gemini-2.5-Pro reaches 63.0% overall and Qwen2.5-VL-72B reaches 38.5%.
Every result is reported against total visual tokens and wall-clock time. The probe study checks whether accuracy recovered by load reduction tracks a narrowing gap between what the encoder holds and what the language model uses. Separately, we track ghost counts in empty crops, which LVLM-COUNT reports persisting despite instructions to answer zero. We test whether a minimum coarse-count threshold for creating leaves removes them.
The method fails its central test if crop-without-magnify recovers little of the gain while a token-matched full-resolution pass recovers most of it. It also fails if FSC-147 MAE in the over-100 bin is no better than LVLM-COUNT's with the same base model.
References
- LVLM-Count: Enhancing the Counting Ability of Large Vision-Language Models
- Visual Structures Help Visual Reasoning: Addressing the Binding Problem in LVLMs
- SPARC: Separating Perception And Reasoning Circuits for Test-time Scaling of VLMs
- VisualOverload: Probing Visual Understanding of VLMs in Really Dense Scenes
- Diagnosing Bottlenecks in Data Visualization Understanding by Vision-Language Models
- Bootstrapping MLLM for Weakly‑Supervised Class‑Agnostic Object Counting
- Density Map Guided Object Detection in Aerial Images
- ChartMuseum: Testing Visual Reasoning Capabilities of Large Vision-Language Models
- VLM-SubtleBench: How Far Are VLMs from Human-Level Subtle Comparative Reasoning?