acceptodds
Under review as a conference paper at ICLR 2027

SimpleVLN: Towards Simple and Frontier Vision-Language Navigation

14 views

Abstract

Vision-and-Language Navigation (VLN) requires embodied agents to ground language in visual observations and make long-horizon decisions. Existing methods often address these demands through task-specific architectures. As multimodal large language models (MLLMs) become increasingly capable, an important question remains: Have we truly unlocked the potential of native MLLMs for VLN before introducing task-specific architecture? We present SimpleVLN, an architecture-preserving framework developed through studies of navigation formulation, data construction, and optimization. At the formulation level, SimpleVLN combines single-turn decision inputs with fixed-budget global–local memory to efficiently use navigation history without unbounded context growth, while action chunks enable efficient output of multiple primitive actions per model invocation. For data construction, we combine expert demonstrations with policy-dependent DAgger experience and develop a scalable synthesis pipeline that generates large-scale tasks for reinforcement learning. At the optimization level, a progressive IL-DAgger-RL pipeline advances from action imitation to task-level outcome optimization. Comprehensive experiments validate the effectiveness of these three aspects. We instantiate SimpleVLN across multiple MLLM backbones and model sizes, demonstrating its generality. SimpleVLN achieves 76.7% and 80.1% success rates on the R2R-CE and RxR-CE splits, respectively, substantially outperforming existing methods. These results show that the navigation capabilities of native MLLMs can be effectively unlocked without task-specific architectural designs.

Primary area:
applications to robotics, autonomy, planning
Keywords:
SimpleVLN, Vision Language Navigation

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_1xofOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SimpleVLN adapts a multimodal language model to vision-language navigation without modifying its architecture. It combines single-turn decision inputs, a fixed budget of global and local visual history, and action-chunk prediction with imitation learning, DAgger, and reinforcement learning. The Qwen3.5-9B model achieves 76.7% and 80.1% success on the R2R-CE and RxR-CE val-unseen splits.

Critical strengths

The paper presents an effective navigation training recipe with a simple architecture. Bounded visual history prevents input size from growing indefinitely with trajectory length, while action chunks reduce the frequency of model calls. Neither requires an additional task-specific network module.

The experiments systematically examine input format, history sampling, demonstration data, DAgger, and reinforcement learning. DAgger adds 7.5 and 8.1 percentage points in Table 4, and RL improves several model configurations in Table 1. These results provide useful empirical guidance beyond reporting the best-performing configuration.

The final results are competitive under single-RGB observations. Table 2 also compares model execution latency on a common A100, reporting 293 ms per action-chunk decision for Qwen3-VL-4B.

Critical weaknesses

The DAgger implementation is the most important missing detail. Section 3.3 describes retaining a policy trajectory or selecting an expert trajectory according to deviation from the reference, but does not specify the deviation measure, the switching point, or how supervision is obtained for retained policy trajectories. In particular, whether off-path states receive newly queried expert actions or the policy's own actions changes the interpretation of this training stage. Given the substantial gain attributed to DAgger, these details should be explicit. Some key details of synthetic RL data construction are missing. Section 3.3 describes sampling paths in training scenes and generating instructions from path waypoints, rooms, salient objects, and egocentric views. However, it does not identify the MLLM, provide the prompts or task counts, or explain whether quality filtering is applied. The scene-source ablations establish the value of different pools but do not establish the scale or quality of the synthetic data. Methods in Table 1 differ in backbones and training data, so the overall performance gap cannot be attributed directly to the training recipe. Section 4.1 already reports training epochs, learning rates, and an RL schedule of 40 steps with batch size 256 and 16 rollouts per prompt. The number of additional DAgger samples, total environment interactions, and training compute are still needed to assess the resources required for these gains. Finally, comparisons of history budgets and RL configurations are reported on val-unseen, but it is unclear whether this split also guides hyperparameter or checkpoint selection. Variability across training seeds is not reported either, making the smaller ablation differences difficult to assess.

Questions for authors
  1. What deviation measure and threshold does DAgger use? When a policy trajectory is retained, how are supervised action labels generated, particularly at states outside the reference path?
  2. Which MLLM and prompts generate the synthetic instructions, and is quality filtering applied? Please report the number of synthetic tasks and additional DAgger samples, total environment interactions, and training GPU-hours.
  3. Does each model use its last training checkpoint or one selected by validation performance? Is val-unseen used for checkpoint or hyperparameter selection? Have the key ablations been repeated across training seeds?
8 comments
AuthorsOpenReview ↗

Response to Reviewer 1xof - 1 / 5

Thanks for your insightful feedback and support. We sincerely appreciate your valuable comments and your recognition of the novelty of our benchmark and the soundness of the experiments.

W1: The DAgger implementation is the most important missing detail. Section 3.3 describes retaining a policy trajectory or selecting an expert trajectory according to deviation from the reference, but does not specify the deviation measure, the switching point, or how supervision is obtained for retained policy trajectories. In particular, whether off-path states receive newly queried expert actions or the policy's own actions changes the interpretation of this training stage. Given the substantial gain attributed to DAgger, these details should be explicit.

We follow the DAgger pipeline in StreamVLN. At each visited state, we query a shortest-path follower for an expert action toward the next waypoint on the reference path. Deviation is measured by cumulative disagreement between the candidate atomic action and this expert action. Let E denote the disagreement count and m=max(1,⌊ L_{ref}/(K-1)⌋), where L_{ref} is the reference action-sequence length and K is the number of reference waypoints. Expert intervention is triggered when E/m>0.8 or E>12. The switch occurs before executing the triggering action: we discard the remaining policy action sequence, reset the counter, and execute expert actions queried from the agent’s current state. Expert control continues until the next reference waypoint is reached, after which policy control resumes. Thus, correction occurs within the ongoing rollout.

Supervision uses the actions actually executed at the corresponding visited states. Steps controlled by the policy retain their executed policy actions as targets, including disagreements below the intervention threshold. During intervention, targets are the newly queried expert actions executed from those states. We do not retrospectively replace all retained policy actions with expert labels. This stage therefore combines supervision from retained policy behavior and online expert corrections.

Trajectory retention is a separate decision. We require a final goal distance below 0.5 m and a path-efficiency ratio r=dₛₕₒᵣₜₑₛₜ/max(dₛₕₒᵣₜₑₛₜ,ℓ_{executed}) below 0.93 for rollouts with a deviation-triggered intervention, or below 0.85 otherwise. Each episode is attempted up to four times, retaining the first rollout satisfying these criteria. Model-generated STOP commands are overridden before completion of the reference path.

AuthorsOpenReview ↗

Response to Reviewer 1xof - 2 / 5

W2: Section 3.3 describes sampling paths in training scenes and generating instructions from path waypoints, rooms, salient objects, and egocentric views. However, it does not identify the MLLM, provide the prompts or task counts, or explain whether quality filtering is applied. The scene-source ablations establish the value of different pools but do not establish the scale or quality of the synthetic data.

We thank the reviewer for pointing out that the description of our synthetic data construction lacks important implementation details.

MLLM and prompt. We use a MLLM (e.g. Qwen3.5 or GPT) with a fixed prompt to generate navigation instructions, which we will include verbatim in the appendix. At each node along a reference trajectory, the MLLM receives the ground-truth action, room label, instance-level landmark candidates (e.g., sofa#1), and the corresponding egocentric RGB frame. The prompt instructs the model to select a few salient landmarks rather than enumerate all candidates, merge consecutive actions, avoid hallucinating rooms, objects, or turns, and specify an explicit stopping location. We also provide up to eight human-written instructions from the same scene as style references. Since the generated instructions are grounded in the nodes and actions of the reference trajectory, they are constrained by the corresponding environment and navigation path.

Scale and quality control. We synthesize a total of 38,520 navigation tasks, including 5,450 from R2R, 7,070 from RxR, and 26,000 from ScaleVLN training scenes. The tasks are stratified into 50-step trajectory-length buckets. These are exactly the three data pools compared in Table 5.

We apply several filtering criteria to remove low-quality or unsuitable tasks. Specifically, we discard trajectories with fewer than 10 or more than 400 steps, geodesic lengths below 3 m, or fewer than two rooms. We also exclude tasks whose goals correspond to wall-mounted or unreachable objects, as well as trajectories that overlap with existing or real trajectories. In addition, we manually audit 50 randomly sampled tasks together with their reference trajectories, evaluating entity grounding, goal consistency, instruction clarity, and executability. Over 95% of the sampled tasks are judged to be reasonable and correct.

Pass@8-based filtering. Beyond these rule-based and manual quality checks, we further assess the difficulty and learnability of the synthesized tasks using the SFT-trained policy. Specifically, we evaluate each task with eight independent rollouts and retain tasks with Pass@8 scores between 0.2 and 0.8. This filtering removes tasks that are either too difficult for the current policy to make meaningful progress or too easy to provide sufficient learning signals. After this step, we retain 12,837 tasks in total, comprising 1,343 from R2R, 1,558 from RxR, and 9,936 from ScaleVLN. We will add these details and the final dataset statistics in Appendix.

AuthorsOpenReview ↗

Response to Reviewer 1xof - 3 / 5

W3: Methods in Table 1 differ in backbones and training data, so the overall performance gap cannot be attributed directly to the training recipe.

We thank the reviewer for raising this important concern. We agree that a direct comparison across methods with different backbones and training data cannot, by itself, establish the contribution of the training recipe. To address this issue, we have expanded our analysis in three aspects: (1) we explicitly report the backbone and training data of each method in Table 1; (2) we introduce matched-backbone comparisons to examine the gains from our progressive training pipeline; and (3) we provide a near-matched comparison with JanusVLN, as well as additional data-source ablations, to better understand the effects of architecture and training data.

1. Matched-backbone comparisons.

We first compare models using the same backbone and model size, which reduces the confounding effect of architectural differences. Table R1 presents the results for Qwen3-VL-4B. Our SFT model achieves performance comparable to existing methods with additional architectural components, while our RL-enhanced model obtains substantial further improvements without introducing any task-specific architectural modules.

Table R1. Matched-backbone comparison on Qwen3-VL-4B.

MethodR2R-CE SRRxR-CE SRExtra modulesTraining data
FutureNav-4B65.460.9VGGT + world-action heads2.43M samples
Qwen-RobotNav-4B (S.RGB)66.971.3MLP action head15.6M samples
SimpleVLN (SFT)65.463.4None2.71M samples
SimpleVLN (+RL)73.875.1None+12,837 synthesized tasks

Compared with FutureNav-4B, our SFT model achieves the same R2R-CE SR (65.4) and higher RxR-CE SR (63.4 vs. 60.9), despite using no additional spatial encoder or auxiliary action head. More importantly, incorporating our RL stage improves SR by 8.4 points on R2R-CE and 11.7 points on RxR-CE with the same backbone and model size. The RL stage uses 12,837 synthesized tasks without action annotations, allowing the policy to optimize task-level navigation success through environment interaction rather than additional expert action supervision.

The same trend is observed across other model configurations:

Backbone and sizeR2R-CE SR gainRxR-CE SR gain
Qwen3-VL-4B+8.4+11.7
Qwen3-VL-8B+10.2+12.2
Qwen3.5-4B+9.2+13.6
Qwen3.5-9B+7.5+16.1

These results suggest that the benefit of our RL-enhanced training pipeline is consistent across different backbone families and model sizes, rather than being specific to a particular architecture.

2. Near-matched comparison with JanusVLN.

We further compare SimpleVLN with JanusVLN, which uses the same Qwen2.5-VL-7B backbone and a closely related training corpus, including ScaleVLN and DAgger data. This provides a useful comparison for examining the effect of architectural modifications.

MethodBackboneScaleVLNDAggerExtra moduleR2R-CE SRRxR-CE SR
JanusVLNQwen2.5-VL-7B~155K trajectories~14K trajectoriesVGGT encoder60.556.2
SimpleVLN (SFT)Qwen2.5-VL-7B~155K trajectories~17K trajectoriesNone59.158.9

The two methods achieve comparable performance at the SFT stage, with SimpleVLN obtaining 59.1/58.9 SR compared with JanusVLN's 60.5/56.2. This comparison suggests that additional spatial architecture is not necessary to obtain competitive performance when using a comparable backbone and training corpus. It is worth noting that JanusVLN additionally uses a large number of image-text pairs for training, whereas SimpleVLN does not. Furthermore, our RL-enhanced models achieve substantial improvements without introducing such architectural components.

3. The RL gains are not simply explained by the ScaleVLN scene pool.

Since ScaleVLN contributes the largest portion of our training trajectories, we further examine whether the RL improvement is mainly caused by its scene coverage. As shown in Table 5, synthesizing RL tasks from ScaleVLN scenes alone yields a +1.2 SR improvement on R2R-CE, whereas using R2R-only scenes, RxR-only scenes, and their mixture yields improvements of +3.1, +2.1, and +4.7, respectively. The mixed-source setting performs best, suggesting that the benefit is associated with the diversity of synthesized tasks and the resulting outcome-based learning signals, rather than simply the volume of ScaleVLN scenes.

Overall, the results show that, under the same backbone, SimpleVLN achieves comparable performance using a similar or even smaller amount of training data. This suggests that the performance gains of SimpleVLN do not simply stem from more training data or a stronger backbone, but rather from improvements in the training recipe.

Reviewer_3SpHOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents SimpleVLN, which adapts MLLMs to VLN tasks using single-turn inputs, visual history, and action chunking. It adopts an IL–DAgger–RL training pipeline and achieves SOTA performance on R2R-CE and RxR-CE. The framework preserves the original MLLM architecture without introducing task-specific modules.

Critical strengths

1."Strong performance":SimpleVLN achieves SOTA results on both R2R-CE and RxR-CE. 2."Comprehensive experiments":The paper provides extensive ablation studies on navigation formulation, data construction, and optimization strategies. 3."Simple framework":The method preserves the original MLLM architecture without introducing additional task-specific modules and demonstrates its applicability across different MLLM backbones.

Critical weaknesses
  1. "Native MLLM Fine-tune":Directly fine-tuning pretrained MLLMs for VLN has already been widely explored in previous works, such as VLN-R1[1] and StreamVLN[2]. Although SimpleVLN emphasizes preserving the original MLLM architecture, its methodological distinction from existing MLLM-based VLN approaches remains unclear. 2."Training Pipeline":The proposed IL–DAgger–RL training pipeline mainly combines existing techniques. Imitation learning, DAgger, and reinforcement learning have already been widely explored in prior VLN studies. The paper does not clearly demonstrate what new methodological contribution this training pipeline provides. 3."Unclear Instruction Quality and Alignment of Synthetic RL Data":The RL instructions are generated from reference trajectories, while visual observations and actions are obtained from policy rollouts. The paper does not clearly explain how the quality of generated instructions is verified or how the alignment between language instructions and rollout actions is ensured.

[1]VLN-R1: Vision-Language Navigation via Reinforcement Fine-Tuning [2]StreamVLN: Streaming Vision-and-Language Navigation via SlowFast Context Modeling

Questions for authors

Questions: Please see Weaknesses 1–3 for my main questions and concerns.

11 comments
AuthorsOpenReview ↗

Response to Reviewer 3SpH - 1 / 3

Thanks for your insightful feedback and support. We sincerely appreciate your recognition of the experiments. We believe the following responses would resolve all concerns. We would appreciate it very much if you could reconsider our work and support us.

W1: "Native MLLM Fine-tune":Directly fine-tuning pretrained MLLMs for VLN has already been widely explored in previous works, such as VLN-R1[1] and StreamVLN[2]. Although SimpleVLN emphasizes preserving the original MLLM architecture, its methodological distinction from existing MLLM-based VLN approaches remains unclear.

VLN-R1 adopts SFT followed by GRPO-based reinforcement fine-tuning, where a time-decayed reward measures the agreement between predicted actions and expert actions. StreamVLN focuses on efficient streaming navigation, introducing multi-turn dialogue modeling, sliding-window KV caching, and 3D-aware spatial token pruning to support long-horizon visual context.

In contrast, SimpleVLN investigates how to systematically adapt native MLLMs to VLN through three complementary aspects.

  1. First, we develop a decision-level navigation formulation that combines independent single-turn inputs, fixed-budget global–local visual memory, and action-chunk prediction.
  2. Second, we introduce a scalable task-synthesis pipeline that automatically generates navigation tasks and instructions to support reinforcement learning beyond existing expert demonstrations.
  3. Third, we develop a progressive IL–DAgger–RL optimization pipeline, where the final RL stage directly optimizes episode-level task success through policy–environment interaction, rather than matching a predefined expert action sequence.

Therefore, the contribution of SimpleVLN is not simply fine-tuning an off-the-shelf MLLM, but a systematic study of its navigation formulation, training data construction, and progressive optimization without task-specific architectural modifications.

AuthorsOpenReview ↗

Response to Reviewer 3SpH - 2 / 3

W2: "Training Pipeline":The proposed IL–DAgger–RL training pipeline mainly combines existing techniques. Imitation learning, DAgger, and reinforcement learning have already been widely explored in prior VLN studies. The paper does not clearly demonstrate what new methodological contribution this training pipeline provides.

Our contribution is therefore not the use of native MLLM fine-tuning itself, but a systematic investigation of how navigation formulation, training data construction, and policy optimization can jointly improve VLN performance without introducing task-specific architectural modifications.

First, SimpleVLN differs in its navigation formulation. While StreamVLN adopts multi-turn streaming context modeling with KV-cache management and spatial token pruning, SimpleVLN reconstructs an independent decision context from the current observation and a fixed-budget global–local visual history. Combined with action-chunk prediction, this formulation avoids accumulating dialogue context while preserving navigation history. Our ablations demonstrate its effectiveness: single-turn navigation improves SR from 35.7% to 53.6% compared with multi-turn modeling, while action chunking improves SR from 45.6% to 53.6% over primitive-action prediction.

Second, SimpleVLN differs in its reinforcement learning formulation and data construction. VLN-R1 employs GRPO with a time-decayed reward based on agreement with expert action sequences. In contrast, our RL stage optimizes episode-level navigation success through closed-loop policy–environment interaction. We further develop a scalable task-synthesis pipeline that generates new start–goal navigation tasks and instructions, allowing the policy to learn from additional navigation experiences beyond the original expert demonstrations.

Third, SimpleVLN studies the complementary effects of progressive optimization. Rather than relying solely on supervised fine-tuning followed by reinforcement learning, our IL–DAgger–RL pipeline incorporates policy-dependent corrective supervision before outcome-driven optimization. We do not claim novelty in the individual optimization algorithms; instead, we investigate their complementary roles in adapting native MLLMs to sequential navigation.

Taken together, SimpleVLN is distinguished by its decision-level navigation formulation, synthesized task-level RL experience, and systematically evaluated progressive optimization strategy. Our contribution is an architecture-preserving framework that demonstrates how these complementary design choices can unlock stronger navigation performance from pretrained MLLMs.

AuthorsOpenReview ↗

Response to Reviewer 3SpH - 3 / 3

W3: "Unclear Instruction Quality and Alignment of Synthetic RL Data":The RL instructions are generated from reference trajectories, while visual observations and actions are obtained from policy rollouts. The paper does not clearly explain how the quality of generated instructions is verified or how the alignment between language instructions and rollout actions is ensured.

In our task synthesis pipeline, reference trajectories are used to construct navigation tasks and generate corresponding instructions, rather than to prescribe action sequences for RL. Specifically, we sample start–goal pairs from the navigation graph and use the associated waypoints, including room transitions and salient objects, as semantic context for instruction generation. The generated instruction defines the navigation objective, whereas the policy independently interacts with the environment to generate its own trajectory. During RL, the policy is optimized based on task-level success rather than agreement with the reference trajectory.

To assess the quality of synthesized instructions, we conduct a manual evaluation of 50 generated instructions together with their corresponding reference trajectories. We examine four aspects: (1) entity grounding, whether the mentioned entities correspond to actual objects or locations in the environment; (2) goal consistency, whether the instruction matches the sampled navigation goal; (3) clarity, whether the instruction is clearly and unambiguously expressed; and (4) executability, whether the instruction describes a feasible navigation task in the environment. Our evaluation shows that over 95% of the sampled instructions are reasonable and correct across these criteria, demonstrating the reliability of our instruction generation process.

Importantly, the reference trajectory provides semantic context for instruction generation but does not constrain the policy to follow the same route. Multiple valid trajectories may satisfy the same instruction, and RL optimizes the policy based on task completion rather than trajectory matching. We will include the manual evaluation protocol and results in the revised manuscript, and clarify the distinction between reference trajectories used for task construction and policy-generated trajectories used for RL.

Reviewer_645qOpenReview ↗
Rating
4(+2)
Confidence
3
Informativeness
3(+1)
Presentation
2
Soundness
3(+1)
Read review
Paper summary

The paper presents SimpleVLN, an architecture-preserving approach to adapting pretrained MLLMs for vision-and-language navigation. It combines single-turn inputs, bounded global–local visual history, and action-chunk prediction with a progressive imitation-learning, DAgger, and reinforcement-learning pipeline. RL uses synthesized navigation tasks and a binary success reward. The framework is evaluated across several Qwen backbones on R2R-CE and RxR-CE.

Critical strengths
  1. The reported benchmark performance is strong, reaching 76.7% SR on R2R-CE and 80.1% SR on RxR-CE.
  2. RL consistently improves performance across the evaluated Qwen3-VL and Qwen3.5 model sizes.
  3. Preserving the native MLLM architecture offers practical compatibility with existing inference infrastructure.
  4. The paper provides ablations covering observation history, action representation, training data, reward design, and RL configuration.
Critical weaknesses
  1. The experiments do not sufficiently separate the proposed design choices from backbone, data, and optimization-budget effects. Table 1 establishes strong system-level performance, but not the comparative value of avoiding specialized architectures under a matched training recipe. The data ablations also do not clearly control optimizer updates or total training exposure.

  2. The single-turn comparison changes several factors simultaneously. Table 3b compares accumulating multi-turn dialogue against a reconstructed, fixed-budget context, also removing past actions. Consequently, the large improvement cannot be attributed specifically to dialogue format. A bounded multi-turn baseline with matched observations and token budgets is necessary.

  3. The benefit of task resynthesis is not isolated. Table 5 compares sources of synthesized episodes but does not compare synthesis against RL on existing training episodes under the same interaction budget. Existing episodes can still generate new policy-dependent trajectories, so the stated motivation does not replace this control.

  4. The latency comparison measures model time per chunk decision. Without chunk-length distributions and task-level invocation counts, it does not establish overall navigation efficiency. Real-world evidence is qualitative.

Questions for authors

see weakness

5 comments
AuthorsOpenReview ↗

Response to Reviewer 645q - 1 / 3

We sincerely appreciate your positive comments on our motivation, method, and experiments, along with your thoughtful feedback and suggestions. We hope our response can address your concerns.

W1: The experiments do not sufficiently separate the proposed design choices from backbone, data, and optimization-budget effects. Table 1 establishes strong system-level performance, but not the comparative value of avoiding specialized architectures under a matched training recipe. The data ablations also do not clearly control optimizer updates or total training exposure.

We thank the reviewer for this thoughtful comment. We appreciate the opportunity to clarify the objective of SimpleVLN and provide a more comprehensive summary of our experimental analyses. We address the concerns from three perspectives.

  1. Clarifying the goal of SimpleVLN and its relationship with specialized architectures.

Our goal is not to demonstrate that specialized architectural designs are inferior or unnecessary. As stated in our Introduction, we aim to explore how to unlock the navigation capabilities of off-the-shelf MLLMs while preserving their native architectures, and to establish a strong and reproducible VLN baseline for the community. We hope that this baseline can serve as a foundation for future research, where specialized architectural components can be further investigated and incorporated when beneficial.

To provide evidence for this goal, we compare SimpleVLN with methods using similar backbones and training data. For example, our Qwen3-VL-4B SFT model achieves 65.4/63.4 SR on R2R-CE/RxR-CE, comparable to FutureNav-4B (65.4/60.9), while requiring no additional spatial encoder or auxiliary action head. We also provide a near-matched comparison with JanusVLN, which uses Qwen2.5-VL-7B and a comparable ScaleVLN and DAgger data pool, but introduces an additional VGGT spatial encoder.

MethodR2R-CE SRRxR-CE SRExtra modulesTraining corpus
FutureNav-4B65.460.9VGGT + world-action heads2.43M samples
Qwen-RobotNav-4B (S.RGB)66.971.3MLP action head15.6M samples
SimpleVLN (SFT only)65.463.4None2.71M samples
SimpleVLN (+RL)73.875.1None+12,837 synthesized tasks
MethodBackboneScaleVLNDAggerExtra moduleR2R-CE SRRxR-CE SR
JanusVLNQwen2.5-VL-7B~155K trajectories~14K trajectoriesVGGT encoder60.556.2
SimpleVLN (SFT)Qwen2.5-VL-7B~155K trajectories~17K trajectoriesNone59.158.9

It is also worth noting that JanusVLN uses a substantial amount of additional image-text pair data for training, whereas SimpleVLN does not. Although this is not a strictly controlled comparison, it shows that our architecture-preserving approach can achieve competitive performance without relying on additional specialized modules or image-text pair training.

  1. Clarifying the scope of our data ablations and optimization objective.

SimpleVLN is not intended as a training-efficiency method. Our objective is to unlock the navigation capabilities of native MLLMs through three complementary components: task formulation, scalable training data, and progressive optimization. Specifically, we reformulate VLN as a multimodal instruction-following task, construct additional navigation tasks to provide scalable training signals, and progressively optimize the policy through IL, DAgger, and environment-interaction RL. Our focus is therefore on navigation capability and task performance, rather than reducing the number of optimizer updates or total training exposure.

AuthorsOpenReview ↗

Response to Reviewer 645q - 2 / 3

  1. Additional experiments and ablations to disentangle the contributing factors.

To make the experimental evidence more transparent, we summarize the additional comparisons and ablations in the following table.

Potential confounding factorAdditional experiment or analysisWhat it examines
Backbone architectureMatched-backbone comparisons across Qwen3-VL and Qwen3.5 model sizesPerformance gains under the same backbone and model size
Specialized architectural modulesComparison with FutureNav and JanusVLNWhether competitive VLN performance requires additional spatial encoders or task-specific modules
Training data scaleDetailed training-data composition in the appendixThe sources and quantities of trajectories, DAgger samples, and synthesized RL tasks
Training data sourceR2R-only, RxR-only, ScaleVLN-only, and mixed-source RL task ablations (Table 5)The contribution of different scene sources and task diversity
Training pipelineIL-only versus RL-enhanced models across backbone families and model sizesThe gains from progressive training and environment-interaction RL
Model size and backbone familyComparisons across Qwen3-VL-4B/8B and Qwen3.5-4B/9BWhether the improvements generalize across model scales and backbone families

For example, with Qwen3-VL-4B, adding the RL stage improves R2R-CE/RxR-CE SR from 65.4/63.4 to 73.8/75.1. Similar improvements are observed across the other backbone configurations, with gains of +7.5 to +10.2 SR on R2R-CE and +11.7 to +16.1 SR on RxR-CE. These results provide evidence that our training pipeline consistently improves navigation performance across different MLLM backbones.

In summary, SimpleVLN is designed to provide a strong architecture-preserving VLN baseline and a practical training pipeline for unlocking the capabilities of native MLLMs, rather than to establish the superiority of simple architectures over specialized ones or to optimize training efficiency. The additional experiments provide complementary evidence regarding the effects of backbone, architectural components, training data, and progressive optimization. We have revised the manuscript to clarify this positioning and incorporate the corresponding experimental analyses.

W2: The single-turn comparison changes several factors simultaneously. Table 3b compares accumulating multi-turn dialogue against a reconstructed, fixed-budget context, also removing past actions. Consequently, the large improvement cannot be attributed specifically to dialogue format. A bounded multi-turn baseline with matched observations and token budgets is necessary.

We add a bounded multi-turn baseline, Multi-turn + Primitive (8), which retains the multi-turn dialogue format while limiting the visual history to eight primitive-step observations, matching the observation-history budget of our single-turn formulation. As shown in the our original manuscript Table 3b, this baseline achieves an SR of 43.9%, improving over the original multi-turn baseline (35.7%) but remaining below our single-turn formulation (53.6%).

First, bounding the observation history improves the multi-turn baseline by 8.2 percentage points, indicating that unrestricted history accumulation is indeed detrimental. Second, the single-turn formulation further improves SR by 9.7 percentage points over the bounded multi-turn baseline. This suggests that its benefit extends beyond simply limiting the observation history.

AuthorsOpenReview ↗

Response to Reviewer 645q - 3 / 3

W3: The benefit of task resynthesis is not isolated. Table 5 compares sources of synthesized episodes but does not compare synthesis against RL on existing training episodes under the same interaction budget. Existing episodes can still generate new policy-dependent trajectories, so the stated motivation does not replace this control.

Thank you for your valuable comments. First, GRPO requires trajectories within the same group to receive different rewards; if all trajectories obtain either a reward of 1 or 0, the group has no effective advantage signal and thus provides no learning signal. After SFT, our model already achieves high accuracy on the existing training episodes, with over 85% of episodes achieving a pass@8 of 1. This means that, when directly applying RL to these existing episodes, most groups would yield zero advantages and provide little useful learning signal. Thus, we propose data synthesis approach to provide a fast and cost-effective way to obtain RL training data, making it possible to scale up RL training.

To address this issue, we filter the SFT training episodes and retain only those with pass@8 scores between 0.2 and 0.8, resulting in approximately 3K episodes. This ensures sufficient reward variation within groups during GRPO training. We then conduct RL using this filtered dataset under the same experimental settings as in Table 5. The resulting SR is reported in the table below. Its performance is lower than that achieved using our generated data, demonstrating the effectiveness of our data generation pipeline. Besides, approximately 50% of our generated episodes have pass@8 scores between 0.2 and 0.8, indicating that our generated data provides more effective learning signals for RL training.

DataR2R
Existing Training Episodes68.9
Synthesized Episodes69.4

The existing training episodes do not provide sufficient learning signals for RL. Therefore, we propose a data generation pipeline to obtain large-scale training data at low cost. Moreover, models trained on our generated data achieve better performance than those trained on the existing training episodes.

W4: The latency comparison measures model time per chunk decision. Without chunk-length distributions and task-level invocation counts, it does not establish overall navigation efficiency.

We provide additional task-level statistics, including the average number of model invocations per episode. The results are summarized in the following table.

MethodSIZESRAverage Model Invocations
SimpleVLN4B73.825.45
StreamVLN7B56.920.99
DualVLN7B65.328.79
JanusVLN7B60.587.10
FutureNav8B64.3115.32

SimpleVLN requires substantially fewer model invocations than JanusVLN and FutureNav, reducing the average number of invocations by 70.8% and 77.9%, respectively. Compared with DualVLN, SimpleVLN also requires 11.6% fewer invocations. These additional results complement our per-decision latency analysis by providing a task-level measure of inference efficiency. Regarding real-world evaluation, we acknowledge that our current physical-robot experiments provide qualitative evidence of deployment feasibility rather than a quantitative comparison of real-world navigation efficiency. We will clarify this distinction in the revised manuscript.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.