CorrectNav: Self-Correcting VLA Navigation

• CorrectNav is a vision-language-action navigation model that leverages a self-correction flywheel paradigm to systematically detect and rectify navigation errors.
• It synthesizes both action-correction trajectories and perception-correction keyframes to retrain the model and enhance instruction-following and error recovery.
• Empirical results on benchmarks like R2R-CE and RxR-CE show significant improvements in success rates and trajectory fidelity over previous state-of-the-art methods.

CorrectNav denotes a vision-language-action (VLA) navigation model architecture and training paradigm designed for robust self-correction during task execution. At its core, CorrectNav incorporates a post-training feedback process termed the Self-Correction Flywheel, which iteratively identifies model errors on its own training set, synthesizes targeted correction data, and retrains the model to systematically eliminate recurrent navigation failures. Deployments on benchmarks such as R2R-CE and RxR-CE demonstrate substantial improvements in both instruction-following and real-world robot navigation settings, with CorrectNav yielding state-of-the-art trajectory fidelity, error recovery, and longer instruction adherence (Yu et al., 14 Aug 2025). The underpinnings of CorrectNav also relate conceptually to Self-Correction GUI Navigation as studied in the Navi-plus task (Cheng et al., 31 Mar 2025), highlighting the growing importance of native agent self-diagnosis and information-seeking in ambiguous or error-prone domains.

1. Deviation Detection and Error Localization

CorrectNav employs a systematic deviation detection process during post-training self-evaluation. Given a set of training instructions and corresponding ground-truth (oracle) trajectories $T_g = (G_1, \dots, G_n)$, the model executes each instruction to generate a predicted trajectory $T_m = (M_1, \dots, M_m)$. The procedure:

• Uniformly interpolates the oracle path to yield a dense reference trace $T_g'$.
• For each predicted model location $M_i$, computes the minimal Euclidean distance $h_i = \min_{x\in T_g'} \|M_i - x\|_2$.
• The "closest foot" point $P_i$ is defined as the nearest point on $T_g'$.
• A deviation is recorded at the first timestep $t$ where $h_t > S$ for a fixed threshold $S$, and $h_i \leq S$ for all $i < t$.

The frames at $M_{t-1}$, $M_t$, and $M_{t+1}$ are extracted as keyframes for subsequent perception correction (Yu et al., 14 Aug 2025).

2. Automatic Self-Correction Data Synthesis

Upon deviation localization, CorrectNav synthesizes two types of correction data:

• Action-Correction Trajectories: If $P_t$ (the closest foot of $M_t$) lies on segment $\overline{G_k G_{k+1}}$, a trajectory planner $\Gamma$ constructs a recovery path $T_e = (M_t, G_{k+1}, \dots, G_n)$. This enables stepwise action supervision for recovering to the oracle path.
• Perception-Correction Keyframes: Each keyframe $K_i$ is processed using a large multimodal LLM (Qwen-VL-Plus) to generate both concise captions $C_i$ and QA pairs $(Q_{i,j}, A_{i,j})$ tailored to the navigational context (e.g., landmarks, spatial layout).

These correction data augment standard navigation training samples, directly targeting the observed failure points (Yu et al., 14 Aug 2025).

3. The Self-Correction Flywheel Paradigm

The self-correction process operates as a closed feedback loop. At each iteration:

1. The model is trained on the available navigation dataset.
2. The trained model is re-applied to the training set; deviations are identified via the above localization method.
3. Correction data (action and perception samples) are synthesized for each error trajectory.
4. A new training set is formed by mixing original navigation data and synthesized correction data (typically with a 1:1 ratio).
5. The model is retrained on this mixed dataset.

Flywheel iterations continue until validation performance on held-out (unseen) splits plateaus or degrades, typically after 3–4 rounds (Yu et al., 14 Aug 2025).

4. Model Architecture and End-to-End Training

CorrectNav integrates three differentiable components:

• Vision Encoder ($v(\cdot)$): A SigLIP backbone produces visual embeddings $Z_v$ from input images.
• MLP Projector ($p(\cdot)$): A 2-layer MLP projects these embeddings to LLM-compatible visual tokens $H_v$.
• LLM ($f(\cdot)$): Qwen2 7B, operating as an autoregressive decoder, receives interleaved visual and textual tokens (actions, captions, QA) and outputs trajectory actions or perceptual content.

End-to-end backpropagation of joint losses—navigation, instruction, caption, and QA—across all modules is performed at every flywheel iteration, with full gradient flow into the vision and language components (Yu et al., 14 Aug 2025).

5. Loss Functions and Optimization Objectives

The learning objective consists of multiple weighted components:

• Navigation Action Loss ($\mathcal{L}_{nav}$): Multi-step action prediction cross-entropy on base and correction trajectories.
• Instruction Generation Loss ($\mathcal{L}_{inst}$): Cross-entropy for trajectory-to-instruction generation.
• General Multimodal Loss ($\mathcal{L}_{mm}$): Auxiliary losses on ActivityQA and NextQA datasets.
• Self-Correction Loss ($\mathcal{L}_{self}$): Composite of action correction ($\mathcal{L}_{act}$), caption ($\mathcal{L}_{cap}$), and QA ($\mathcal{L}_{qa}$) cross-entropies with corresponding weighting parameters.

The full objective at each flywheel round is

$$\mathcal{L} = \mathcal{L}_{nav} + \alpha\,\mathcal{L}_{inst} + \beta\,\mathcal{L}_{mm} + \gamma\,\mathcal{L}_{self}$$

with hyperparameters $\alpha, \beta, \gamma$ (Yu et al., 14 Aug 2025).

6. Empirical Performance and Ablations

CorrectNav achieves the following performance gains on standard benchmarks, surpassing prior state-of-the-art:

• R2R-CE (Val-Unseen): Navigation error (NE) = 4.24 m, success rate (SR) = 65.1 %, and SPL = 62.3 %, exceeding StreamVLN (SR = 56.9 %) by +8.2 points.
• RxR-CE (Val-Unseen): NE = 4.09 m, SR = 63.3 %, SPL = 75.2 %, a +16.4 point gain over previous best (Yu et al., 14 Aug 2025).

Ablation studies demonstrate that both trajectory and keyframe correction components are critical. Removing either trajectory or perception correction reduces R2R-CE SR by 2.9–3.8 points. Multiple flywheel iterations further increase SR cumulatively (e.g., R2R-CE: from 63.0 % to 65.1 % over three rounds).

In real robotics tests, CorrectNav demonstrates consistent error recovery, dynamic obstacle avoidance, and robust adherence to long natural language instructions (Yu et al., 14 Aug 2025).

7. Relation to Self-Correction GUI Navigation and Outlook

Navi-plus establishes the critical role of explicit information-seeking (ASK actions with user follow-ups) in remedying ambiguous GUI instructions. A future "CorrectNav" system, as envisioned, would integrate real-time confidence monitoring, ASK action invocation upon detecting missing informational gaps or ambiguities, and multi-turn plan updating using user responses. This generalizes the flywheel’s error-driven data augmentations to interactive settings and multi-slot reasoning. Empirically, self-correction—whether via explicit user dialog in GUI settings (Cheng et al., 31 Mar 2025) or autonomous trajectory/scene reanalysis in navigation (Yu et al., 14 Aug 2025)—substantially recovers and extends agent competence, suggesting a central role for such mechanisms in next-generation robust automation systems.