GeoVista: Web-Augmented Agentic Visual Reasoning for Geolocalization

ArXiv: 2511.15705

🎯 Pitch

A 7B-parameter open-source model trained to interleave web searches with visual zoom-ins can geolocate random street-level photos down to the correct city 72.7% of the time—matching closed-source giants like GPT‑5—with a median error of just 2.35 km. That performance only emerges when reinforcement learning combines a hierarchical reward that doubles the payout for each finer-grained location level, proving that small models can rival large ones if they are taught to actively retrieve and verify external evidence during reasoning.

---

1. Executive Summary

This paper introduces GeoVista, an agentic multimodal model that seamlessly integrates tool invocation within a dynamic reasoning loop for complex geolocalization queries—pairing an image-zoom-in tool to magnify regions of interest with a web-search tool to retrieve and validate external geographic hypotheses. To rigorously evaluate agentic geolocalization, the authors curate GeoBench, a benchmark of 1,142 high-resolution images (photos, panoramas, and satellite imagery) spanning 6 continents, 66 countries, and 108 cities, with multi-level labels enabling both level-wise accuracy and fine-grained haversine distance evaluation. GeoVista is trained through a complete pipeline: cold-start supervised fine-tuning on curated multi-turn reasoning trajectories to learn tool-use priors, followed by reinforcement learning with GRPO and a hierarchical reward that grants progressively larger rewards for correctness at country, province, and city levels (weighted as 1, β, β² with β=2). A 7B-parameter GeoVista achieves 72.68% city-level accuracy on GeoBench—matching GPT-5 (67.11%) and approaching Gemini-2.5-flash (73.29%)—while reducing median haversine distance to 2.35 km, establishing that web-augmented agentic visual reasoning enables small open-source models to rival closed-source counterparts on geolocalization only when both cold-start SFT and hierarchical RL are combined.

2. Context and Motivation

The Core Gap: Agentic Reasoning Without Web Access

The paper addresses a specific and under-explored gap in multimodal reasoning: current agentic models that "think with images" rely almost exclusively on image manipulation tools, lacking access to external information retrieval during their reasoning loops. This gap is precisely stated in Section 1:

"these works only emphasize image manipulation during multimodal reasoning, thus making problem-solving rely solely on the model's inherent knowledge and lacking appropriate access to external information retrieval tools like web search."

This is not a minor limitation. When a reasoning system can only zoom, crop, and rotate images—but cannot look up what it sees in an external knowledge source—it is fundamentally constrained by the boundaries of its pretraining data. A model may correctly identify visual features (a specific architectural style, road signage, vegetation pattern) but lack the factual knowledge to map those features to a location. Conversely, it may have factual knowledge about a region but be unable to confirm whether a given image matches that knowledge because it cannot search for corroborating evidence. The absence of web retrieval creates a hard ceiling on agentic visual reasoning: no amount of image manipulation can substitute for missing facts.

Why This Gap Matters: The Geolocalization Use Case

The paper argues that geolocalization is the ideal testbed for exposing this gap because it fundamentally demands both capabilities simultaneously. To localize an image, a system must:

1. Extract fine-grained visual clues from high-resolution imagery—text on signs, architectural styles, road markings, vegetation types, license plates, business names, weather patterns, and hundreds of other subtle cues that may only be visible when zooming into specific image regions.
2. Retrieve and validate external knowledge corresponding to those clues—searching for a business name to find its location, looking up a distinctive architectural style's geographic distribution, confirming that a particular combination of road signs exists in a specific country.

Neither capability alone suffices. A model with perfect vision but no web access cannot identify an obscure business sign; a model with extensive world knowledge but no image inspection cannot find that sign in the first place. The reasoning process is inherently interleaved: zoom in to find a clue → search the web to understand it → zoom somewhere else based on what was learned → search again to refine the hypothesis. This dynamic, tool-mediated loop of visual inspection and knowledge retrieval is precisely what the paper aims to enable and what prior work has not addressed.

The practical importance of geolocalization extends beyond academic interest. Real-world applications include disaster response (locating where aid is needed from user-submitted photos), investigative journalism (verifying the location of images in conflict zones), content moderation (detecting misrepresented locations in social media), and autonomous navigation (confirming location from visual surroundings when GPS fails). Each of these scenarios demands combining what is seen with what is known—exactly the capability GeoVista targets.

Prior Work and Where It Falls Short

Image-Centric Reasoning Models: Tool Use Without Retrieval

The paper positions itself against a recent wave of "thinking with images" research that has evolved from treating images as static inputs to using visual intermediate representations for reasoning. This lineage begins with Visual CoT (visual_cot), which introduced localized intermediate reasoning steps—such as drawing bounding boxes or identifying regions of interest—to guide the model's attention during multi-step visual reasoning. Visual Sketchpad (visual_sketchpad) extended this concept to an editable canvas where models could draw, crop, and annotate images during inference, essentially creating a scratchpad for visual thought.

The critical inflection point came with OpenAI o3 (OpenAI_o3_2025), which the paper describes as a "watershed" moment:

"OpenAI o3 (OpenAI_o3_2025) marked a watershed by productizing tool-mediated visual reasoning inside the chain (zoom, crop, rotate), triggering open replications."

Several open-source replications followed in rapid succession. Thyme (thyme) extends the paradigm with a code-executing visual sandbox that emits and runs image operators programmatically. mini-o3 (mini-o3) trains an agent to alternate "think–act" cycles, performing iterative region selection and overturn masking, scaling to deep multi-turn search. OpenThinkIMG (open_think_img) unifies multiple visual tools—detectors, OCR, drawing—under a standardized controller with reinforcement-learning-learned tool policies. DeepEyes (deepeyes) goes further, demonstrating that purely RL-induced zoom behaviors emerge without any supervised fine-tuning for tool use.

However, all of these systems share a common limitation: their toolset is restricted to image manipulation. They can zoom, crop, rotate, annotate, and draw—but they cannot query external knowledge. The paper explicitly frames this as the gap it addresses:

"these works only emphasize image manipulation during multimodal reasoning, thus making problem-solving rely solely on the model's inherent knowledge and lacking appropriate access to external information retrieval tools like web search."

The consequence is that even the most sophisticated image-thinker cannot answer questions that require knowing something it hasn't memorized during pretraining. For geolocalization, this means a model might perfectly zoom in on a building's distinctive architectural detail, carefully analyze its features, and then... fail because it has no way to determine where buildings with that style exist.

Prior Geolocalization Work: Specialized Systems Without Agentic Reasoning

The paper also distinguishes its approach from the extensive prior work on geolocalization as a standalone computer vision task (Section 2.2). Early work established the foundational paradigm: Im2GPS (im2gps, 2008) framed geolocalization as image retrieval, finding visually similar database images with known GPS coordinates. YFCC4k (revisit_im2gps, 2017) refined this with curated subsets of the YFCC100M dataset, emphasizing metric learning to map images to geographic coordinates. These approaches treat geolocalization purely as a vision problem—match visual features, retrieve location.

Landmark-centric systems like Google Landmarks v2 (google_landmarks_v2, 2020) achieved high precision on distinctive structures (the Eiffel Tower, the Sydney Opera House) where visual uniqueness makes localization straightforward. VIGOR (vigor, 2022) tackled the more challenging cross-view setting, matching ground-level photos to aerial imagery, stressing generalization across unseen cities. OSV-5M (osv-5m, 2024) scaled to worldwide street scenes with 5 million images, enabling training and fair evaluation at unprecedented diversity.

A significant advance toward reasoning-based geolocalization came with GeoComp (geocomp, 2025), which the paper describes as:

"introduc[ing] human gameplay traces and reasoning sequences, catalyzing explainable, step-wise localization beyond raw appearance cues."

GeoComp collected human gameplay data from a geolocalization game (GeoGuessr), capturing not just location predictions but the reasoning chains humans used to arrive at them—observations about language, vegetation, infrastructure, and culture. This shifted the paradigm from pure visual matching to explainable reasoning, but the reasoning was still based entirely on what the human could see, mapped to their internal knowledge. It did not involve tool use at inference time.

More recent works explored agentic approaches but with important limitations. EmbodiedWebAgents (embodiedwebagents) investigated agents for web-based tasks but not specifically for multimodal reasoning with image tools. DOXingBench (doxingbench) studied privacy-invasive location inference but treated it as a retrieval problem rather than a reasoning one. Recognition through Reasoning (recognition_through_reasoning) explored how reasoning can improve visual recognition, but again without the agentic tool-use loop.

The common thread across all prior geolocalization work is the absence of interleaved visual tool use and web search within a single reasoning loop. Systems either matched images to coordinates (vision-only), used human reasoning traces (fixed knowledge), or deployed agents without both visual and retrieval capabilities. GeoVista's contribution is closing this gap with a model that can dynamically decide when to zoom, when to search, and how to integrate the results.

Benchmarks: Why Existing Datasets Don't Test What Matters

The paper also argues that existing geolocalization benchmarks are structurally inadequate for evaluating agentic models (Section 3.2, Table 1). The key deficiencies are:

Low resolution. Most existing benchmarks use images that are too low-resolution to support the fine-grained visual clue extraction that agentic models perform. Im2GPS and YFCC4k primarily use web-resolution images where zooming yields little additional information. GeoBench requires all images to have at least 1M pixels, ensuring that the zoom-in tool has meaningful detail to reveal.

Lack of localizability control. Existing benchmarks mix highly localizable images (iconic landmarks that any model knows) with completely non-localizable ones (generic indoor scenes, close-up food photos). This makes it impossible to assess whether a model is genuinely reasoning or simply pattern-matching memorized landmarks. GeoBench explicitly filters out both extremes—removing non-localizable images (those without any geographic clues) and easily recognizable landmarks (those that would be trivially solved by pretraining knowledge)—leaving a challenging middle ground where reasoning is both possible and necessary.

Absence of multi-level evaluation. Most benchmarks report only a single accuracy metric (e.g., correct city), which masks whether errors are catastrophic (wrong continent) or near-misses (wrong city within the correct region). GeoBench provides hierarchical labels at country, province, and city levels, enabling analysis of what kind of errors models make. It also computes haversine distance—the great-circle distance between predicted and true coordinates—for a continuous, fine-grained assessment of localization precision.

Limited data variety. Earlier benchmarks typically contain only one type of imagery (street-level photos, landmark photos, or aerial). GeoBench includes three deliberately different data types—standard photos, 360° panoramas, and satellite images—each requiring different reasoning strategies. Photos contain close-range visual clues (signage, architecture, people); panoramas provide wide-angle context but lack the detail resolution of photos; satellite images demand reasoning about city layout, infrastructure patterns, and geographic features from above, with no textual or cultural cues.

How This Paper Positions Itself

The paper frames its contribution at the intersection of two previously separate research directions: agentic visual reasoning (thinking with images through tool use) and real-world geolocalization (locating images through visual and knowledge-based reasoning). The central insight is that these two directions are complementary in a way that prior work has not exploited:

• Agentic visual reasoning provides the mechanism for interactive tool use (zooming, searching) but has been developed on tasks that don't require external knowledge retrieval.
• Geolocalization provides the task that naturally demands both visual tools and knowledge retrieval but has been approached with specialized systems rather than general-purpose agentic architectures.

By bringing them together, the paper creates a new axis for agentic multimodal reasoning that extends beyond image manipulation:

"To enable a new axis for agentic multimodal reasoning, we revisit a real-world scenario—geolocalization, in which models are required to extract visual clues in high-resolution images and rely on the web search to validate or refine their hypotheses."

The training methodology further distinguishes GeoVista from prior work. The two-stage pipeline—cold-start SFT on curated reasoning trajectories followed by RL with hierarchical rewards—is designed to overcome specific failures observed in preliminary experiments:

• RL without SFT fails because the model hasn't learned tool-use patterns. The paper notes that direct RL training produced "overly concise responses" and the model "hesitated to make tool calls" (Section 3.3). The cold-start SFT provides the necessary prior: by training on trajectories that demonstrate zooming to inspect regions, searching for information about observed features, and integrating search results into reasoning, the model learns that it should use tools and how to use them.
• SFT without RL fails because it only imitates reasoning, not optimizes for correctness. The cold-start trajectories include both correct and incorrect reasoning—they demonstrate the pattern of geolocalization reasoning but are not filtered for accuracy. RL with correctness-based rewards incentivizes the model to produce reasoning that leads to correct answers, not just any reasoning that looks plausible.
• Flat rewards fail to leverage geographic hierarchy. A simple city-correct-or-not reward provides weak supervision when the model is often close but not exact—it would penalize a model that predicts "California, USA" for a Los Angeles photo identically to one that predicts "Japan." The hierarchical reward (country=1, province=β, city=β², with β=2) provides partial credit for partial correctness, giving the model a smoother learning signal that encourages getting closer to the truth even when the exact city remains elusive.

The paper explicitly chooses a 7B parameter base model (Qwen2.5-VL-7B-Instruct) to demonstrate that web-augmented reasoning can close the gap with much larger closed-source models—a design choice that emphasizes reasoning capability over raw parameter scale. The comparison with closed-source models (Gemini-2.5-pro, GPT-5, Seed-VL-1.6) that "are likely having far larger parameter counts than 7B" (Section 5.1) is intended to show that tool-mediated reasoning can compensate for model size when the task requires external knowledge that even large models cannot fully memorize. This positions GeoVista not as a scaling achievement but as a reasoning architecture achievement—the gains come from how the model thinks, not from how big it is.

3. Technical Approach

3.1 Reader Orientation

GeoVista is a multimodal language model that can inspect images by zooming into specific regions and simultaneously search the web for information about what it sees, all within a single continuous reasoning loop. It solves the problem that current "thinking with images" models can manipulate images but cannot retrieve external knowledge: GeoVista adds a web-search tool to the standard image-manipulation toolkit and trains the model to dynamically interleave visual inspection with information retrieval, making it capable of geolocalization tasks that require both fine-grained visual clue extraction and factual knowledge that goes beyond what was memorized during pretraining.

3.2 Big-Picture Architecture (Diagram in Words)

The system has four major components connected in an iterative loop:

1. Policy Model (GeoVista) — a 7B-parameter vision-language model (initialized from Qwen2.5-VL-7B-Instruct) that serves as the central reasoning engine. It receives a query, an image, and an accumulated interaction history; it produces a thought (reasoning step) followed by an action (tool call or final answer). Every decision—what to zoom into, what to search for, when to stop and answer—originates here.

2. Two Tools — executable functions that the policy model can invoke through structured action outputs:

   • Crop-and-Zoom: takes a bounding box (bbox_2d with pixel coordinates) as input, crops the specified region from the original image, magnifies it, and returns the magnified sub-image as an observation.
   • Web-Search: takes a search query string as input, queries a third-party web search service, and returns up to 10 relevant textual documents with their URLs as an observation.

3. Tool Execution Environment — a runtime that parses the model's action outputs, executes the corresponding tool, captures the result, and formats it as an observation that gets appended to the interaction history. This is not learned; it is a deterministic execution layer.

4. Interaction History — an accumulated sequence of (thought, action, observation) tuples that serves as the full context fed back into the policy model at each iteration. It is the "memory" that allows the model to build on previous inspections and searches.

Information flows as follows: a query and image enter the policy model → the model generates thought T₁ followed by action A₁ → the execution environment parses A₁ and runs the tool → the observation O₁ is appended to history → the full history (query + image + T₁ + A₁ + O₁) is fed back to the policy model → the model generates T₂ and A₂ → and so on. The loop terminates when the model outputs a final geolocation prediction (a special action type indicating "I have enough information to answer") or when a maximum turn limit is reached.

The training pipeline has two stages operating on this architecture:

5. Cold-Start SFT — supervised fine-tuning on 2,000 curated multi-turn reasoning trajectories that demonstrate the pattern of interleaved zooming, searching, and reasoning. This teaches the model that tools exist and how to use them.

6. Reinforcement Learning (RL) with GRPO — policy optimization on 12k training samples using a hierarchical reward that grants partial credit based on geographic precision (country, province, city). This refines the model to use its tool-calling capability to produce correct answers, not just plausible-looking reasoning.

3.3 Roadmap for the Deep Dive

• First, GeoBench benchmark construction — understanding the evaluation target: how data is collected, filtered for localizability, and annotated with hierarchical labels, and how the two evaluation modes (level-wise and nuanced/haversine) work. This is foundational because the model's training depends on knowing what "correct" means at multiple geographic granularities.

• Second, the agentic pipeline — the exact format of the thought-action-observation loop, what the two tools accept and return, and how turn limits and termination work. This is the inference-time architecture that must be compatible with both SFT trajectory format and RL rollout mechanics.

• Third, cold-start trajectory curation — how the 2,000 SFT trajectories are constructed using a strong VLM (Seed-1.6-vision) to propose zoom regions, generate search queries, and assemble multi-turn reasoning, and why this specific procedure is necessary (RL from scratch fails to learn tool use).

• Fourth, reinforcement learning with GRPO and hierarchical rewards — the GRPO objective, the advantage normalization, the hierarchical reward function (country=1, province=β, city=β² with β=2), and why a flat city-level reward produces worse results (fewer tool calls, lower accuracy).

• Fifth, training hyperparameters and infrastructure — SFT and RL configurations (learning rates, batch sizes, context lengths, turn limits, concurrent workers for tool interaction during RL rollouts) that make the full pipeline reproducible.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems-and-training paper whose core idea is that agentic visual reasoning benefits from adding web-search capabilities to the image-manipulation toolkit, and that a two-stage training pipeline—cold-start SFT to learn tool-use patterns followed by RL with hierarchical geographic rewards—enables a 7B model to rival closed-source models on geolocalization.

---

GeoBench Benchmark Construction

The paper constructs GeoBench to fill a specific gap: existing geolocalization benchmarks are either too low-resolution for detailed visual inspection, include non-localizable images mixed with trivially recognizable landmarks, lack hierarchical labels, or contain only a single type of imagery. GeoBench addresses all four deficiencies simultaneously.

Raw data collection. Three distinct data types are collected (described in Appendix A):

• Normal photos are collected from the internet to cover diverse scenarios (libraries, supermarkets, suburban areas). All photos have at least a resolution of 1600×1200 pixels—approximately 1.92M pixels, exceeding the 1M-pixel minimum the paper sets as the threshold for "high resolution."
• Panoramas originate as 360° street-view scenes from cities worldwide. They are retrieved via the Mapillary API, which provides tiled segments of full spherical views. These tiles are stitched locally into planar panoramic images and fixed at a resolution of 4096×2048 pixels (approximately 8.39M pixels). This wide-angle format provides broad contextual information—multiple buildings, street layouts, skyline views—but at lower per-object resolution than standard photos.
• Satellite images are retrieved as Sentinel-2 Level-2A imagery from the Microsoft Planetary Computer. These are recent satellite captures with low cloud cover, each approximately 2000×2000 pixels. Multiple low-cloud scenes within each city's bounding box are mosaicked, and multiple viewport variants are saved with their metadata (geolocation coordinates).

Localizability filtering. The raw data contains images that are either impossible to localize or trivially easy to localize. The paper applies model-based filtering to remove both categories:

• Non-localizable images are those lacking identifiable geographic clues: close-up food photos, indoor rooms, plain natural landscapes without distinctive features, single animals. These provide "almost no regional or cultural context, making localization infeasible" (Section 3.2). A VLM-based classifier identifies and removes these images.
• Easily localizable landmarks contain strong geographic priors—iconic landmarks or globally recognizable sites (the Eiffel Tower, the Sydney Opera House, the Statue of Liberty). Since VLMs "have likely encountered such images multiple times during pretraining, including them would make geolocation trivial and fail to reflect genuine reasoning ability." These are also removed.

The result is a dataset of images that are localizable but not trivial—the "challenging middle ground where reasoning is both possible and necessary."

Multi-level annotation. Each image that passes filtering receives hierarchical geographic labels at three administrative levels: country, province or state, and city. The paper notes that "each sample is accompanied by geolocalization metadata, including precise latitude and longitude" (Section 3.2), which enables both automated level-wise evaluation (by checking whether the predicted location matches the ground truth at each level) and continuous distance-based evaluation (by computing haversine distance between predicted and true coordinates).

Final dataset composition. GeoBench contains 512 standard photos, 512 panoramas, and 108 satellite images, for a total of 1,142 images (actually 512 + 512 + 108 = 1,132—the paper states 1,142, which may include a small number of additional images not split evenly across categories, or this may be a rounding artifact in the reported numbers). The geographic coverage spans 6 continents, 66 countries, and 108 cities, "ranging from Xi'an to Dublin to Washington, D.C." (Section 3.2).

Table 1 (Section 3.2) compares GeoBench to prior benchmarks along five axes: Global Coverage (GC), Reasonable Localizability (RC), High Resolution (HR), Data Variety (DV), and Nuanced Evaluation (NE). GeoBench is the only benchmark that satisfies all five criteria. Im2GPS and YFCC4k have global coverage but lack the other four. OSV-5M and GeoComp come closest, each satisfying four of five (they lack either reasonable localizability filtering or data variety), but neither provides the full combination.

Comparison with Table 1 in the paper. The comparison table reports that Im2GPS (2008) has GC only; YFCC4k (2017) has GC only; Google Landmarks v2 (2020) has GC and HR; VIGOR (2022) has GC and RC; OSV-5M (2024) has GC, RC, HR, and DV but not NE; GeoComp (2025) has GC, RC, DV, and NE but not HR (its images are typically lower resolution game screenshots). GeoBench (2025) is the first to achieve all five: GC, RC, HR, DV, and NE.

Level-wise evaluation. The paper implements a combined rule-based and model-based verifier. At each administrative level (country, province/state, city), the evaluation system:

1. Extracts the predicted location text from the model's response.
2. Applies a rule-based verifier for exact or near-exact string matching against the ground-truth labels at that administrative level. For example, if the ground truth country is "Germany" and the model predicts "Berlin, Germany," the country-level verifier extracts "Germany" from the prediction and matches it.
3. When rule-based matching is ambiguous (e.g., the model uses a different name format or provides an address that doesn't cleanly parse), a model-based verifier (OpenAI gpt-4o-mini) is invoked to judge whether the predicted location is correct at that administrative level.
4. Accuracy is reported separately for each level: country accuracy, province/state accuracy, and city accuracy. A prediction correct at the city level is necessarily correct at province and country levels (the hierarchy is strict).

The paper also reports city-level accuracy broken out by data type (panorama, photo, satellite) to assess whether models handle different imagery types differently.

Nuanced evaluation and haversine distance. City-level accuracy is coarse—it treats "Los Angeles" and "San Francisco" identically as errors when the true location is San Diego, even though Los Angeles is much closer. To provide finer-grained assessment, the paper computes haversine distance between predicted and true coordinates:

$d = 2R_{\text{e}}\arcsin\left(\sqrt{v}\right)$

$v = \sin^{2}\left(\frac{\phi_{2} - \phi_{1}}{2}\right) + \cos(\phi_{1})\cos(\phi_{2})\sin^{2}\left(\frac{\lambda_{2} - \lambda_{1}}{2}\right)$

where $(\phi_1, \lambda_1)$ are the latitude and longitude of the predicted point, $(\phi_2, \lambda_2)$ are the latitude and longitude of the ground-truth point, and $R_e$ is Earth's approximate radius (typically 6,371 km). The term $v$ is the haversine of the central angle—a composite trigonometric expression that computes the squared half-chord length between the two points on a sphere. The arcsin of the square root of $v$ gives the central angle in radians; multiplying by $R_e$ converts this to a great-circle distance in kilometers.

What it computes: the shortest distance between two points on the surface of a sphere, given their latitude/longitude coordinates. This is the great-circle distance—"as the crow flies"—not driving distance. The formula accounts for the spherical geometry of Earth, avoiding the distortions that would arise from treating latitude and longitude as Cartesian coordinates (which becomes severely inaccurate at high latitudes or across long distances).

Why this form: the haversine formula is numerically stable for both small and large distances because the haversine function $\text{hav}(\theta) = \sin^2(\theta/2)$ avoids the catastrophic cancellation that can occur when computing $\cos(\theta)$ for small angles with finite-precision arithmetic. Alternative distance formulas (e.g., the spherical law of cosines) suffer from rounding errors when points are close together, precisely the regime that matters for fine-grained geolocalization evaluation.

The evaluation pipeline for haversine distance works as follows (Figure 4, left):

1. From the model's text response, extract the predicted textual location (e.g., "Schöneberger Straße, 22149 Hamburg, Germany").
2. Pass this text to a geocoding service (Google Geocoding API) which converts it to latitude/longitude coordinates. This step is necessary because models do not directly output coordinates.
3. Compute the haversine distance between the geocoded prediction point and the ground-truth coordinates from the metadata.
4. Report two aggregated metrics: the percentage of predictions with haversine distance < 3 km (a strict proximity threshold indicating street-level accuracy) and the median haversine distance across all predictions (a robust central-tendency measure not skewed by a few catastrophic errors).

The 3 km threshold is notably stringent—it requires predictions to be within roughly the same urban neighborhood. For comparison, the paper reports that the base Qwen2.5-VL-7B model has a median distance of 2,209.82 km (effectively random guessing at continental level), while GeoVista achieves 2.35 km.

---

The Agentic Pipeline

The agentic pipeline (Section 3.1, Figure 2) defines the inference-time interaction protocol between the policy model and its tools. It follows a ReAct-style pattern of interleaved reasoning and action but is specifically adapted for multimodal inputs and tool-augmented visual reasoning.

Loop structure. At iteration $i$:

1. The policy model receives the full interaction history $H_{i-1}$, consisting of: the original user query $q$, the original input image $I$, and all previous (thought, action, observation) tuples from iterations $1$ through $i-1$.

2. The model generates a thought $T_i$—free-form text describing what it has observed so far, what it hypothesizes about the location, and what it intends to do next. This is the model's internal reasoning, analogous to the chain-of-thought in a non-agentic setting but operating over accumulated visual and textual evidence.

3. Immediately following $T_i$, the model generates an action $A_i$—a structured output specifying either a tool call or the final answer. Actions use a standardized format (the paper mentions JSON format for tool calls; Section 5.3.3 discusses malformed JSON as an error category), with specific fields depending on the action type.

4. The action is parsed by the execution environment:

   • If $A_i$ is a Crop-and-Zoom action: it contains a bbox_2d parameter with pixel coordinates (x_min, y_min, x_max, y_max) defining a rectangular region in the original image. The execution environment crops this region, magnifies it, and returns the magnified sub-image as observation $O_i$.
   • If $A_i$ is a Web-Search action: it contains a search query string. The execution environment sends this query to a third-party web search provider, retrieves up to 10 relevant textual documents with their URLs, and returns these as observation $O_i$.
   • If $A_i$ is a Final Answer action: it contains the predicted location text. The loop terminates, and this text is passed to the evaluation pipeline.

5. The observation $O_i$ is appended to the history, forming $H_i = H_{i-1} + (T_i, A_i, O_i)$, and the loop continues from step 1.

Termination conditions. The loop ends when either (a) the model outputs a final answer action, or (b) a maximum turn limit is reached. During training and evaluation, the paper caps the maximum number of turns at 6 (Section 4, RL configuration). If the limit is reached without a final answer, the model's last output is taken as the prediction (in practice, the model is trained to produce answers within the limit).

Initial image preprocessing. Before entering the policy model's visual encoder, the original high-resolution image is downsampled. The paper sets the initial pixel budget to 2M pixels (Section 5.1, Inference), meaning the image is resized so that its total pixel count does not exceed approximately 2 million. This is done "to prevent the models from being overwhelmed by the context of the original high-resolution image." The 2M threshold is a compromise: it preserves more detail than standard web-resolution images (which might be 0.5M–1M pixels in typical VLM inputs) but is computationally tractable. When the model uses the crop-and-zoom tool, the cropped region is presented at full available resolution—the 2M limit applies only to the initial view, not to zoomed sub-images. This design means the model can strategically allocate its visual bandwidth: it first sees a moderate-resolution overview to identify candidate regions, then zooms into specific areas to extract fine details from the full-resolution crop.

Why a turn limit of 6. The paper states this is "to maintain training efficiency" during RL (Section 4). Each turn involves generating model outputs and potentially executing tool calls (which may include web search API calls with latency and cost). Without a limit, the model could enter arbitrarily long reasoning chains during RL rollouts, making training computationally infeasible. The choice of 6 is empirical—it balances sufficient depth for multi-step reasoning (zoom → search → zoom → search → zoom → answer fits within 6 turns) against training cost.

Tool symmetry and asymmetry. The two tools differ in a crucial way that affects the model's reasoning:

• Crop-and-Zoom is deterministic: given the same bounding box on the same image, it always returns the same magnified sub-image. The model has full control over what it sees.
• Web-Search is stochastic: the same query may return different results at different times, and the model has no control over which 10 documents are returned or their ordering. This introduces an element of unreliability—the model must be robust to variation in search quality and must sometimes reformulate queries if the first search returns unhelpful results.

The paper does not explicitly model this stochasticity in the RL formulation (the GRPO objective does not account for tool stochasticity), which means the RL signal is noisier for search-involving trajectories than for zoom-only trajectories. This is a subtle but real challenge: the model may be penalized for correct reasoning if a web search returns poor results during a rollout, creating a confounding factor in the reward signal.

---

Cold-Start Trajectory Curation

The cold-start supervised fine-tuning (SFT) stage addresses a bootstrapping problem: the base Qwen2.5-VL-7B-Instruct model, when trained directly with RL, "tended to produce overly concise responses and hesitated to make tool calls, leading to unsatisfactory performance" (Section 3.3). The model hasn't been trained to use tools and doesn't discover tool-use behavior through exploration alone within a feasible RL budget. The SFT stage provides explicit demonstrations of multi-turn tool-use reasoning, teaching the model both that tools should be used and how to format tool calls.

Trajectory generation procedure (Figure 6, left). The paper uses a three-phase process to construct each reasoning trajectory, orchestrated by a strong VLM (Seed-1.6-vision):

Phase 1: Visual inspection proposals. The VLM is given the image and asked to propose multiple regions of interest along with intermediate reasoning. Specifically, it outputs several bounding boxes and for each one, a rationale explaining why that region is worth inspecting—what geographic clues it might contain. This mimics the human behavior of scanning an image, identifying potentially informative areas (signs, architectural features, vegetation, vehicles), and formulating hypotheses about what each area might reveal.

Phase 2: Web-search query generation. After the VLM has identified and described the salient geographic cues (from Phase 1), it is prompted to generate several web-search queries accompanied by rationales. For example, if Phase 1 identified a distinctive building style and a partially visible business sign, Phase 2 might generate queries like "Brutalist architecture buildings with blue tile facade" or the business name extracted from the sign. The rationale explains why each query is relevant to the geolocalization task—what geographic information it is expected to return.

Phase 3: Final reasoning assembly. The VLM is asked to generate the reasoning for the final geolocation judgment, integrating the visual observations and search results. This provides a coherent narrative that connects the evidence to the conclusion.

The outputs from all three phases—the bounding boxes, the search queries, and the narrative reasoning—are then assembled into a coherent multi-turn trajectory by interleaving them in a logical order: the VLM's thoughts are placed as $T_i$ elements, the bounding boxes and search queries are formatted as tool call actions $A_i$ using the system's action format, and the actual tool executions (running the crop-and-zoom on the specified bounding box, running the web search on the specified query) are performed and their results inserted as observations $O_i$. The result is a complete (query, image, $T_1$, $A_1$, $O_1$, $T_2$, $A_2$, $O_2$, ..., final answer) sequence that demonstrates the full agentic reasoning pattern.

No answer-based filtering. Critically, the paper states:

"As we only intend to provide the model with a reasoning pattern prior, we did not apply answer-based filtering to the reasoning trajectories."

This means the SFT trajectories include both correct and incorrect final answers. The SFT stage teaches the model how to reason with tools—the format, the sequence of operations, the integration of visual and search evidence—but does not directly optimize for correctness. This is a deliberate design choice: if only correct trajectories were included, the model might overfit to a narrow set of reasoning patterns that happen to produce correct answers in the training data, rather than learning a generalizable reasoning capability. The RL stage handles correctness optimization separately.

Scale and scope. The paper curates 2,000 cold-start reasoning trajectory examples. This is a relatively small number for SFT (compared to typical instruction-tuning datasets of tens or hundreds of thousands of examples), reflecting the focused nature of the task: 2,000 demonstrations of multi-step geolocalization reasoning are sufficient to teach the model the tool-use pattern because the pattern itself is relatively constrained (zoom to inspect, search to verify, integrate, repeat). The trajectories are curated specifically for geolocalization; there are no non-geolocalization examples in the SFT mix.

Why use Seed-1.6-vision for trajectory generation. The paper uses a closed-source, large-scale VLM rather than the base Qwen2.5-VL-7B model to generate trajectories. This is a teacher-student paradigm: a stronger model (the teacher) produces reasoning demonstrations that a weaker model (the student) can learn from. Seed-1.6-vision is capable of producing coherent multi-step reasoning with tool calls, which the 7B base model cannot do without training. The teacher's outputs may contain errors (recall: no filtering), but the pattern of reasoning—the structure of interleaved thoughts, zoom actions, and search actions—is what matters for the SFT stage.

Cost of trajectory curation. The paper does not report the computational cost of generating the 2,000 trajectories using Seed-1.6-vision, but it involves: (1) running a large VLM for 2,000 images × 3 phases per image = 6,000 inference calls to the teacher model, (2) executing the proposed tool calls (crop operations are cheap; web search queries incur API costs), and (3) assembling and formatting the results. This is a one-time cost for dataset construction, not a recurring inference cost.

---

Reinforcement Learning with GRPO and Hierarchical Rewards

The RL stage optimizes the policy model to produce correct geolocalization predictions, building on the tool-use patterns learned during SFT. The paper uses Group Relative Policy Optimization (GRPO) with a hierarchical reward function tailored to geographic labels.

The GRPO objective. GRPO is an extension of Proximal Policy Optimization (PPO) that operates on groups of responses rather than individual samples. For each question $q$, the policy model generates a group of $G$ outputs $\{o_i\}_{i=1}^G$. Rewards $r_i$ are computed for each output based on correctness (defined below). The optimization objective is:

$\mathcal{J}_{\mathrm{GRPO}}(\theta) = \mathbb{E}_{q \sim \mathcal{D},\ \{o_i\}_{i=1}^{G} \sim \pi_{\theta_{\mathrm{old}}}(\cdot \mid q)} \left[ \frac{1}{G} \sum_{i=1}^G \left[ \min\left(\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_{\mathrm{old}}}(o_i \mid q)} A_i,\ \operatorname{clip}\!\left(\frac{\pi_\theta(o_i \mid q)}{\pi_{\theta_{\mathrm{old}}}(o_i \mid q)},\, 1 - \epsilon,\, 1 + \epsilon\right) A_i \right) \right] \right]$

where $q$ is a question sampled from the training distribution $\mathcal{D}$, $G$ is the group size (number of responses generated per question), $\pi_\theta$ is the current policy being optimized, $\pi_{\theta_{\mathrm{old}}}$ is the frozen policy from the previous iteration (used for importance sampling), $A_i$ is the group-relative advantage for output $i$, and $\epsilon$ is the clipping parameter.

The advantage $A_i$ is computed as:

$A_i = \frac{r_i - \operatorname{mean}(\{r_1, r_2, \ldots, r_G\})}{\operatorname{std}(\{r_1, r_2, \ldots, r_G\})}$

where $r_i$ is the reward for output $i$, and mean and std are computed over the group of $G$ outputs for the same question.

What it computes: For each question, GRPO generates $G$ candidate responses, scores them with the reward function, then updates the policy to increase the probability of above-average responses and decrease the probability of below-average responses, subject to a clipping constraint that prevents too-large policy changes. The advantage $A_i$ measures how much better (or worse) output $i$ is compared to the average output in its group, normalized by the group's standard deviation—this is a z-score normalization that removes the scale of rewards and focuses on relative ranking within the group.

Why this form: GRPO's key property is that it uses group-relative rather than absolute advantages. This is important because the absolute reward values depend on the reward function's scale (in this case, $\beta$ in the hierarchical reward), which is arbitrary. By normalizing within each group, GRPO is invariant to the absolute scale of rewards—it only cares about whether one response is better than another for the same question. This also provides a natural curriculum: as the model improves and most responses achieve higher absolute rewards, the relative differences still drive learning.

The clipping mechanism (using $\min$ and $\operatorname{clip}$) prevents the policy from changing too rapidly in a single update, which is standard in PPO-style algorithms. The paper "deprive[s] the KL regularization" (Section 4), meaning they do not add an explicit KL divergence penalty between $\pi_\theta$ and $\pi_{\theta_{\mathrm{old}}}$. The clipping alone is relied upon to constrain policy updates.

The hierarchical reward function. The reward $r_i$ for an output $i$ is:

$r_i = \begin{cases} \beta^2, & \text{if city-level correct}, \\ \beta, & \text{if provincial/state-level correct}, \\ 1, & \text{if country-level correct}, \\ 0, & \text{else}. \end{cases}$

where $\beta$ is a scaling factor controlling the reward gap between geographic levels. The paper sets $\beta = 2$, yielding rewards of 4 for city-correct, 2 for province-correct, 1 for country-correct, and 0 otherwise.

What it computes: The reward is a discrete function of the finest administrative level at which the prediction is correct. A prediction that correctly identifies the city (and thus implicitly the province and country) receives the maximum reward of 4. A prediction that identifies the correct province but wrong city receives 2. A prediction that only gets the country right receives 1. A completely wrong prediction receives 0.

Why this form: The geometric progression (1, $\beta$, $\beta^2$) creates a superlinear reward gap between levels: getting the city right is $\beta$ times better than getting only the province right, which is $\beta$ times better than getting only the country right. With $\beta=2$, the multiplicative gaps are clear: city is 4× country-level reward, province is 2× country-level reward. A linear reward (1, 2, 3) would not sufficiently incentivize the model to aim for finer-grained predictions—the marginal benefit of going from province-correct to city-correct would be the same as going from completely wrong to country-correct. The geometric form makes each additional level of precision disproportionately valuable.

The paper explains the choice with a concrete example:

"For a photo taken in Los Angeles, we give a higher reward to the answer 'Los Angeles' than to 'San Francisco,' because the former is correct at the city level, although both are correct at the state level."

Both "Los Angeles" and "San Francisco" are in California, so under a flat city-level-only reward, both would receive 0 (since San Francisco is the wrong city). This is harsh: the model that predicts "San Francisco" is clearly doing better than one that predicts "Tokyo," but a flat reward treats them identically. The hierarchical reward distinguishes them: San Francisco gets 2 (state-correct), Tokyo gets 0 (completely wrong).

Why $\beta=2$ specifically. The paper states:

"To prevent $\beta$ from being so large that reward gaps become excessive, or so small that rewards collapse, empirically we choose a compromise value of $\beta=2$ in later experiments."

This reveals an important tension: if $\beta$ is too large (e.g., $\beta=10$, giving rewards of 1, 10, 100), the reward gap between levels is so extreme that the model is heavily penalized for near-misses (getting the province right but city wrong gives only 10% of the city-correct reward), which could discourage the model from attempting fine-grained predictions at all—it might learn to be conservative and only predict at the country level to avoid the risk of a large penalty. Conversely, if $\beta$ is too close to 1 (e.g., $\beta=1.1$, giving rewards of 1, 1.1, 1.21), the reward differences are so small that the model cannot effectively distinguish between levels, leading to "reward collapse" where the RL signal is too weak. $\beta=2$ provides a moderate gradient: getting the city right (reward 4) is meaningfully better than getting only the province right (reward 2), but not so much better that the model becomes risk-averse.

The paper acknowledges they did not sweep $\beta$ values: "As reinforcement learning incurs substantial cost, particularly due to search API usage and the computational overhead of response-group rollouts, we do not experiment with additional $\beta$ values." This means $\beta=2$ was chosen based on intuition and perhaps small-scale preliminary tests, not a systematic sweep, which is a limitation the paper implicitly acknowledges.

Comparison with flat reward (Figure 6, right). The paper reports that using a flat city-only reward (where the model gets 1 for correct city and 0 otherwise) leads to worse performance and fewer tool calls. The ablation (Table 4, "w/o HR") confirms this quantitatively: with hierarchical reward disabled, city-level accuracy on panoramas drops from 79.49% to 75.0%, on photos from 72.27% to 68.95%, and on satellite images from 44.92% to 40.68%. The median haversine distance worsens from 2.35 km to 4.11 km.

The reduction in tool calls is particularly telling. Without hierarchical reward, the model receives no partial credit for getting close—so when it is uncertain, it has less incentive to invest turns in refining its guess through additional zoom or search. Under hierarchical reward, even if the model cannot identify the exact city, getting the province right earns a reward of 2, which is better than 0. This incentivizes the model to continue reasoning and using tools to narrow down the location as much as possible, even when perfect accuracy seems unlikely.

RL training procedure. During RL, the paper uses the standard GRPO implementation from the verl library with 12,000 training samples. This is larger than the 2,000 SFT samples because RL data do not require reasoning-trajectory annotations—the model generates its own trajectories during rollouts, and only the image and ground-truth location labels are needed to compute rewards. The paper does not specify the exact composition of these 12k samples (whether they include the 2k SFT images plus additional data, or are entirely separate), but given the data types described in Appendix A, they presumably include images from the same raw data sources as GeoBench, drawn from a training split distinct from the test split.

GRPO hyperparameters. The paper specifies: group size $G$ is set implicitly through the global batch size of 64 with mini-batches of 32. The constant learning rate is $1 \times 10^{-6}$. KL regularization is disabled. The maximum number of interaction turns per rollout is capped at 6. The maximum context length is set to 32K tokens (to avoid out-of-memory errors from overlong trajectories combining images, search results, and multiple turns of reasoning). Concurrent workers are implemented for tool interactions during rollouts to accelerate training—this means multiple rollout environments run in parallel, each handling the tool execution for one trajectory, reducing the wall-clock time of generating groups of responses.

---

Training Recipe and Infrastructure

Base model. All training starts from Qwen2.5-VL-7B-Instruct, a 7-billion-parameter vision-language model with instruction fine-tuning. The model uses a vision encoder (the specific architecture is not detailed in the paper, but Qwen2.5-VL uses a ViT-based vision encoder) and a language model decoder, with cross-attention or similar mechanisms to integrate visual and textual information.

SFT configuration (Section 4). The supervised fine-tuning uses:

• Training data: approximately 2,000 cold-start reasoning trajectories.
• Epochs: 1 epoch only—the small dataset with a single pass prevents overfitting while being sufficient to imprint the tool-use pattern.
• Maximum context length: 32,768 tokens. This is set "to avoid out-of-memory error caused by overlong trajectories." Multi-turn trajectories with high-resolution images, multiple zoomed crops, and web search results can easily exceed context limits; 32K tokens accommodates the typical 6-turn interaction depth.
• Learning rate: $1 \times 10^{-5}$, a standard fine-tuning rate.
• Global batch size: 32. With 2,000 examples and batch size 32, one epoch consists of approximately 63 gradient updates, making this a very light SFT stage.

RL configuration (Section 4). The reinforcement learning stage uses:

• Training data: 12,000 samples (images with ground-truth location metadata).
• Global batch size: 64, with mini-batches of 32. The global batch size of 64 determines how many questions are processed in parallel across all workers; within each question, $G$ responses are generated. The paper doesn't explicitly state $G$, but typical GRPO implementations use $G$ equal to the number of rollouts per question, often 4–16. With global batch 64 and mini-batch 32, this suggests 2 mini-batches per update.
• Learning rate: $1 \times 10^{-6}$, constant throughout training. This is an order of magnitude lower than the SFT learning rate, reflecting the sensitivity of RL training—larger learning rates can cause policy collapse where the model rapidly diverges from useful behavior.
• KL regularization: explicitly removed ("we deprive[d] the KL regularization"). This is a non-standard choice; most GRPO/PPO implementations include a KL penalty to constrain policy updates. The paper relies entirely on the clip mechanism to prevent divergence.
• Turn limit: 6 maximum interaction turns per rollout.
• Context length: 32K tokens maximum, same as SFT.
• Concurrent workers: multiple parallel rollout environments execute tool interactions simultaneously. This is critical for training throughput because web search API calls introduce latency—without parallel workers, each rollout would wait for search results sequentially, making training impractically slow.

The tool execution during RL rollouts. A key implementation detail: during each RL rollout, the model's generated actions are actually executed against the real tools. Crop-and-zoom operations are performed on the actual images; web search queries are sent to a live third-party search API. This means:

1. The RL training cost includes real API usage for web search (the paper notes this as a reason for not sweeping $\beta$ values).
2. The model learns from actual web search results, not simulated ones, which means it experiences the stochasticity and variability of real search—some queries will return excellent results, others will be unhelpful.
3. The concurrent worker infrastructure must handle API rate limits, timeouts, and error responses gracefully.

Failed tool calls during RL. The paper tracks the "error tool-call rate" during RL training (Section 5.3.3). Errors arise from:

• Invalid bounding box parameters for crop-and-zoom (e.g., x_min > x_max, coordinates outside the image dimensions).
• Incomplete or malformed JSON format for tool calls.

An interesting observation: "although we do not directly optimize tool-call behavior during RL, the model gradually produces fewer erroneous tool calls, showing a clear decreasing trend in error rate as training progresses" (Figure 7, right). The paper hypothesizes that the mechanism is indirect: "erroneous tool calls reduce the model's likelihood of reaching the correct answer within limited turns, leading the model to implicitly learn to avoid such errors in its reasoning trajectories." This is a form of emergent behavior—the RL objective doesn't penalize malformed tool calls per se (they just fail and produce no useful observation), but trajectories with failed tool calls are less likely to produce correct answers, so the policy gradient naturally suppresses them.

The RL scaling experiment (Section 5.3.2). To probe the data scaling properties of the RL stage, the paper trains the model (from the same cold-start SFT checkpoint) with varying amounts of RL data: 1,500, 3,000, 6,000, and 12,000 samples. Performance is measured on a validation set of 512 panoramas. The result: "a nearly perfect data-scaling effect" when plotting data size on a logarithmic scale against performance (Figure 7, left)—performance increases log-linearly with RL data scale, suggesting that the model has not saturated at 12k samples and could benefit from further data scaling.

This log-linear relationship is significant because it mirrors the scaling laws observed in pretraining and instruction tuning, suggesting that RL-based reasoning improvement follows predictable scaling trends. It also implies that the 12k sample budget was chosen based on practical constraints (search API cost, training time) rather than performance saturation—more data would likely yield further improvements.

Why no KL regularization. The paper's decision to remove KL regularization from GRPO is noteworthy. In standard PPO, the KL penalty $\beta_{\text{KL}} \cdot D_{\text{KL}}(\pi_{\theta_{\text{old}}} \| \pi_\theta)$ is added to the objective to prevent the policy from changing too drastically. The paper's rationale is not explicitly stated, but the likely reasoning is: the SFT stage already provides a strong prior on the policy distribution, and the RL stage is intended to optimize within a narrow basin around that prior. The clipping mechanism alone may provide sufficient constraint. However, removing KL regularization carries risk: without it, the policy can theoretically diverge further from the SFT checkpoint in a single update if the advantage estimates are noisy. The fact that the training remains stable (as evidenced by the improving validation performance and decreasing error rate) suggests that the clip mechanism and the small learning rate together provide adequate stability in this setting, but this may not generalize to other tasks or base models.

4. Key Insights and Innovations

Innovation 1: Geolocalization as a Diagnostic for the Missing Axis in Agentic Visual Reasoning

The paper's most fundamental intellectual move is not proposing a new architecture or training algorithm, but rather identifying geolocalization as the precise task that exposes a blind spot in the entire "thinking with images" research program. This is a diagnostic contribution: by selecting a problem that cannot be solved with image manipulation alone, the paper reveals what the field has been systematically ignoring.

Before this work, the dominant paradigm in agentic visual reasoning—from Visual CoT through OpenAI o3 to open-source replications like mini-o3 and DeepEyes—treated tool augmentation as synonymous with image manipulation. The implicit assumption was that the visual world is self-contained: if you can zoom into enough detail, rotate to the right angle, and annotate the right regions, the answer will emerge from visual information alone. The paper's core challenge to this assumption is that some tasks require knowledge that is not present in the image at any resolution. A business sign in a photo contains text; the model can zoom in and read it perfectly—but knowing where in the world that business exists is not a visual problem. It is a knowledge retrieval problem.

The significance of this move extends beyond the specific tools GeoVista uses. The paper is arguing for a functional taxonomy of agentic reasoning: image-manipulation tools address what is in the image, while retrieval tools address what the image means. Prior work conflated these under a single "tool use" umbrella, but they serve fundamentally different cognitive functions. Zooming into a building's distinctive cornice tells you what it looks like; searching for buildings with that cornice tells you where it might be. The reasoning loop is not just "look harder" but "look, then know, then look differently based on what you now know."

The paper's selection of geolocalization is itself a contribution to experimental design in agentic reasoning research. Prior tasks for evaluating visual reasoning agents (VQA variants, visual grounding, document understanding) do not structurally require web retrieval—good visual inspection is often sufficient. Geolocalization is a forcing function: if a model cannot search the web, its performance ceiling on genuinely novel images (not landmark photos memorized during pretraining) is set by whatever geographic knowledge was incidentally encoded during training. The GeoBench construction—with its deliberate removal of landmarks and non-localizable images—creates a benchmark where web search is not optional but essential. Table 1 demonstrates this design choice quantitatively: prior benchmarks lacked the combination of high resolution, localizability control, and hierarchical evaluation that makes web-augmented reasoning both necessary and measurable.

This is a fundamental reframing, not an incremental improvement. It changes the question from "how can we make models better at using visual tools?" to "what tools does a reasoning system need to transcend its training data?" The answer—external knowledge retrieval—has implications far beyond geolocalization, extending to medical diagnosis (retrieving case literature), scientific reasoning (searching for experimental protocols), and forensic analysis (looking up regulations and precedents).

Innovation 2: Two-Stage Training as a Solution to the Tool-Use Bootstrapping Problem

The paper's second conceptual contribution is a diagnosis of why pure RL fails to induce tool-use behavior and a corresponding two-stage training recipe that separates learning to use tools from learning to produce correct answers. This insight is grounded in a concrete empirical observation that the authors document rather than gloss over:

"We initially attempted to train the model using reinforcement learning only, removing the need for cold-start supervised fine-tuning. However, the model tended to produce overly concise responses and hesitated to make tool calls, leading to unsatisfactory performance."

This failure is instructive. It reveals that tool use is not a behavior that emerges naturally from correctness pressure alone. The RL objective rewards final answer accuracy, not the process by which the model arrives at it. If the model can achieve non-trivial accuracy on some fraction of questions through direct guessing (leveraging pretrained geographic knowledge), the RL signal does not strongly incentivize the expensive, multi-turn tool-use behavior—even though tool use would yield higher accuracy on the harder questions that the model currently gets wrong. The exploration problem is too severe: randomly discovering effective tool-use sequences within the RL credit assignment horizon is vanishingly unlikely.

Prior work in this space largely sidestepped this problem. DeepEyes (deepeyes) demonstrated that zoom behaviors can emerge from pure RL—but zooming is a single action type on a single image, not a multi-turn sequence interleaving different tool categories. The policy space for GeoVista's task (when to zoom, what to zoom into, when to search, what to search for, how to integrate results, when to stop) is combinatorially larger. The paper's insight is that this complexity requires an explicit behavioral prior—the SFT stage provides demonstrations of the reasoning pattern (not necessarily correct reasoning), which constrains the RL exploration to a subspace where useful tool-use sequences are reachable.

The deliberate choice not to filter SFT trajectories for correctness is the most subtle and important aspect of this design. If the SFT data only showed correct reasoning chains, the model would learn to imitate specific correct patterns rather than the general capability of interleaving zoom and search. By including both correct and incorrect trajectories, the SFT stage teaches that tools should be used and how to format those uses, while leaving what constitutes good tool use to be optimized by RL through correctness rewards. This is a capability–correctness decomposition that echoes the pretraining-then-fine-tuning paradigm but applied to the meta-cognitive level of tool-use strategy rather than to model weights.

The ablation study (Table 4) quantifies the necessity of both stages. Removing SFT ("w/o Cold Start") causes performance to collapse compared to the base model on most metrics, even after RL—the model never learns to use tools effectively. Removing RL ("w/o RL") leaves the model with reasonable baseline performance (median distance 11.17 km vs. 2.35 km for the full model) but far from optimal, confirming that SFT alone teaches the reasoning pattern but not how to make it accurate. The combination is necessary and synergistic.

This is a foundational training paradigm rather than a minor optimization. It addresses a general problem—inducing structured, multi-turn interaction behavior in language models—that extends beyond geolocalization to any task requiring tool orchestration. The specific instantiation (SFT on unfiltered trajectories + RL with correctness rewards) is a recipe that other agentic systems can adopt.

Innovation 3: Hierarchical Reward as Partial Credit for Geographic Reasoning

The hierarchical reward function (country=1, province=β, city=β² with β=2) appears simple, but the conceptual insight behind it is deeper than the formula suggests: geographic predictions have a natural metric structure that flat correctness rewards destroy, and exploiting this structure provides a smoother optimization landscape for RL.

To understand why this matters, consider what happens under a flat city-level reward. The model receives 1 for "Los Angeles" and 0 for "San Francisco" when the correct answer is Los Angeles—even though San Francisco is in the same state, same country, and is geographically closer than, say, "Tokyo" (which also receives 0). The RL signal treats these two errors as equivalent. The gradient that pushes the model from "Tokyo" to "San Francisco" is identical in magnitude to the gradient from "Tokyo" to "Tokyo"—zero, because all wrong answers are equally wrong. The model cannot learn to make progressively better guesses; it can only learn to be either perfectly right or completely wrong.

The hierarchical reward solves this by injecting the geographic containment hierarchy into the reward function. Country ⊃ province ⊃ city creates a natural partial ordering: getting the province right is strictly better than getting only the country right, which is strictly better than getting nothing right. The geometric progression (1, β, β²) ensures that each step up the hierarchy is worth more than the previous one—but crucially, all steps provide some signal. A model that predicts "California" for a Los Angeles photo receives reward 2 rather than 0, providing a positive gradient that encourages state-level reasoning even when city-level precision is out of reach.

The choice of β=2 is empirically motivated but theoretically significant. If β were too large, the reward gap between levels would be so extreme that the model would be punished harshly for attempting fine-grained predictions and failing—encouraging conservative, coarse-grained answers. If β were too close to 1, the levels would collapse into indistinguishability. β=2 creates a moderate gradient where each level is meaningfully better than the previous but not so much better that the model becomes risk-averse.

What makes this an innovation rather than an obvious design choice is the integration with the GRPO advantage normalization. Because GRPO standardizes advantages within each group of responses, the absolute scale of the reward function is irrelevant—only relative differences matter. The hierarchical reward's contribution is therefore not in the absolute values (1, 2, 4) but in the relative ordering it imposes across different error types. In a group of responses, the model that predicts the correct state but wrong city (reward 2) will have a higher advantage than the model that predicts the wrong continent entirely (reward 0), and this relative difference drives learning. Without the hierarchy, both would have advantage 0 and be indistinguishable.

The empirical evidence for the hierarchical reward's importance extends beyond accuracy improvements. The paper notes that the flat-reward model "makes fewer tool calls" (Figure 6, right)—a behavioral consequence that the hierarchical reward solves. When the model gets partial credit for partial correctness, it has incentive to keep reasoning and using tools even when it cannot achieve perfect accuracy. If it can narrow the location from "somewhere in Europe" to "Germany" to "Bavaria," each step earns increasing reward. Under a flat reward, once the model realizes it cannot get the exact city, there is no incentive to spend additional turns refining the answer—any wrong city is equally wrong.

This is a methodological advance with broad applicability. Any task with hierarchical or structured labels—document classification (section → chapter → book), code generation (function → module → program), legal reasoning (clause → section → statute)—can adopt analogous partial-credit reward functions. The paper provides both the principle (exploit task structure in reward design) and a concrete demonstration of its effectiveness.

Innovation 4: Verifier Over-Optimization as a First-Class Phenomenon in Test-Time Scaling

While reward hacking / over-optimization is well-documented in the RLHF literature, this paper provides some of the first clear evidence that the same phenomenon governs test-time search scaling and is the primary bottleneck preventing unbounded improvements from additional compute. The evidence is concrete: beam search degrades easy-problem performance at high budgets (Figure 3, right); lookahead search — the most powerful optimizer — paradoxically performs worst overall (Figure 3, left); and qualitative examples in Appendix M show search producing degenerate outputs (repetitive low-information steps, overly short solutions) that score highly under the PRM.

This finding is significant because it shifts the narrative around test-time compute from "more is better" to "more is better only up to the verifier's reliability frontier." It explains why prior work found negative results for sophisticated search methods: those studies likely pushed past the over-optimization threshold. It also implies that improving verifier robustness is the key bottleneck for further scaling test-time compute, not improving search algorithms. The paper's compute-optimal policy can be understood partly as a way to stay below the over-optimization threshold per difficulty level — using weaker optimization (best-of-N) where the verifier is reliable (easy problems) and stronger optimization (beam search) only where the verifier signal has more room to provide genuine guidance (medium problems).

5. Experimental Analysis

Evaluation Methodology

• Dataset. All experiments use GeoBench, a custom-curated benchmark of 1,142 high-resolution images (512 standard photos, 512 panoramas, 108 satellite images) spanning 6 continents, 66 countries, and 108 cities. Each image includes geolocation metadata with precise latitude/longitude and hierarchical labels at country, province/state, and city levels. The benchmark is designed to exclude both non-localizable images (lacking geographic clues) and trivially localizable landmarks, ensuring that localization requires genuine reasoning rather than pretraining memorization.

• Base model(s). The primary model is Qwen2.5-VL-7B-Instruct, a 7-billion-parameter vision-language model with instruction fine-tuning. This scale is deliberately chosen to test whether web-augmented reasoning can compensate for limited parametric knowledge relative to much larger closed-source models. All open-source baselines (Mini-o3-7B, DeepEyes-7B, Thyme-RL-7B) share this same 7B parameter scale, enabling fair comparison of reasoning architectures. Closed-source models (Gemini-2.5-pro, Gemini-2.5-flash, GPT-5, Seed-VL-1.6) have undisclosed but "likely far larger parameter counts than 7B" (Section 5.1).

• Metrics. Two complementary evaluation frameworks are used:

  • Level-wise accuracy: percentage of predictions correct at each administrative level (country, province/state, city), computed by combining rule-based string matching with a model-based verifier (GPT-4o-mini) for ambiguous cases. City-level accuracy is further broken out by data type (panorama, photo, satellite) to assess domain-specific performance.
  • Nuanced distance metrics: each model's predicted textual location is geocoded to coordinates via Google Geocoding API, and haversine distance (great-circle distance, in km) is computed against ground-truth coordinates. Two aggregations are reported: percentage of predictions with haversine distance < 3 km (street-level precision) and median haversine distance across all predictions (robust to catastrophic outliers).

  The 3 km threshold is notably stringent—it requires predictions to be within roughly the same urban neighborhood. The haversine formula used is $d = 2R_e \arcsin(\sqrt{v})$ where $v = \sin^2((\phi_2-\phi_1)/2) + \cos(\phi_1)\cos(\phi_2)\sin^2((\lambda_2-\lambda_1)/2)$, with $R_e$ as Earth's radius (~6,371 km). This formula is chosen for numerical stability at both small and large distances compared to alternatives like the spherical law of cosines.

• Baselines. The paper compares against:

  • Closed-source models: Gemini-2.5-pro, Gemini-2.5-flash (gemini-2.5-short), GPT-5 (OpenAI_GPT5_2025), and Seed-VL-1.6 (seed_1_6_vision). These models "are already integrating comparable tools into their internal reasoning" and are evaluated with single-turn queries.
  • Open-source vision reasoning models at 7B scale: Mini-o3-7B (mini-o3), DeepEyes-7B (deepeyes), and Thyme-RL-7B (thyme). These represent the state of the art in image-centric agentic reasoning and are given identical tool access (crop-and-zoom, web-search) for fair comparison.
  • Base model: Qwen2.5-VL-7B-Instruct without agentic training, using the same tool access. This isolates the contribution of the training pipeline from the base model's inherent capabilities.

  All open-source models use identical ReAct-style (react) thought-action-observation interaction patterns and receive identical access to the same crop-and-zoom and web-search tools.

• Generation budget / compute accounting. Compute is measured in interaction turns (pairs of thought + action + observation). All models are capped at a maximum of 6 turns per query during evaluation, matching the RL training configuration. The initial image is downsampled to a 2M pixel budget before entering the visual encoder, a compromise between preserving sufficient detail for reasoning and maintaining computational tractability. When the crop-and-zoom tool is invoked, the magnified sub-region is presented at full available resolution—the 2M limit applies only to the initial overview, not to zoomed inspections. Web search returns up to 10 textual documents per query. For closed-source models, the tools are integrated into their internal reasoning and the query is issued in a single turn, so the turn-count budget does not apply; they are evaluated under their own native tool-use protocols.

• Cross-validation / statistical protocol. The paper does not describe explicit cross-validation or statistical significance testing. The 1,142-image GeoBench test set is used as a fixed evaluation set for all reported results. Ablation studies (Table 4) use the same evaluation settings as the main results, and the RL scaling experiment (Figure 7, left) uses a separate 512-panorama validation set to avoid contaminating the GeoBench test set with training-time decisions. No confidence intervals or error bars are reported, which is a methodological weakness—with 1,132–1,142 total test images, the city-level accuracies have substantial binomial uncertainty (e.g., a 72.68% accuracy estimate has a standard error of roughly ±1.3 percentage points under simple random sampling assumptions).

---

Main Quantitative Results

Overall GeoBench Performance (Tables 2 and 3)

The headline result is that GeoVista-7B achieves 72.68% city-level accuracy on GeoBench, substantially outperforming all other open-source models and closing the gap with closed-source counterparts. The complete multi-level breakdown is reported in Table 2:

• Country-level: GeoVista-7B reaches 92.64%, trailing only Gemini-2.5-pro (97.20%) but surpassing GPT-5 (94.09%), Seed-VL-1.6 (94.31%), and Gemini-2.5-flash (90.54%). The next-best open-source model, Thyme-RL-7B, achieves only 69.61%. The base Qwen2.5-VL-7B manages 58.93%.

• Province/State-level: GeoVista-7B reaches 79.60%, again behind only Gemini-2.5-pro (86.78%) and ahead of Seed-VL-1.6 (81.61%), Gemini-2.5-flash (79.16%), and GPT-5 (77.69%). Among open-source models, the gap is even wider—Thyme-RL-7B reaches 44.31%, approximately half of GeoVista's performance.

• City-level (overall): GeoVista-7B at 72.68% beats GPT-5 (67.11%), approaches Gemini-2.5-flash (73.29%), and is competitive with Seed-VL-1.6 (70.58%). Gemini-2.5-pro leads at 78.98%. No other open-source model exceeds 33%; the base Qwen2.5-VL-7B achieves 32.57%.

City-level by data type (Table 2, columns 4–6):

• Panoramas: GeoVista-7B achieves 79.49%, exceeding all closed-source models including Gemini-2.5-pro (78.32%). This is the only data type where GeoVista surpasses the strongest closed-source model. The next-best open-source model is Thyme-RL-7B at 26.17%.
• Photos: GeoVista-7B at 72.27% is competitive with Gemini-2.5-flash (73.83%) and Seed-VL-1.6 (73.44%), and surpasses GPT-5 (67.92%). The base Qwen2.5-VL-7B manages 44.73%, and the next-best agentic open-source model is DeepEyes-7B at 42.58%.
• Satellite images: GeoVista-7B achieves 44.92%, the highest among all open-source models, but substantially behind all closed-source models. Gemini-2.5-pro leads at 88.14%, followed by Gemini-2.5-flash at 77.12%. The satellite case reveals a clear performance ceiling: even the best open-source agentic model cannot approach closed-source performance on this data type.

The large gap between satellite and ground-level imagery for GeoVista (44.92% vs. 72–79%) despite identical reasoning architecture suggests that the web-search tool is less effective for satellite images—search queries about overhead visual features (road patterns, building layouts, geographic features) may return less useful results than queries about ground-level textual and architectural cues.

Nuanced evaluation (Table 3):

• Percentage of predictions with haversine distance < 3 km: GeoVista-7B achieves 52.83%, trailing Gemini-2.5-pro (64.45%) and Gemini-2.5-flash (58.11%) but comparable to GPT-5 (55.12%) and Seed-VL-1.6 (54.00%). This means GeoVista places more than half of its predictions within roughly the same urban neighborhood—a striking result for a 7B model. All other open-source models fall below 30%; Thyme-RL-7B reaches 29.88% and Mini-o3-7B plummets to 9.57%.

• Median haversine distance: GeoVista-7B achieves 2.35 km, exceeding GPT-5 (1.86 km) and Gemini-2.5-flash (1.67 km) by a small margin, and approaching Seed-VL-1.6 (2.22 km). Gemini-2.5-pro achieves 0.80 km. In contrast, the base Qwen2.5-VL-7B has a median distance of 2,209.82 km—essentially random at continental scale—and Mini-o3-7B reaches a catastrophic 13,043.70 km, meaning most of its predictions are on the wrong side of the planet.

What the numbers actually mean. The city-level accuracy of 72.68% means GeoVista correctly identifies the exact city for nearly three-quarters of GeoBench images—images that were deliberately selected to exclude landmarks and require genuine reasoning. The median haversine distance of 2.35 km means that when GeoVista is wrong about the exact city, it is typically wrong by only a few kilometers—wrong neighborhood, same metro area—rather than by thousands of kilometers. The contrast between the base model's 2,209.82 km median distance and GeoVista's 2.35 km (a factor of ~940× improvement) demonstrates that nearly all of GeoVista's performance derives from its trained reasoning capability, not from pretrained geographic knowledge.

The performance hierarchy across closed-source models reveals that Gemini-2.5-pro is the strongest overall (78.98% city accuracy, 0.80 km median distance, 64.45% < 3 km), suggesting that Google's models may benefit from stronger geographic pretraining data (Google Maps, Street View) in addition to their agentic reasoning capabilities.

---

Ablation Studies and Robustness Checks

Cold-start SFT ("w/o Cold Start", Table 4): Removing the cold-start SFT stage and training directly with RL causes severe performance degradation. Compared to the full GeoVista-7B (median distance 2.35 km, city accuracy 79.49%/72.27%/44.92% for panorama/photo/satellite), the SFT-free model achieves median distance 55.32 km (23.5× worse) and city accuracies of 48.52%/43.63%/27.46%. While this is still substantially better than the base Qwen2.5-VL-7B (median 2,209.82 km), it confirms that RL alone cannot reliably induce the multi-turn tool-use behavior needed for geolocalization. The model learns something from RL even without SFT—it is not completely failing—but the reasoning patterns are inconsistent, the tool calls are sparse, and the accuracy is roughly halved compared to the full pipeline.

Reinforcement learning ("w/o RL", Table 4): Removing the RL stage and using only the cold-start SFT checkpoint yields median distance 11.17 km with city accuracies of 54.88%/57.23%/29.66%. This is significantly better than the SFT-free model, confirming that the SFT trajectories successfully imprint the tool-use pattern. However, the gap to the full model (11.17 km vs. 2.35 km median distance) demonstrates that SFT alone teaches the form of reasoning but not its accuracy—the model imitates the reasoning structure but does not reliably produce correct conclusions. This validates the two-stage design hypothesis: SFT provides the behavioral prior (what actions to take, when), while RL optimizes the policy toward correctness.

Hierarchical reward ("w/o HR", Table 4): Removing the hierarchical reward during RL and using only a flat city-level reward (correct city = 1, else 0) reduces performance across all metrics: median distance worsens from 2.35 km to 4.11 km, panorama city accuracy drops from 79.49% to 75.0%, photo accuracy from 72.27% to 68.95%, and satellite accuracy from 44.92% to 40.68%. The degradation is smaller than removing SFT or RL entirely, but it is consistent across all data types and metrics. Qualitatively, the paper notes that the flat-reward model "makes fewer tool calls" (Figure 6, right)—when the model receives no partial credit for getting close, it has reduced incentive to invest additional turns in refining uncertain predictions through further zoom or search. This behavioral effect is arguably as important as the accuracy numbers: the hierarchical reward does not just improve the correctness of reasoning, it incentivizes the quantity of reasoning.

RL data scaling (Section 5.3.2, Figure 7, left): Training the same cold-start SFT checkpoint with varying amounts of RL data (1,500, 3,000, 6,000, 12,000 samples) on a 512-panorama validation set reveals a log-linear relationship between data quantity and performance. The paper describes this as "a nearly perfect data-scaling effect," with performance consistently improving as data size increases. This implies that the model has not saturated at 12k samples—more RL data would likely yield further gains, limited primarily by the cost of web search API usage during rollouts.

Failed tool calls during RL (Section 5.3.3, Figure 7, right): The error tool-call rate (malformed JSON, invalid bounding box parameters) decreases monotonically during RL training, even though the RL objective does not directly penalize failed tool calls. The paper hypothesizes that this is an emergent consequence of the correctness objective: "erroneous tool calls reduce the model's likelihood of reaching the correct answer within limited turns, leading the model to implicitly learn to avoid such errors." This is a robustness check on the training dynamics rather than on final performance—it shows that RL training is stable and that tool-call formatting improves without explicit supervision.

Performance by data type (Table 2, implicit): The data-type breakdown reveals systematic differences in how GeoVista handles different imagery. Panorama accuracy (79.49%) exceeds photo accuracy (72.27%), which exceeds satellite accuracy (44.92%). This ordering is not uniform across all models: Gemini-2.5-pro achieves its highest accuracy on satellite images (88.14%), followed by panoramas (78.32%) and photos (77.54%), suggesting fundamentally different reasoning strategies. The paper does not analyze why satellite performance is low for GeoVista, but plausible explanations include: (1) satellite images lack the textual clues (signage, business names) that the web-search tool is most effective at looking up; (2) the crop-and-zoom tool is less useful for satellite images because the relevant features (road networks, city layout) span large regions rather than localized details; (3) the SFT trajectories, curated by a VLM that may perform poorly on satellite imagery, provide weaker behavioral priors for this data type.

Open-source model comparison (Table 2, bottom section): The comparison with other open-source agentic models is striking: GeoVista-7B (72.68% city accuracy) vs. Thyme-RL-7B (30.21%), DeepEyes-7B (30.56%), Mini-o3-7B (11.30%), and the base Qwen2.5-VL-7B (32.57%). All open-source models have identical tool access (crop-and-zoom + web-search) and the same 7B parameter scale, so the differences isolate the effect of training methodology. The fact that Mini-o3-7B and DeepEyes-7B perform worse than the untrained base model (20.14% and 54.20% country accuracy respectively vs. 58.93%) suggests that their image-centric reasoning training may interfere with general visual understanding when web search is introduced—their architectures may be optimized for zoom-only reasoning patterns that do not transfer well to interleaved visual-and-textual tool use. Thyme-RL-7B's 69.61% country accuracy significantly exceeds the base model's 58.93%, but its city-level performance (30.21%) remains close to the base model (32.57%), indicating that it achieves broad geographic narrowing but fails at fine-grained location identification.

---

Critical Assessment

Claim: GeoVista achieves "performance comparable to closed-source models such as Gemini-2.5-flash and GPT-5 on most metrics." This claim is supported by the evidence in Tables 2 and 3, but requires careful qualification about what "comparable" means across different metrics and data types.

Geovista matches or exceeds GPT-5 on most metrics: GeoVista achieves 72.68% city accuracy vs. GPT-5's 67.11% (Table 2), 52.83% < 3 km vs. 55.12% (Table 3), and 2.35 km median distance vs. 1.86 km—the distance metric being the one clear area where GPT-5 maintains a small edge. Against Gemini-2.5-flash, the comparison is mixed: GeoVista leads on country accuracy (92.64% vs. 90.54%), trails slightly on province (79.60% vs. 79.16%—essentially tied) and city (72.68% vs. 73.29%), and trails on both nuanced metrics (52.83% vs. 58.11% for < 3 km, 2.35 km vs. 1.67 km median distance). "Comparable" is accurate for these two models. Against Gemini-2.5-pro, however, the gaps are substantial: 72.68% vs. 78.98% city accuracy, 52.83% vs. 64.45% for < 3 km, and 2.35 km vs. 0.80 km median distance. The paper's claim of comparable performance applies to "most" closed-source models—meaning GPT-5 and Gemini-2.5-flash—but explicitly not to the strongest model.

However, the satellite image breakdown (Table 2, rightmost columns) reveals a significant qualification that the headline numbers obscure. GeoVista's 44.92% satellite city accuracy is dramatically below all closed-source models: Gemini-2.5-pro (88.14%), Gemini-2.5-flash (77.12%), Seed-VL-1.6 (61.86%), and GPT-5 (53.39%). The "comparable" claim holds only for ground-level imagery types (panorama and photo), where GeoVista's 72–79% accuracy is genuinely competitive. The overall city accuracy of 72.68% is buoyed by strong ground-level performance on the 1,024 panorama+photo images, partially compensating for the 108 satellite images where GeoVista substantially underperforms. A reader focused on satellite geolocalization would reach a very different conclusion than a reader focused on street-level or photo geolocalization.

Claim: The two-stage training pipeline (cold-start SFT + RL with hierarchical rewards) is necessary for performance. The ablation study (Table 4) provides strong evidence for this claim. Removing SFT degrades median distance from 2.35 km to 55.32 km; removing RL degrades it to 11.17 km; removing the hierarchical reward degrades it to 4.11 km. All components are individually necessary, and the degradation from removing any single component is substantial. The claim is supported.

A limitation of the ablation design, however, is that it removes entire stages rather than probing finer-grained design choices. There is no ablation on the number of SFT trajectories (is 2,000 necessary or would 500 suffice?), on the SFT trajectory curation method (what if trajectories were filtered for correctness? what if a different teacher model was used?), on the RL algorithm choice (GRPO vs. standard PPO), on the RL data size relative to the observed scaling trend, or on the specific value of β (the paper acknowledges this missing ablation explicitly). These absences are understandable given the computational cost of RL training with live web search API calls, but they mean the paper demonstrates that the components are necessary without demonstrating that they are optimal.

Claim: The hierarchical reward improves performance by providing partial credit for geographic proximity. Table 4 shows the hierarchical reward improves median distance from 4.11 km to 2.35 km and city accuracy by 3–5 percentage points, depending on data type. The evidence supports the claim quantitatively. The qualitative observation that the flat-reward model "makes fewer tool calls" (Figure 6, right) provides mechanistic support for why the improvement occurs—but this mechanistic claim is only stated, not demonstrated with detailed tool-call statistics. The paper does not report the average number of tool calls per trajectory for the hierarchical vs. flat-reward models, or the distribution of tool types (zoom vs. search), which would strengthen the argument that hierarchical rewards specifically incentivize more extensive reasoning.

Genuine weaknesses and missing evaluations:

• No error analysis across difficulty levels. GeoBench was constructed with localizability filtering to ensure images are neither trivially easy nor impossible. However, within the "localizable" middle ground, there is presumably substantial variation in difficulty—some images contain abundant textual clues (multiple business signs in clear languages), while others contain only subtle environmental cues (vegetation patterns, architectural styles without text). The paper reports no breakdown by difficulty, which would reveal whether GeoVista's gains are concentrated on "easy-localizable" images (those with searchable text cues) or extend to the hardest cases. This matters for understanding whether the approach works by enabling genuinely novel reasoning or by efficiently exploiting web search for text-rich images.

• No comparison against a non-agentic web-search baseline. A simpler architecture would be: extract visual features from the full image, use them to generate a single web search query, and reason about the location from those search results—without iterative zoom-in or multi-turn refinement. Such a baseline would isolate the contribution of the iterative, interleaved tool-use loop from the simpler contribution of any web access. If a single-turn search model achieved comparable performance, it would undermine the paper's claim that dynamic, multi-turn reasoning is essential. This baseline is absent.

• Cost and latency are not reported. The paper acknowledges that web-search API costs limited β-value experimentation and that concurrent workers were needed for training throughput, but no quantitative cost or latency measurements are reported for inference. A query that involves 6 turns with multiple web searches and image crops has very different deployment characteristics than a single forward pass of GPT-5 or Gemini. The paper's central value proposition—smaller model + tool use = comparable performance—is less compelling if the tool-use process is substantially slower or more expensive per query than simply querying a larger model.

• Single model family, single benchmark. All experiments use Qwen2.5-VL-7B-Instruct as the base model and GeoBench as the evaluation benchmark. There is no evidence that the training pipeline transfers to other base models (e.g., LLaVA, InternVL) or other geolocalization datasets. The selection of Qwen2.5-VL is not justified beyond being "representative." If the base model has unusually poor geographic pretraining knowledge, the relative benefit of web search would be artificially inflated—a base model with stronger world knowledge might need less web search, reducing the apparent benefit of the agentic approach.

• Geocoding dependency. The nuanced evaluation relies on Google Geocoding API to convert predicted text locations to coordinates. If the geocoding service has geographic biases (better coverage in wealthy countries, better handling of English-language addresses), the haversine distance metrics would systematically penalize models that predict locations in under-served regions or in non-English naming conventions. The paper does not discuss or control for this potential bias.

• Missing confidence intervals. With 1,142 test images, accuracy estimates have non-trivial uncertainty. The difference between GeoVista's 72.68% city accuracy and Gemini-2.5-flash's 73.29% (a gap of 0.61 percentage points) is almost certainly not statistically significant at this sample size. The paper's ordering of models by raw accuracy without uncertainty quantification risks over-interpreting small differences. This is particularly relevant for claims of "matching" or "surpassing" closed-source models—most of these matches fall within plausible sampling error.

Experiments that would have strengthened the paper:

• Ablation on the number of SFT trajectories to characterize how much behavioral prior is needed.
• Ablation on different teacher models for trajectory curation to test whether the SFT behavior is robust to the choice of teacher VLM.
• Component-wise tool ablation (e.g., zoom-only, search-only) to isolate the contribution of each tool to overall performance, which would directly test the paper's core claim that both visual inspection and web retrieval are necessary.
• Latency and cost measurement for representative queries, to contextualize the accuracy gains against deployment feasibility.
• A non-agentic web-search baseline as described above.
• Difficulty-stratified results within GeoBench to characterize where the model succeeds and fails.
• Replication on a different base model to assess generalizability of the training recipe.

6. Limitations and Trade-offs

Limitation 1: Satellite Imagery Performance Collapses Relative to Ground-Level Imagery

The assumption or constraint. GeoVista's training pipeline and tool set treat all image types uniformly—the same SFT trajectories, the same RL reward, the same crop-and-zoom and web-search tools. The paper implicitly assumes that the reasoning strategy effective for ground-level photos and panoramas transfers to satellite imagery. This assumption breaks.

The consequence. GeoVista achieves 44.92% city-level accuracy on satellite images versus 72.27% on photos and 79.49% on panoramas (Table 2). The gap to closed-source models on satellite images is dramatic: Gemini-2.5-pro reaches 88.14%, Gemini-2.5-flash reaches 77.12%, GPT-5 reaches 53.39%. Even the base Qwen2.5-VL-7B (16.10% satellite accuracy) and DeepEyes-7B (24.58%) establish a floor that GeoVista only modestly exceeds. The 44.92% satellite accuracy means GeoVista fails to identify the correct city for more than half of satellite images—a failure rate that undermines any claim of general geolocalization capability.

The likely mechanism is that satellite images lack the textual cues (signage, business names, street signs) that make the web-search tool effective for ground-level imagery. A crop-and-zoom on a satellite image reveals road layouts, building footprints, and vegetation patterns—features that are hard to formulate as effective web search queries. "Checkerboard road network with rectangular building blocks" is not a query that returns "Barcelona" with high reliability. The crop-and-zoom tool's value is also diminished: on ground-level photos, zooming into a small region (a sign, a building facade) can yield decisive information; on satellite images, the relevant geographic signals (overall city structure, regional topography) span the entire image, making localized zooming less informative.

What evidence exists in the paper. Table 2 provides the satellite accuracy breakdown, showing GeoVista at 44.92% versus closed-source models at 53–88%. The paper offers no analysis of why satellite performance lags, no examples of satellite reasoning trajectories, and no ablation studying whether different tool designs (e.g., rotation or scale tools for satellite imagery) would help. The SFT trajectory curation used a VLM that may itself perform poorly on satellite images—if the teacher cannot produce coherent satellite geolocalization trajectories, the student receives a weak behavioral prior for this data type. The paper does not report satellite-specific trajectory quality or quantity.

Mitigation status. The paper does not address this limitation. Section 8 (Conclusion) does not mention satellite-specific challenges, and no future work is proposed to close the satellite gap. The uniform treatment of all data types is presented as a feature (demonstrating generalizability across varied data conditions) rather than as a potential source of failure. A practitioner deploying GeoVista for satellite geolocalization would need to develop substantially different tool designs, training data, or reward structures—none of which are explored in this work.

---

Limitation 2: Web Search Cost and Latency Are Unmeasured but Dominant

The assumption or constraint. The paper treats "number of interaction turns" as a proxy for inference compute, but web search API calls have qualitatively different cost and latency profiles than model forward passes or image crops. The paper acknowledges this in passing—"reinforcement learning incurs substantial cost, particularly due to search API usage" (Section 3.4)—but never quantifies it. The headline comparison of GeoVista-7B against closed-source models (Tables 2, 3) reports accuracy and distance metrics without any corresponding cost or latency numbers.

The consequence. The paper's central value proposition—a 7B model rivaling much larger closed-source models through tool use—cannot be evaluated by practitioners without understanding what that tool use costs. A single GeoVista inference may involve up to 6 interaction turns, each potentially including one web search (returning up to 10 documents) and one crop-and-zoom operation. Web search APIs charge per query and introduce network latency on the order of hundreds of milliseconds to seconds per call. If a typical GeoVista trajectory involves 3–4 web searches, the wall-clock inference time might be several seconds longer than a single forward pass of GPT-5 or Gemini, and the per-query API cost might approach or exceed the inference cost of a larger model.

The latency issue is particularly consequential for the paper's motivating applications. Disaster response and investigative journalism scenarios require timely answers—a model that takes 30 seconds per image because of serial web search dependencies may be impractical regardless of accuracy. The paper's acknowledgment that training required "concurrent workers for interactions with tools during rollout to accelerate training" (Section 4) reveals that tool interaction latency was already a bottleneck during training; inference would face the same serial dependency without the parallelization that training can amortize across batch rollouts.

What evidence exists in the paper. None. The paper reports no inference latency measurements, no web search API cost estimates, and no throughput numbers. The RL training description mentions that "search API usage and the computational overhead of response-group rollouts" prevented experimenting with additional β values (Section 3.4), indirectly revealing that costs are non-trivial. The concurrent worker infrastructure for RL rollouts (Section 4) further implies that serial tool execution is too slow for practical use at scale. But these are qualitative hints, not quantitative evidence.

Mitigation status. Not addressed. The paper does not report cost or latency, does not discuss caching strategies for web search results (which could reduce API usage for repeated queries about the same image features), does not explore whether fewer search queries or abbreviated search results would suffice, and does not compare GeoVista's total inference cost to the cost of querying a larger closed-source model. The "comparable performance" claim is accurate for accuracy metrics but incomplete for deployment decisions—a practitioner choosing between GeoVista-7B and GPT-5 needs to know the cost-performance tradeoff, and the paper provides only half of that equation.

---

Limitation 3: Difficulty Estimation Cost Is Unaccounted and Potentially Prohibitive

The assumption or constraint. GeoBench was constructed with explicit localizability filtering—removing both non-localizable images and easily localizable landmarks—to ensure that images require genuine reasoning. However, this filtering was performed using model-based classifiers (VLM judgments of whether an image contains geographic clues or depicts a recognizable landmark; Section 3.2). The paper provides no analysis of how GeoVista performs across varying difficulty levels within the remaining "localizable" images.

The consequence. The overall 72.68% city accuracy masks what is almost certainly substantial difficulty-dependent variation. Images with abundant textual clues (multiple clear business signs in recognizable languages, prominent street names) are fundamentally different from images with only subtle environmental cues (vegetation patterns, architectural styles without text, ambiguous terrain). The former enable highly effective web search queries ("Café Central, Vienna"); the latter require the model to reason about visual patterns that are far harder to translate into searchable terms. If GeoVista's performance is concentrated on text-rich images and collapses on text-sparse ones, the approach is less a general geolocalization solution and more a sophisticated text-extraction-and-search pipeline.

This difficulty dependence matters for the paper's broader claim that geolocalization demonstrates a "new axis for agentic multimodal reasoning." If the primary mechanism of success is reading text from zoomed-in regions and searching for that text on the web, then the reasoning component—formulating hypotheses, cross-referencing clues, integrating multiple ambiguous signals—may be far less important than the architecture suggests. The paper does not provide the granularity of analysis needed to distinguish these accounts.

What evidence exists in the paper. The data-type breakdown (Table 2) provides indirect evidence of difficulty dependence. Satellite images—which lack text entirely—show dramatically lower GeoVista performance (44.92%) than ground-level photos (72.27%) despite identical tools and training. This suggests that the absence of searchable textual cues is a major performance driver. However, within ground-level photos, there is no analysis: the paper does not report performance for images with versus without visible text, with versus without distinctive architecture, in urban versus rural settings, or across different geographic regions (which may have varying levels of internet documentation in languages the web search tool indexes well).

Mitigation status. Not addressed. The paper does not report any difficulty-stratified results within GeoBench, does not analyze what types of clues GeoVista successfully exploits, and does not characterize failure modes beyond the data-type aggregate. The absence of this analysis leaves open the possibility that GeoVista's strong overall performance is driven by a subset of images that are effectively text-retrieval problems, while genuinely ambiguous images—the ones most in need of agentic reasoning—remain largely unsolved. The paper's concluding claim that it "lays a solid foundation for future research on agentic visual reasoning" is undermined by the lack of clarity about what the model is actually doing when it succeeds.

---

Limitation 4: Single Model Family and Benchmark Limit Generalizability Claims

The assumption or constraint. All experiments use Qwen2.5-VL-7B-Instruct as the base model and GeoBench as the sole evaluation benchmark. The paper states that Qwen2.5-VL is "representative of the capabilities of many contemporary LLMs" (implied in Section 5.1), but this is an unverified assertion. GeoBench was constructed by the same team that built GeoVista, using their own localizability filtering criteria, hierarchical label design, and evaluation pipeline.

The consequence. The paper cannot distinguish between properties of GeoVista's training pipeline and properties of the specific base model. Qwen2.5-VL-7B may have unusually poor geographic pretraining knowledge relative to its visual reasoning capabilities—making web search appear disproportionately beneficial because the base model's parametric knowledge is weak. A model with stronger built-in world knowledge (e.g., a model trained on geographically diverse data with explicit location metadata) might need far less web search, reducing the apparent advantage of the agentic approach. Conversely, Qwen2.5-VL-7B may have unusually strong visual grounding capabilities that transfer well to the crop-and-zoom tool, making GeoVista's tool-use training appear more effective than it would be on a model with weaker vision-language alignment.

The single-benchmark evaluation compounds this uncertainty. GeoBench was designed specifically to require web-augmented reasoning—it excludes landmarks and non-localizable images. This makes it an excellent diagnostic for the specific capability GeoVista targets, but it also means the benchmark is optimized for GeoVista's strengths. Performance on GeoBench measures exactly what the training pipeline was designed to achieve. There is no evidence that the training pipeline produces a model that generalizes to other geolocalization benchmarks (OSV-5M, Im2GPS, GeoComp), to other visual reasoning tasks that benefit from web search (medical image interpretation, satellite image analysis for environmental monitoring, fashion or product identification), or to other base model architectures.

The closed-source model comparisons further complicate generalizability. Gemini-2.5-pro's 88.14% satellite accuracy versus GeoVista's 44.92% (Table 2) suggests fundamentally different capabilities on overhead imagery. If Gemini-2.5-pro achieves this through stronger pretraining rather than reasoning, then GeoVista's approach cannot close the gap through better tool use—the missing capability is parametric, not procedural. But without testing on a different base model, this hypothesis is untestable.

What evidence exists in the paper. The paper contains no experiments on any base model other than Qwen2.5-VL-7B-Instruct, and no evaluation on any benchmark other than GeoBench. The RL scaling experiment (Section 5.3.2, Figure 7, left) uses a 512-panorama validation set drawn from the same data sources as GeoBench, not an external dataset. The open-source baselines (Mini-o3-7B, DeepEyes-7B, Thyme-RL-7B) are all also 7B-scale models—the comparison demonstrates GeoVista's superiority among 7B agentic models for this specific benchmark, but provides no evidence about transfer to other scales, architectures, or tasks.

Mitigation status. The paper does not acknowledge this as a limitation. No future work is proposed to test GeoVista on alternative base models or benchmarks. The concluding claim that the work "lays a solid foundation for future research on agentic visual reasoning and real-world geolocalization" (Section 6) treats the single-model, single-benchmark results as a general contribution without caveat. A practitioner considering whether the GeoVista training recipe would work for their base model (e.g., LLaVA, InternVL2) or their geolocalization task (e.g., rural imagery, historical photos, user-generated content from underrepresented regions) has no evidence to guide that decision.

---

Limitation 5: No Component-Wise Tool Ablation to Isolate Zoom Versus Search Contributions

The assumption or constraint. The paper's core claim is that web-augmented agentic reasoning—interleaving image-zoom-in and web-search tools—enables performance that neither tool alone could achieve. The introduction frames this as the central insight:

"these works only emphasize image manipulation during multimodal reasoning, thus making problem-solving rely solely on the model's inherent knowledge and lacking appropriate access to external information retrieval tools like web search."

The consequence. Without a component-wise ablation, it is impossible to determine whether GeoVista's performance gains come primarily from web search (looking up visual clues), from iterative zooming (finding better visual clues to look up), or from the specific interleaving of both. A model that simply zooms into a few promising regions, extracts all visible text, performs a single web search, and reasons from the results might achieve comparable performance. If so, the paper's emphasis on dynamic, multi-turn interleaving would be overstated—the agentic loop would be a complex solution to a problem that simpler orchestration could solve.

This matters for both scientific understanding and practical deployment. If web search alone accounts for most of the gain, then the expensive crop-and-zoom reasoning infrastructure (bounding box prediction, image processing, multi-turn context accumulation) adds complexity without proportional benefit. If zooming without search accounts for most of the gain, then the web-search integration—with its API costs and latency—is unnecessary. If the interleaving is essential, the paper should demonstrate this directly.

What evidence exists in the paper. The paper provides no zoom-only or search-only baselines. The ablation study (Table 4) removes entire training stages (SFT, RL, hierarchical reward) but does not remove individual tools. The open-source baselines (Mini-o3-7B, DeepEyes-7B, Thyme-RL-7B) are given identical tool access (both zoom and search), so their lower performance cannot disentangle tool contributions—their poor performance could reflect weak zoom usage, weak search usage, or weak integration of both. The base Qwen2.5-VL-7B also has access to both tools; its poor performance (32.57% city accuracy) establishes that tool access alone is insufficient, but does not identify which tool matters more.

The closest the paper comes to a tool ablation is comparing across data types: satellite images (where search is less useful due to absence of text) show dramatically lower GeoVista performance (44.92%) than ground-level imagery (72–79%). This suggests that when search is less effective, overall performance suffers, indirectly implicating web search as a major driver of success—but this is a correlational observation across data types, not a controlled ablation within a single data type.

Mitigation status. Not addressed. The paper does not report zoom-only or search-only experiments, does not acknowledge this gap, and does not propose such experiments as future work. This is a significant omission for a paper whose central contribution is the claim that combining these two specific tool types—and interleaving them dynamically—enables a new capability axis.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not introduce a fundamentally new architecture or algorithm. Rather, it makes a diagnostic contribution that reframes the agentic visual reasoning research program: it identifies web-augmented retrieval as the missing axis that prior "thinking with images" work systematically ignored, and it provides both a benchmark (GeoBench) and a training recipe (cold-start SFT + hierarchical RL) that make this axis experimentally tractable.

The magnitude of this shift is best characterized as a reframing with methodological consequences. Before this paper, the dominant paradigm in agentic visual reasoning—from OpenAI o3 through open-source replications like mini-o3, DeepEyes, and Thyme—equated tool augmentation with image manipulation. The implicit assumption was that visual reasoning is about extracting progressively finer information from pixels: zoom in, rotate, crop, annotate. This paper's central challenge is that some visual reasoning tasks require knowledge that is not in the image at any resolution, and that without web retrieval, even the most sophisticated zoom-and-crop agent hits a hard ceiling determined by whatever facts were incidentally memorized during pretraining.

The paper does not argue that image manipulation tools are unimportant—GeoVista uses a crop-and-zoom tool extensively. Rather, it shows that the two tool categories occupy different functional roles in reasoning. Image manipulation answers "what is in the image"—it addresses the perception problem. Web retrieval answers "what does this image content mean in the world"—it addresses the interpretation problem. Prior work conflated these under a single "tool use" umbrella, but they serve fundamentally different cognitive functions. This insight is likely to influence how future agentic systems design their toolkits: not just "what operations can we perform on the input?" but "what external knowledge sources are needed to make sense of the input?"

The paper also provides the first systematic evidence that geolocalization is the right diagnostic task for this capability. Prior geolocalization benchmarks (Im2GPS, OSV-5M, GeoComp) were designed for either retrieval-based or reasoning-without-tools evaluation. GeoBench is the first benchmark specifically constructed to require both fine-grained visual inspection and web knowledge retrieval, through its deliberate filtering of landmarks (too easy—pretraining memorization suffices) and non-localizable images (too hard—no reasoning can succeed). This makes GeoBench a forcing function: if a model performs well on it, we can be confident it is genuinely interleaving visual and retrieval reasoning, not just doing one or the other well.

A secondary but important shift is the reconciliation of the tool-use bootstrapping problem. The field has seen conflicting evidence about whether models can learn tool use through RL alone. DeepEyes showed that zoom behaviors emerge from pure RL on visual tasks. But GeoVista's authors found that "the model tended to produce overly concise responses and hesitated to make tool calls" when RL was applied directly to the more complex interleaved zoom-and-search task. The paper's resolution—that the combinatorial complexity of the action space matters, and that explicit behavioral priors become necessary when the tool-use sequence involves multiple heterogeneous tool types—provides a more nuanced understanding than "RL does or does not work for tool use." It suggests that the search space for tool orchestration grows combinatorially with the number and diversity of tools, and that SFT demonstrations become increasingly necessary as tool diversity increases.

Which research directions become more attractive as a result of this paper:

• Agentic reasoning with heterogeneous toolkits. The paper makes it clear that image-centric reasoning research must expand beyond visual manipulation to include retrieval, computation, and other tool categories. The natural next step is not just "add web search to zoom" but to systematically characterize what categories of tools exist (perception tools, retrieval tools, computational tools, communication tools) and develop architectures that dynamically select among them.
• Structured reward design for hierarchical tasks. The hierarchical reward function (country=1, province=β, city=β²) demonstrates that injecting task structure into the RL reward can improve both accuracy and reasoning behavior (more tool calls). This principle generalizes to any task with hierarchical or partially ordered outputs—document classification, code generation, legal reasoning—and the paper provides a concrete template for operationalizing it.
• Scaling laws for RL-based reasoning improvement. The log-linear relationship between RL data size and performance (Figure 7, left) is a preliminary scaling law for this training regime. If it holds across tasks and models, it would provide a predictive framework for how much RL data is needed to achieve a target performance level—analogous to pretraining scaling laws but for reasoning capability.

Which research directions become less attractive:

• Pure image-manipulation agentic reasoning as a self-contained research program. If the paper's central insight is correct, then systems that can only zoom, crop, and rotate are fundamentally bounded for a broad class of tasks where external knowledge is essential. The onus is now on image-manipulation-only systems to either (a) show that their target tasks don't require retrieval, or (b) demonstrate that their parametric knowledge is sufficient to match retrieval-augmented performance. The paper's results suggest (b) is unlikely for geolocalization—GeoVista's 7B model with web search outperforms the base model (32.57% → 72.68% city accuracy) by an amount that parametric knowledge scaling alone (going to a ~14× larger model) cannot match, at least for the open-source 7B models that share the same parameter scale.
• The assumption that tool use can always be learned through RL from scratch. The failure of direct RL to induce tool use in GeoVista's setting—combined with DeepEyes' success on a simpler zoom-only task—establishes that the feasibility of pure-RL tool learning depends on action space complexity. This complicates the narrative that "RL is sufficient for emergent tool use" and suggests that for multi-tool systems, some form of behavioral prior (SFT demonstrations, curriculum learning, or constrained action spaces) may be necessary.

---

Follow-Up Research This Work Enables

Component-wise tool ablation to isolate zoom versus search contributions. The paper's central claim is that interleaving crop-and-zoom with web search enables a new axis of agentic reasoning, but it never tests the two tools separately. A direct follow-up would train three variants: GeoVista with only the crop-and-zoom tool (no web search), GeoVista with only the web-search tool (no zoom, single full-image view), and the full two-tool GeoVista, all starting from the same SFT checkpoint and RL configuration. Comparing their GeoBench performance would quantify the marginal contribution of each tool and determine whether the interleaving specifically matters, or whether independent tool use (zoom now, search later) suffices. The paper already provides indirect evidence that search matters—satellite images, which lack the textual clues that make search effective, show dramatically lower performance (44.92% vs. 72–79% for ground-level imagery; Table 2)—but a controlled within-data-type ablation would be definitive. If the zoom-only model achieves, say, 60% city accuracy and the search-only model achieves 65%, while the combined model achieves 73%, the synergy is confirmed. If the search-only model achieves 71%, the complex interleaving architecture provides minimal marginal benefit over simpler orchestration.

Difficulty-stratified performance analysis within GeoBench. GeoBench was filtered to exclude non-localizable images and landmarks, but within the remaining "localizable" middle ground, difficulty almost certainly varies widely. A follow-up study would annotate GeoBench images with fine-grained difficulty features: presence of visible text (business names, street signs, billboards), language of visible text (English, local language, mixed), urban versus rural setting, distinctive versus generic architecture, number of independent geographic clues visible, and geographic region (which affects internet documentation density in searchable languages). Stratifying GeoVista's performance by these features would reveal whether the model's success is concentrated on text-rich, search-friendly images (in which case the approach is effectively a sophisticated text-extraction-and-search pipeline) or extends to images requiring more subtle reasoning about non-textual environmental cues. This analysis is essential for understanding whether GeoVista is genuinely doing "web-augmented visual reasoning" in a deep sense, or primarily doing "read text, search text, match result." The paper's current data-type breakdown (Table 2) hints at this distinction—panoramas and photos, which contain text, show much higher accuracy than satellite images, which do not—but the within-photo variation is unexplored. A negative result here (performance collapses on text-sparse images) would not invalidate GeoVista but would precisely characterize its capability boundary.

Cross-model replication of the training pipeline. The paper trains GeoVista exclusively on Qwen2.5-VL-7B-Instruct. A critical follow-up is replicating the full pipeline—cold-start SFT on 2,000 trajectories curated by Seed-1.6-vision, then RL with GRPO and hierarchical rewards—on a different base VLM architecture at the same scale (e.g., LLaVA-1.6-7B, InternVL2-8B). Two measurements are key: (1) Does the absolute GeoBench performance transfer, or is it tied to Qwen2.5-VL's specific pretraining knowledge and visual grounding quality? (2) Does the relative improvement over the base model transfer? If GeoVista-LLaVA achieves similar absolute performance to GeoVista-Qwen, the training recipe is robust. If it achieves similar relative gain but lower absolute performance (because LLaVA has weaker geographic pretraining), the recipe works but is bounded by base model quality. If the gain collapses entirely, the recipe is specific to Qwen2.5-VL's architecture or training data. This experiment is practical because all components are open-source or documented: the trajectory curation procedure, the GRPO implementation, and the GeoBench benchmark are all available.

Scaling the RL data size beyond 12k to determine the saturation point. The paper observes a log-linear relationship between RL data size and performance from 1.5k to 12k samples (Figure 7, left), with no evidence of saturation. A natural follow-up is to extend the RL stage to 24k, 48k, or 96k samples and measure whether the log-linear trend continues, bends, or plateaus. The cost is non-trivial—each additional RL sample requires generating group rollouts with live web search API calls—but the scientific question is important: does test-time reasoning capability follow the same kind of predictable scaling laws as pretraining, and if so, what is the compute multiplier for reasoning data versus pretraining data? If the trend continues to, say, 48k samples with another 2–3 percentage points of city accuracy, the practical implication is that organizations should budget substantially more for RL data generation than the 12k used here. If it plateaus sharply at 12k, the current budget is near-optimal and the remaining gap to Gemini-2.5-pro represents a fundamental capability difference that more RL data cannot close. The paper's acknowledgment that "search API usage and the computational overhead" limited β-value experimentation (Section 3.4) suggests the authors were already operating near practical cost limits, making this a non-trivial but scientifically important extension.

Difficulty-adaptive turn budgets. GeoVista uses a fixed maximum of 6 turns for all queries. But the paper's difficulty-dependent reasoning (implicit in the SFT trajectory curation, which includes both simple and complex reasoning chains) suggests that some images need only 1–2 turns (clear textual clue → single search → answer) while others need the full 6 and might benefit from more. A follow-up would train a variant where the RL reward includes a small penalty proportional to the number of turns used, incentivizing the model to learn when to stop rather than always using the maximum budget. The evaluation would measure both accuracy and average turns per query. If the model can achieve comparable accuracy with, say, 3.5 average turns instead of 6, the effective inference throughput (and API cost) improves by nearly 2×. This directly addresses the paper's unmeasured cost and latency limitations. A stronger version would make the turn budget adaptive based on an initial difficulty estimate: for images that the base model classifies as "likely easy" (based on, say, presence of multiple clear text regions), allocate only 2–3 turns; for harder images, allocate the full 6. This connects to the paper's own difficulty awareness (via the hierarchical reward's implicit encoding of precision levels) without requiring the expensive 2,048-sample difficulty estimation procedure that the paper's structure (Section 3.4) explicitly avoids.

Generalization to non-geolocalization tasks requiring web-augmented visual reasoning. Geolocalization is the paper's chosen testbed, but the architecture—interleaved zoom and search within a single reasoning loop—should transfer to other tasks. A strong follow-up would select two or three tasks that share the structural requirement of needing both visual inspection and external knowledge retrieval. Candidate tasks include: medical image interpretation (zoom into a CT scan region, search for similar case reports or diagnostic criteria), artwork identification (zoom into a painting's signature or stylistic detail, search for artist attribution or provenance), and product authentication (zoom into a label or security feature, search for known counterfeit indicators). For each, a small benchmark (100–200 examples) would be constructed following GeoBench's design principles: high-resolution images, removal of trivially easy and impossible examples, multi-level ground-truth labels, and both categorical and continuous evaluation metrics. Training would follow GeoVista's pipeline with task-specific SFT trajectories and RL rewards. The key measurement is whether the 4× improvement over the base model (Table 4: 2,209.82 km → 2.35 km median distance, a ~940× improvement) generalizes in magnitude, or whether geolocalization is uniquely well-suited to web-augmented reasoning because geographic information is comprehensively documented on the web. This experiment would determine whether GeoVista is a geolocalization-specific system or a general-purpose web-augmented visual reasoning architecture.

---

Practical Applications and Downstream Use Cases

Disaster response and humanitarian aid localization. In the aftermath of natural disasters or conflicts, aid organizations receive large volumes of user-generated imagery (photos and videos from smartphones, social media posts) showing damaged infrastructure, stranded populations, or supply needs—often without reliable location metadata. A deployment of GeoVista could process these images through its crop-and-zoom and web-search loop: zoom into partially visible street signs, shop names, architectural features, and terrain patterns; search for matching locations; and output a geolocation prediction with a quantified uncertainty (the haversine distance distribution). The paper's 52.83% rate of predictions within 3 km (Table 3) means that roughly half of images could be localized to neighborhood-level precision, enabling responders to route aid without manual geolocation effort. The 2.35 km median distance means that even when the exact street is wrong, the prediction is typically within the same urban area—sufficient for directing search-and-rescue to the correct district. The key practical advantage is that GeoVista-7B is an open-source model deployable on humanitarian organizations' own infrastructure, avoiding dependency on closed-source APIs that may have usage restrictions, privacy concerns, or availability issues in crisis zones.

Investigative journalism and open-source intelligence (OSINT) verification. Journalists and human rights researchers increasingly rely on verifying the location of images and videos shared on social media—determining whether a claimed atrocity took place where it was alleged, or identifying the location of a covert facility from leaked imagery. GeoVista's agentic loop mirrors the manual process these investigators currently perform: zoom into details (uniform insignia, vehicle types, architectural features, vegetation), search databases and public records for matching information, cross-reference multiple clues, and iteratively refine hypotheses. The paper's 72.68% city-level accuracy (Table 2) means GeoVista can automate the initial localization for nearly three-quarters of challenging images (recall: GeoBench excludes landmarks, so these are images without obvious iconic identifiers). For an OSINT team processing hundreds of images daily, this could triage the workload—GeoVista provides candidate locations with supporting evidence (the reasoning trajectory itself, showing which clues were identified and what search results confirmed them), and human analysts focus on the 27% of cases where the model is uncertain or wrong. The fact that GeoVista achieves 92.64% country-level accuracy means it almost never catastrophically mislocalizes to the wrong continent, making its errors manageable (wrong city, same region) rather than dangerous (wrong continent, misleading investigation).

Content moderation and platform integrity at scale. Social media platforms face the challenge of detecting misrepresented locations—users claiming to be in one place while posting images from another, whether for disinformation campaigns, fraudulent fundraising, or impersonation. A content moderation pipeline integrating GeoVista could flag location inconsistencies by comparing the model's predicted location against user-provided geotags or contextual claims. With 92.64% country accuracy (Table 2), the false positive rate for country-level mismatches would be low (~7%)—meaning if GeoVista says an image is from Germany and the user claims it is from Brazil, that flag is highly likely to be genuine. The 72.68% city accuracy enables finer-grained verification: if a user claims to be documenting a protest in a specific city square, and GeoVista's prediction places the image in a different neighborhood 5 km away, the inconsistency warrants review. The key deployment consideration is throughput and cost: at up to 6 turns with multiple web searches per image, per-image processing cost must be weighed against the cost of human moderation. But for high-stakes content (political speech during elections, crisis reporting, verified accounts), automated pre-screening with GeoVista could substantially reduce the volume of manual verification needed.

---

When to Prefer This Method

The paper does not explicitly articulate a structured tradeoff against named alternative approaches (e.g., "use GeoVista when X, use a retrieval-only pipeline when Y"). The experimental comparisons in Tables 2 and 3 position GeoVista against other open-source agentic models (all using the same tool access) and closed-source models (using their native tool-use protocols), but the decision of whether to adopt GeoVista's specific architecture versus alternatives is left implicit. The paper's contribution is demonstrating that a specific training recipe (cold-start SFT + hierarchical RL) applied to a 7B base model with two specific tools (zoom + search) achieves strong geolocalization performance, but it does not compare this recipe to simpler architectures (single-turn search without zoom, zoom without search, larger base model without tools) in a way that generates a clear decision boundary. The ablation study (Table 4) shows that all components of the training recipe are necessary, but this establishes internal validity, not comparative advantage against fundamentally different approaches. A forced decision matrix would therefore be extrapolation beyond the paper's explicit claims. </example>