PAPER DEEP DIVE
Navi-Agent: Unlocalized Monocular Navigation Agent
Vision-Language Navigation in Continuous Environments (VLN-CE) requires an embodied agent to execute long-horizon instructions in unknown environments. Existing zero-shot VLN-CE systems typically maintain spatial states through geometric localization or coordinate-based representations. Recent geometry-constrained navigation removes depth and globally consistent coordinates, but maintaining persistent spatial awareness for place confirmation, progress verification, and recovery remains challenging. We present Navi-Agent, a zero-shot VLN-CE agent that constructs a coordinate-free spatial state from visual observations and executed motion histories. Navi-Agent organizes this state as a navigation topology, where nodes represent visual places and edges represent motion transitions. This representation enables observation-based approximate self-localization, task progress verification, and visual revisitation-based recovery. Navi-Agent performs closed-loop navigation by decomposing instructions into sub-goals, executing local visual navigation, and verifying visited places through the constructed spatial state. Experiments on zero-shot VLN-CE benchmark and real-world robot platforms show that Navi-Agent achieves state-of-the-art performance among geometry-constrained methods while remaining competitive with approaches relying on geometric localization.
One-line Summary
Navi-Agent navigates long-horizon instructions with a single monocular RGB camera by keeping a coordinate-free Visual Anchor Graph: nodes are six-view visual visits, edges are executed motion histories, and place confirmation, progress verification, and visual-revisitation recovery all become graph operations. On OpenNav_R2R-CE_100 it reaches 33.4% success without depth or coordinates.
Figure 1: Concept figure. Top left: metric spatial state built from RGB plus depth plus pose (localization, metric map, planning). Top right: an RGB-only reactive agent with no persistent memory. Bottom: Navi-Agent's coordinate-free visual spatial memory, a Visual Anchor Graph that stores place identities and motion histories to support place confirmation, progress verification, and visual backtracking recovery. The figure caption reads "Remember space without coordinates."
Background and Motivation
Vision-Language Navigation in Continuous Environments (VLN-CE) asks an embodied agent to execute long-horizon natural-language instructions in unknown environments, without task-specific expert trajectories. The agent must understand the instruction, perceive the scene, and select actions from a continuous observation stream. As vision-language foundation models matured, zero-shot VLN-CE became an engineering reality, with Habitat-based R2R-CE as the standard testbed.
Existing zero-shot systems have converged on one paradigm: decompose the long instruction into ordered sub-tasks, execute local actions per sub-task, and use subsequent observations to estimate progress, update memory, and decide stage transitions. The critical component is a spatial representation that associates observations across time steps: explicit BEV or voxel maps, 3D scene graphs, or landmark graphs. These let "what I see now" align with "what I saw before," supporting obstacle modeling, distance computation, and path planning.
All of those representations depend, directly or indirectly, on global coordinates: depth sensors, camera pose, odometry, or SLAM/SfM output. To probe the spatial reasoning of foundation models themselves and to loosen sensor requirements for deployment, recent work explores geometry-constrained navigation, where depth and globally consistent coordinates are unavailable. Two compensation routes exist: DreamNav compares executed actions against predicted future observations using local relative trajectories, while LightZeroNav keeps short-term observation histories and stage-level visual baselines and estimates progress by image-level comparison.
Both routes show that local visual evidence can support action selection and stage progression, yet three capabilities remain weak: deciding whether the current observation corresponds to a previously visited place, verifying whether an executed motion actually completed the intended transition, and recovering to a reliable location after deviating from the instruction. Without a persistent spatial state, all three lean on short-term memory. This is the central question of the paper: how can an agent maintain a persistent spatial state from visual observations without explicit geometric localization, verify its current place and task progress, and recover from failures through visual revisitation?
Navi-Agent answers by converting the metric-localization-based navigation topology into a navigation history topology: nodes are observed visual scenes, edges are executed motion histories. On this graph, place confirmation, progress verification, and failure recovery become retrieval and matching operations that need no coordinates. The paper claims three contributions: the first framework that builds spatial state for zero-shot VLN-CE under geometry-constrained settings; a coordinate-free topology with visual-scene nodes and motion-history edges; and a closed-loop recovery mechanism combining historical visual retrieval, motion-history backtracking, and visual matching confirmation.
Setup: The Geometry-Constrained Problem
The paper studies zero-shot VLN-CE in geometry-constrained indoor environments with a single forward-facing RGB camera. The agent starts from an episode-specific pose and navigates to the goal described by instruction $I$ without depth or metric coordinates. At time $t$, given observation $o_{t}$, the policy selects
$$a_{t}=\pi(o_{t},I,\mathcal{M}_{t})\in\{\texttt{move\_forward},\texttt{turn\_left},\texttt{turn\_right},\texttt{stop}\}$$leveraging a memory graph $\mathcal{M}_{t}=(\mathcal{A}_{t},\mathcal{E}_{t})$ of visual anchor nodes $\mathcal{A}_{t}$ and executed motion edges $\mathcal{E}_{t}$. The objective is to issue stop within the target distance threshold. The information protocol is strict: depth, absolute pose, odometry, SLAM/SfM coordinates, and global metric maps are unavailable; simulator pose is used only by the evaluator for distance computation.
Action granularity follows R2R-CE conventions: a forward step is 0.25 m, each turn is 10 degrees, and each episode is capped at 500 actions; success requires stopping within 3 m geodesic distance of the goal. All system components are off-the-shelf modules without task-specific fine-tuning: GroundingDINO and SAM for RGB target localization and segmentation, ViNT for local navigation, KLT for visual point tracking, and frozen LLM/VLM backbones for language reasoning and view ranking. The contribution is therefore not any single perception module but the memory-and-verification structure that organizes them into a closed loop.
Method in Depth
Figure 2: System overview. A long-horizon instruction is decomposed into ordered typed sub-goals. For each active sub-goal, SelectTarget ranks six RGB views with a VLM and grounds the chosen visual target (floor mask, trackable point, ViNT goal crop); ExecuteLocal performs the motion segment via point tracking and ViNT. Each physical stop is registered into the coordinate-free visual anchor graph, whose nodes store RGB views, semantic signatures, place identities, and visit contexts, and whose edges record executed motion. Associate labels each new visit Same/New/Ambiguous, VerifyProgress decides Commit/Intermediate/Wrong/Uncertain, and on verification failure the agent explores alternatives or backtracks along recorded edges to re-confirm the parent place.
Navi-Agent organizes long-horizon navigation as a sequence of verifiable local loops. Instead of asking a VLM to predict actions directly, the agent identifies the active sub-goal, selects an executable visual target, runs a point-tracking-guided motion segment, and verifies the visited place against the instruction. Only a verified stage advances the instruction; otherwise the observation is retained for exploration or backtracking. Algorithm 1 makes this loop explicit and is the skeleton of the whole paper.
1. Instruction Decomposition
At the start of an episode, a frozen LLM implements $\textit{Decompose}(I)$ and converts the instruction into an ordered sequence
$$G=\{g_{1},\ldots,g_{N}\}$$Each sub-goal describes an independently observable event: reaching an object, entering a room, passing a doorway, or following a direction. It stores a completion type (for example room_enter, portal_traverse, portal_stop), target entities, a spatial relation or direction, an ordinal, and a top instruction-grounded visual query. The paper's running example splits "turn left and walk straight across the kitchen and through the storage area, once out turn right and stop at doorway" into three sub-goals with queries "kitchen entrance doorway," "storage area entrance," and "doorway on the right." The controller advances to the next sub-goal only after VerifyProgress returns Commit_stage, so decomposition is a hard state machine rather than a soft prompt.
2. Visual Target Selection
For an active sub-goal $g_{i}$, SelectTarget converts language into an executable visual target. The agent rotates in place and captures six canonical RGB views separated by 60 degrees. A VLM ranks these views using the sub-goal description, target entities, spatial relations, and traversability cues, then selects a candidate direction. Additional nearby views at plus or minus 30 degrees refine the selection and produce the target image $v$ for local execution.
Figure 3: Two-stage SelectTarget. (a) Six canonical views captured by rotating in place; the VLM ranks them with the sub-goal text and walkable-route evidence, green marking the Rank-1 departure view and yellow the Rank-2 view. (b) Refinement over three views at plus or minus 30 degrees around the coarse pick, with the 0-degree view selected.
Open-vocabulary detection and segmentation (GroundingDINO plus SAM) then localize object instances in $v$; for doorways, corridors, and stairs a floor mask supplies traversable regions. The function outputs $(v,p)$, where $p$ is a trackable point in the selected RGB observation. The paper stresses that this is a visual reference, not a coordinate-defined waypoint: it has no coordinates, only the operational semantics of "follow it in the image."
3. Local Execution
$\textit{ExecuteLocal}(v,p,g)$ initializes a KLT point tracker and feeds a crop around $p$ to the pretrained ViNT local navigator. The tracker updates the point in each RGB frame and the goal crop follows it, letting ViNT choose forward and turning actions from the current visual state. The module performs short-range continuous motion and does not plan the long-horizon instruction. In Algorithm 1 the two per-iteration updates are
$$(v,p)\leftarrow\textit{SelectTarget}(o_{t},g,\mathcal{M})$$ $$(s_{\mathrm{exe}},o_{\mathrm{stop}},a_{\mathrm{local}})\leftarrow\textit{ExecuteLocal}(v,g)$$Arrival is triggered entirely by point-tracking geometry, one of the cleanest design decisions in the paper: for object, floor, and route points, when a valid tracked point moves downward and exits through the bottom boundary of the RGB observation ("bottom_exit"), the agent has arrived at the selected local visual target, and ExecuteLocal returns $s_{\mathrm{exe}}=\texttt{Arrival}$ together with the local action sequence $a_{\mathrm{local}}$ and the stop observation $o_{\mathrm{stop}}$. VLM inference, depth estimation, and simulator pose never trigger this event; it only marks the end of local visual motion, and task completion is decided after the physical stop. Conversely, a point leaving the image boundary or being lost returns $s_{\mathrm{exe}}=\texttt{Failure}$, routing control into exploration or backtracking.
Figure 4: Goal construction for ExecuteLocal. Left: the selected view $v$ with the floor mask in yellow and the tracked target point $p$ (the portal point) in blue. Right: the goal crop around $p$ (red frame) fed to the ViNT local navigator; the tracker updates $p$ every frame and the crop follows until $p$ exits through the bottom of the image.
4. Anchor Construction
For the stop observation $o_{\mathrm{stop}}$, BuildVisit captures a six-view RGB scan at $0^{\circ},60^{\circ},\ldots,300^{\circ}$ and stores it as a visit containing the views, sub-goal context, semantic descriptions, and motion evidence. Unseen places initialize a new AnchorNode, while revisited places merge into existing anchors that store a canonical visit, visual features, a semantic signature, and six relative direction slots. Executed motions and observations are logged as directed TraversalEdges.
The resulting anchor graph maintains place identities and confirmed transitions without explicit coordinates, and the paper is candid about its expressive limits: direction slots lack distance and global angles, and forward edges do not imply reverse paths. A record of walking from A to B does not automatically tell the agent how to walk back; the return path must be established separately by the backtracking mechanism.
5. Place Association
$\textit{Associate}(\textit{visit},\mathcal{M})$ performs coarse-to-fine RGB place association: global descriptor retrieval with cyclic view alignment, refined by RANSAC local feature matching and semantic verification. The output is a three-valued state
$$\textit{state}\in\{\texttt{Same},\texttt{New},\texttt{Ambiguous}\}$$Same means a known place was revisited, New means a new place, and Ambiguous means insufficient evidence. Ambiguous visits are retained in memory but can neither advance the instruction nor serve as backtracking targets, which stops the system from cementing uncertain judgments into the graph.
6. Progress Verification
$\textit{VerifyProgress}(g,\textit{state},\textit{visit},\mathcal{M})$ receives motion completion, visit association, and the sub-goal's target entities, completion type, spatial relations, and history. Associate determines the visual place state; VerifyProgress decides whether that state satisfies the current instruction stage, emitting a four-valued decision
$$\textit{decision}\in\{\texttt{Commit\_stage},\texttt{Intermediate},\texttt{Wrong},\texttt{Uncertain}\}$$If the completion condition holds, the output is Commit_stage and the controller advances $G$. A confirmed but incomplete place is labeled Intermediate and stored as an anchor without advancing the instruction. Wrong and Uncertain cases do not advance the task and instead trigger exploration or backtracking. Splitting "is this place right" from "is this stage done" is what makes the verification structure reusable: the same Associate result serves both progress verification and post-backtrack relocalization confirmation.
7. Exploration and Backtracking
When progress is not committed, CanExplore checks whether the current anchor still has exploration budget. If so, Explore selects a new direction and invokes SelectTarget and ExecuteLocal again; rejected directions are recorded in anchor memory and are not re-explored for the same sub-goal. When the budget is exhausted, or the current branch is judged inconsistent with the instruction, the agent activates Backtrack.
Unlike geometric backtracking, Backtrack does not rely on pose or metric maps. Each anchor transition stores historical RGB observations and motion trajectories from local execution. During recovery the agent retrieves historical observations, matches the current view against the stored trajectory, and recovers a visual target $(v^{\prime},p^{\prime})$ from the matched historical state; it then reuses ExecuteLocal with $(v^{\prime},p^{\prime})$ to iteratively return to previous locations. If no reliable visual correspondence is found, recovery terminates. After each recovery step, BuildVisit and Associate verify the returned location: only a Same association with the target anchor is accepted, while ambiguous or incorrect returns are rejected. Once back at a confirmed anchor, failed directions remain in memory and SelectTarget chooses alternative candidates for the same sub-goal.
Figure 5: Coordinate-free anchor graph and visual backtracking. (a) Anchors A1 to A7 created by BuildVisit from six-view RGB visits, linked by executed TraversalEdges (solid blue, numbered in execution order); room labels are the semantic signatures used by Associate. At A5 the branch is judged uncertain (orange) and then fails (red). (b) The stored departure view of edge A4 to A5. (c) The view after Backtrack returns along the same edge; Associate classifies the returned visit as SAME to A4 (green), committing the reverse edge and restoring exploration from A4. The top-down map is for visualization only and is never available to the policy.
8. The Closed Loop
Assembled, these modules form the Algorithm 1 loop: for each sub-goal, while the decision is not Commit_stage, select a target, execute, register the visit, associate, and verify; on execution failure or failed verification, explore or backtrack. The diagram below follows the paper's actual control flow:
flowchart TD
A["Decompose I
ordered typed sub-goals G"] --> B["SelectTarget
six RGB views at 60 deg
VLM ranking then refine at plus/minus 30 deg
GroundingDINO + SAM gives v and p"]
B --> C["ExecuteLocal
KLT tracking + ViNT
bottom_exit means Arrival
lost point means Failure"]
C -->|Failure| E["Explore within budget
rejected directions recorded"]
C -->|Arrival| D["BuildVisit
six-view scan 0 to 300 deg
new AnchorNode or merge"]
D --> F["Associate
descriptor retrieval + cyclic alignment
RANSAC matching + semantic check
Same or New or Ambiguous"]
F --> G["VerifyProgress
Commit_stage or Intermediate
or Wrong or Uncertain"]
G -->|Commit_stage| H["advance to next sub-goal"]
G -->|Intermediate| E
G -->|Wrong or Uncertain| E
E -->|budget left| B
E -->|budget exhausted or branch inconsistent| I["Backtrack
match current view to stored edge RGB + motion
reuse ExecuteLocal with recovered target
accept only Same on return"]
I --> B
H -->|all sub-goals committed| J["stop"]
The most interesting parts of this diagram are the two return edges rather than the trunk. Explore keeps unverified observations in the graph for further trials, and Backtrack walks the agent along historical edges back to a confirmed anchor. Both consume the same anchor graph and both write results back into it, so memory is simultaneously the basis of decisions and their product; that is what closes the loop.
Experiments
Main Results: Best Success Rate Without Depth or Coordinates
Evaluation uses the Habitat-based R2R-CE benchmark with the corrected 100-episode val_unseen subset from the OpenNav protocol (OpenNav_R2R-CE_100). Metrics are Success Rate (SR, stop within 3 m geodesic distance), Oracle Success Rate (OSR), Navigation Error (NE), and SPL. The table below groups baselines by whether they directly consume depth or coordinate/pose information:
| Method | Depth | Coord/Pose | SR ↑ | OSR ↑ | NE ↓ | SPL ↑ |
|---|---|---|---|---|---|---|
| MapGPT-CE | Y | Y | 7.0 | 21.0 | 8.16 | 5.04 |
| DiscussNav | Y | Y | 11.0 | 15.0 | 7.77 | 10.51 |
| InstructNav | Y | Y | 31.0 | - | 6.89 | 24.00 |
| Open-Nav | Y | Y | 16.0 | 23.0 | 7.25 | 12.90 |
| CA-Nav | Y | Y | 25.3 | 48.0 | 7.58 | 10.80 |
| SmartWay | Y | Y | 29.0 | 51.0 | 7.01 | 22.46 |
| Fast-SmartWay | Y | Y | 27.8 | - | 7.72 | 24.95 |
| DreamNav | Y | N | 32.8 | 41.0 | 7.06 | 28.95 |
| LightZeroNav | N | N | 27.0 | 39.0 | 7.45 | 20.00 |
| Navi-Agent (ours) | N | N | 33.4 | 48.3 | 5.79 | 18.73 |
Table 1: Comparison with zero-shot VLN-CE methods on OpenNav_R2R-CE_100; Y/N indicates whether the policy directly uses depth or coordinate/pose information.
Three readings matter. First, the 33.4% SR is not only the best among methods without depth or coordinates, it also exceeds every metric-prior method in the table, including SmartWay at 29.0 and InstructNav at 31.0; NE of 5.79 m is likewise the lowest in the table, meaning that even in failed episodes the agent stops closer to the goal. Second, OSR of 48.3 trails SmartWay's 51.0, so the trajectory-reaches-goal ratio is not first: part of the potential is lost on "was there but did not stop right." Third, SPL of 18.73 is clearly below DreamNav's 28.95 and Fast-SmartWay's 24.95. Backtracking and exploration cost path length, and the ablations below price that cost precisely.
Ablations: Backbone and the Value of the Anchor Graph
Varying the semantic backbone with everything else fixed, all three models meet or exceed the baseline level, with the open-source Qwen3.6-Plus best at 33.4% SR and the closed-source GPT-5.6-sol and GPT-5.5 at 26.3 and 28.6. The authors add a side observation: the system is sensitive enough to the backbone's spatial judgments that it could serve as a benchmark for evaluating multimodal LLMs on embodied tasks.
| Semantic model | SR ↑ | OSR ↑ | NE ↓ | SPL ↑ |
|---|---|---|---|---|
| Qwen3.6-Plus (open-source) | 33.4 | 48.3 | 5.79 | 18.73 |
| GPT-5.6-sol (close-source) | 26.3 | 46.6 | 6.50 | 18.37 |
| GPT-5.5 (close-source) | 28.6 | 47.3 | 6.24 | 16.82 |
Table 2: VLM backbone ablation with all other modules and the protocol fixed.
The anchor-graph ablation answers directly whether the graph pays for itself. Disabling graph construction and recovery entirely (w/o anchor graph and recovery) degrades the agent to greedy motion until it actively stops or hits the step limit: SR drops to 28.33 while SPL rises to the table-best 22.45, since never backtracking means never retracing steps. Widening the backtrack depth from 1 hop (the full system, SR 33.43) to 2 and 3 hops collapses SR to 21.67 and 14.67: multi-hop recovery expands the graph along wrong branches and compounds errors. The paper concludes that a constrained 1-hop recovery balances failure correction against concise path execution. Recovery capability is real, but its radius must be deliberately limited.
| Configuration | SR ↑ | OSR ↑ | NE ↓ | SPL ↑ |
|---|---|---|---|---|
| w/o anchor graph and recovery | 28.33 | 46.33 | 5.64 | 22.45 |
| 1 hop (full Navi-Agent) | 33.43 | 48.33 | 5.79 | 18.73 |
| 2 hops | 21.67 | 40.33 | 6.58 | 14.39 |
| 3 hops | 14.67 | 32.67 | 9.83 | 11.72 |
Table 3: Exploration and recovery strategies; on this benchmark the full system uses a 1-hop exploration budget.
Is the Spatial State Itself Reliable?
To evaluate the anchor graph as spatial memory independently of instruction following, the paper measures pose-free return: given a trajectory segment, the agent returns to a previous anchor using only stored visual targets and motion histories, with return success defined by the indicator
$$\mathbb{I}\!\left(d(p_{\mathrm{return}},p_{\mathrm{anchor}})<\delta\right)$$The result is a return position error of 2.32 m and an 80.3% physical revisitation success rate. Without any pose information, that precision is enough to support the recovery semantics of "go back to the last confirmed place and try another direction." On visual place confirmation the method scores Acc 0.71, Prec 0.68, Recall 0.75, F1 0.71: Associate distinguishes visually similar places correctly most of the time, while roughly three in ten judgments still need the Ambiguous state and later verification as a safety net.
| Evaluation | Metric | Navi-Agent |
|---|---|---|
| Physical revisitation | Return error ↓ (m) | 2.32 |
| Physical revisitation | Return SR ↑ (%) | 80.3 |
| Visual place confirmation | Acc / Prec / Recall / F1 | 0.71 / 0.68 / 0.75 / 0.71 |
Table 4: Spatial state verification and recovery evaluation, corresponding to Table IV of the paper.
Real-World Deployment and Latency
Real-world experiments run in an indoor library on two platforms, an AGV and a wheeled-legged robot, both equipped only with a monocular RGB camera and no depth, IMU, or prior map. Fixed control intervals give an average forward step of 0.5 m and turns of plus or minus 30 degrees; the platforms differ only in camera height and kinematics. Two target-directed tasks start from the same room: T1 exits the room, turns right, and stops at a wooden door (10.5 m); T2 exits, follows the corridor, and stops near a green plant (21.5 m). Both platforms reach success rates between 0.7 and 0.8. Early failures concentrate on complex exits and turns; after a 1-hop exploration the recovery module backtracks to the correct topological node and completes navigation, with up to 2/2 successful recoveries on the long-horizon task. The cross-platform consistency suggests the mapless, depth-free framework is insensitive to embodiment differences.
| Task | Dist. (m) | AGV Succ. | AGV Rec. | Wheeled-legged Succ. | Wheeled-legged Rec. |
|---|---|---|---|---|---|
| T1: exit, turn right, door | 10.5 | 8/10 | 2/2 | 8/10 | 1/1 |
| T2: exit, corridor, plant | 21.5 | 7/10 | 2/2 | 8/10 | 2/2 |
Table 5: Real-world deployment results; Succ. is successes out of 10 trials and Rec. is successful over triggered recoveries.
Figure 6: One deployment platform: the AGV in the library corridor, with a laptop on top running the full Navi-Agent pipeline and a single forward RGB camera as the only sensor.
The latency analysis decomposes each navigation cycle: visual target selection (VLM) 8.3 s, local execution 0.2 s per step, anchor construction and graph update 4.6 s, progress verification 3.7 s, and backtracking as the sum of the above. One select-move-register-verify cycle therefore costs roughly 17 s, which positions the system as a validation of correctness and recovery rather than real-time control; the VLM call is the largest single cost.
| Component | Latency |
|---|---|
| Visual target selection (VLM) | 8.3 s |
| Local execution (ViNT + tracking) | 0.2 s per step |
| Anchor construction and graph update | 4.6 s |
| Progress verification | 3.7 s |
| Backtracking and visual revisitation | sum of the above |
Table 6: Per-component latency of a navigation cycle, averaged over episodes.
Limitations
First, the anchor graph has explicit expressive limits, stated by the authors: direction slots carry no distance or global angle, forward edges do not imply reverse paths, retained Ambiguous visits can neither advance the instruction nor serve as backtracking targets, and recovery terminates outright when no reliable visual correspondence is found. The authors point future work toward higher-level semantic spatial memory and reasoning, moving from transition records to spatial relation inference and reasoning over ambiguous configurations.
Second, recovery radius and success rate are tightly coupled, a structural fragility exposed by the ablation: at a 1-hop budget SR is 33.43, at 2 hops it falls to 21.67, and at 3 hops only 14.67 remains. The recovery mechanism itself works (2/2 recoveries on the real robot), but "one step further back" almost inevitably introduces compounded error under the current graph structure, indicating that the anchor graph cannot yet support multi-hop topological reasoning. The budget is a constraint forced by experiments rather than a design choice.
Third, association accuracy and the efficiency bill still have headroom: Associate's F1 of 0.71 means roughly three in ten judgments on visually similar places (repeated corridors on one floor, similar doorways) rely on the Ambiguous state and retries; SPL of 18.73 trails DreamNav's 28.95 even though DreamNav also avoids coordinates, making the detour cost of backtracking visible in the main table; and the roughly 17 s per cycle keeps the system far from real-time deployment. The main results also cover only a 100-episode subset, and the real-robot study is two tasks with ten trials each, so the scale remains proof-of-principle.
Conclusion and Outlook
Navi-Agent's central claim can be stated in one sentence: spatial state need not be a function of coordinates, it can be a function of history. With visual visits as nodes and executed motions as edges, place confirmation, progress verification, and failure recovery all become retrieval and matching on a graph; the bottom_exit arrival criterion and the Same-only acceptance rule for backtracking turn the two easiest things to fudge, "when have I arrived" and "when am I really back," into decidable geometric and matching conditions. Under the strict zero-shot, depth-free, coordinate-free setting this structure reaches 33.4% SR and 5.79 m NE and reproduces on two real robot platforms.
For robot developers the transferable lesson is the memory trade-off: the paper does not chase a richer map but deliberately keeps a graph whose expressive power is limited yet whose every edge is verifiable, and pushes all uncertainty into the explicit Ambiguous and Uncertain states. The authors' stated next step, upgrading transition records to semantic spatial relation reasoning, is exactly the layer this graph currently lacks; and the fragility of the 1-hop budget suggests that multi-hop recovery may need stronger edges carrying distance and direction semantics rather than a larger budget.
SOURCE LINKS
