Preprint
Article

This version is not peer-reviewed.

ARC-VLN: Adaptive Recursive Computing-Based Visual-Language Navigation

  † Xiang Zhang and Xiangyu Dong contributed equally to this work.

Submitted:

13 November 2026

Posted:

16 November 2026

You are already at the latest version

Abstract
Efficient aerial visual-language navigation (VLN) requires reducing model storage and inference costs while maintaining instruction-conditioned action prediction. We present ARC-VLN, a token-type-aware recursive computation framework built on a language backbone with shared parameters. ARC-VLN retains full-depth computation for text and action tokens while adaptively selecting exit depths for visual tokens. Representations of early-exiting visual tokens are retained, and active-token compaction shortens the sequences processed by subsequent recursive blocks. To mitigate routing collapse to a single exit depth, we design a dedicated learning strategy that encourages the model to distribute visual tokens across multiple exit depths. On OpenFly’s Test-Seen and Test-Unseen subsets, ARC-VLN achieves the lowest navigation error and the highest success rate and success weighted by path length among all compared methods. Meanwhile, it reduces the average number of decision steps per trajectory, total floating-point operations, mean model inference time per trajectory, and average GPU memory usage during inference, indicating its great potential as a VLN backbone for lightweight applications.
Keywords: 
;  ;  ;  

1. Introduction

Visual-language navigation (VLN) combines language understanding and visual perception to guide embodied agents according to natural language instructions [1,2]. In recent years, VLN studies such as CityNav [3], OpenUAV [4] and OpenFly [5] have tightly integrated vision-language-action (VLA) models with perception and path-planning modules for aerial VLN. This integration enables natural language instruction parsing, semantic understanding of unfamiliar environments and autonomous navigation without prior maps, substantially improving aerial navigation in complex environments. To further improve VLN performance, studies such as FlightGPT [6] and FreeFly-Thinking [7] have introduced chain-of-thought (CoT) reasoning. By decomposing navigation tasks and modeling spatial relationships through multi-step logical reasoning, these methods strengthen long-horizon planning and autonomous decision-making in complex environments.
As large-scale generative VLA models are adopted for aerial VLN, parameter counts and the computational cost of inference increasingly constrain practical deployment. On the one hand, navigation architectures built around large language models (LLMs) contain large numbers of unique parameters, imposing substantial model storage requirements. On the other hand, tokens in multimodal sequences serve distinct task roles, so uniformly processing all tokens through the full model depth may incur redundant computation.
To address these challenges, we present ARC-VLN, an efficient aerial VLN framework based on adaptive recursive computing. The framework reuses weights across recursive stages of the LLM backbone to reduce the number of unique parameters. Building on this shared backbone, we introduce token-type-aware routing that allocates computational resources according to the roles of text, visual and action tokens in navigation.
Our main contributions are as follows:
(1) We propose a token-type-aware adaptive recursive computation framework for aerial VLN, which retains full recursive depth for text and action tokens while adaptively assigning exit depths to visual tokens. The sequences processed by subsequent recursive blocks are shortened through active-token compaction, reducing computation within the shared backbone.
(2) We incorporate cross-entropy regularization against a uniform target into the auxiliary routing loss alongside load-balancing loss and z-loss, providing a non-zero corrective gradient to the corresponding logit even as the routing probability of an exit depth approaches zero. This regularization mitigates routing collapse to a single exit depth and promotes visual-token assignments across multiple exit depths.
(3) On the evaluated OpenFly Test-Seen and Test-Unseen subsets, ARC-VLN uses approximately 2.7B unique language-backbone parameters and achieves the lowest navigation error and the highest success rate and success weighted by path length among the compared methods, together with greater computational efficiency.

3. Methods

3.1. Problem Definition

Aerial VLN requires the model to predict the navigation action for the current state based on natural language instructions and continuous visual observations. Let T denote text tokens, V visual tokens obtained by encoding visual observations with a visual encoder, and A action tokens. The aerial VLN model can then be formulated as:
A t = f θ ( T , V , h t − 1 ) ,
where A t denotes the navigation action predicted at time step t, h t − 1 represents the historical navigation state, and θ denotes the model parameters.
We investigate the trade-offs among navigation performance, unique parameter count and inference cost under this formulation.

3.2. ARC-VLN Framework

Figure 1 shows ARC-VLN, which tokenizes and embeds instructions into text representations. A visual encoder maps multiframe observations into the LLM hidden space. The input sequence comprises text tokens, visual tokens and an action prefix, in that order. Under causal attention, visual tokens can thus attend to preceding instructions.
After an initial unshared Transformer layer, the sequence enters recursive blocks that reuse intermediate-layer weights. Before recursion, a router assigns visual tokens exit depths, while text and action tokens retain the full depth. Active-token compaction excludes exited visual tokens from subsequent blocks, shortening their input sequences.
After recursive processing, all token representations are assembled and passed through a final unshared Transformer layer. The language model head then produces a probability distribution over action tokens, which is decoded into the navigation action for the current time step. The unmanned aerial vehicle (UAV) executes the action and acquires new visual observations for the next navigation decision.

3.3. Recursive Blocks with Parameter Sharing

In an N-layer Transformer decoder, the first and last layers remain unshared. The N − 2 intermediate layers form R recursive blocks, each containing B = ( N − 2 ) / R layers with distinct parameter sets. For i = 0 , 1 , … , B − 1 , corresponding layers across blocks share the same nn.Parameter objects through hard parameter tying. Each shared parameter set is initialized by averaging the corresponding pretrained weights. Parameter sharing reduces unique parameters while preserving the maximum effective computational depth.
For the 32-layer LLaMA-2-7B model, setting R = 3 retains the first and last layers as unshared layers. The 30 intermediate layers are reorganized into a block of 10 layers with distinct parameter sets, executed three times. This preserves an effective computational depth of 32 layers while reducing the number of unique decoder layers to 12. The number of unique parameters in the LLM backbone consequently decreases from approximately 6.7B to approximately 2.7B.

3.4. Token-Type-Aware Routing

Text tokens encode navigation goals and action constraints, while action tokens contribute to control sequence generation; both retain full recursive depth. Visual exit depths are predicted from pre-recursion hidden states, allowing token-specific computation within each observation. Exited tokens retain their outputs, while active tokens continue through subsequent recursive blocks. Outputs are restored to their original order and passed through the final unshared Transformer layer. Normalization and the language model head then produce action-token predictions.

3.4.1. Router Architecture

The router uses a two-layer multilayer perceptron (MLP) to predict routing scores. Its input is the hidden state h ∈ R d produced by the initial unshared Transformer decoder layer (layer 0). The router first applies layer normalization to remove scale differences, then computes routing scores through two linear transformations:
h ^ = LayerNorm ( h ) ,
z = W 2 σ W 1 h ^ ,
where R d denotes the d-dimensional real vector space. The matrices W 1 ∈ R 2 d × d and W 2 ∈ R R × 2 d contain the weights of the first and second linear transformations, respectively. The activation function is denoted by σ ( · ) , and z contains the routing scores for the recursive depths.
Applying softmax to z yields the routing probability for each recursive depth:
p r = exp ( z r ) ∑ j = 0 R − 1 exp ( z j ) , r = 0 , 1 , … , R − 1 ,
where p r is the probability of assigning the token to exit after recursive block r. The router selects the depth with the highest routing probability:
r * = arg max p r .
The target exit depth r * indicates that the token is processed sequentially by recursive blocks 0 , 1 , … , r * before exiting.
Given variable visual information density, the final rule assigns adaptive depths to visual tokens while retaining full depth for text and action tokens:
r final * = R − 1 , if τ = 0 , 2 r * , if τ = 1 ,
where { τ = 0 , 1 , 2 } denotes text, visual and action tokens, respectively. Once routing decisions are fixed, computation proceeds sequentially through recursive blocks indexed by r = 0 , 1 , … , R − 1 .

3.4.2. Adaptive-Depth Execution

The active-token set for recursive block r is defined as
V r = t ∣ r final * ( t ) ≥ r ,
which contains all tokens that require processing by recursive block r. For the first recursive block ( r = 0 ), V 0 contains all tokens, and the full sequence is processed. For subsequent recursive blocks ( r ≥ 1 ), we use a Gather-Compute-Scatter strategy to avoid redundant computation on inactive tokens.
(1) Gather:The hidden states of active tokens in V r are gathered from the full sequence and compacted into a subsequence. The corresponding causal attention mask and rotary positional encodings are gathered alongside them to preserve the original positional information.
(2) Compute:The compacted subsequence is processed by the B Transformer decoder layers in recursive block r.
(3) Scatter:The computed hidden states are written back to their corresponding positions in the full sequence. After each recursive block, tokens satisfying ( r final * = r ) have reached their target exit depths. Their weighted outputs are incorporated into the final representations as follows:
o t = h t ( 0 ) + h t ( r * ) · w t .
Here, h t ( 0 ) denotes the original hidden state of token t before entering the first recursive block. The term h t ( r * ) denotes the output of token t at its target recursive block, and w t is the corresponding routing weight.

3.5. Auxiliary Routing Loss

The router weights W 1 and W 2 are learned end to end through two gradient pathways. The main-task cross-entropy loss supplies gradients indirectly through the differentiable routing weight w t . A dedicated auxiliary routing loss provides direct training signals to improve training stability and mitigate routing collapse. This auxiliary loss is computed only for visual tokens and comprises three components.
(1) Load-balancing loss
To discourage assigning all visual tokens to a single depth, we use a load-balancing loss. This loss sums the products of mean routing probabilities and actual assignment frequencies:
L bal = α · R · ∑ r = 0 R − 1 P r · f r , P r = 1 | V c | ∑ t ∈ V c p r ( t ) , f r = | { t ∈ V c ∣ r * ( t ) = r } | | V c | .
Here, P r denotes the mean routing probability for depth r across all visual tokens, and f r is the fraction of visual tokens assigned to that depth. The set V c contains the visual tokens in the current batch, and α is the load-balancing coefficient.
By jointly accounting for routing probabilities and assignment frequencies, this loss penalizes concentration at a few recursive depths, thereby mitigating load imbalance across exit depths.
(2) Z-loss
To improve numerical stability during router training, we introduce z-loss to regularize logit magnitudes:
L z = β · 1 | V c | ∑ t ∈ V c log ∑ r = 0 R − 1 exp ( z r ( t ) ) 2 .
Here, β is the coefficient of z-loss. By penalizing the squared logsumexp, this loss limits numerical drift in the log-normalization factor, providing an additional stability constraint during router training.
(3) Cross-entropy regularization loss
With only load-balancing loss and z-loss, we observed visual tokens concentrating at one exit depth. We therefore introduce cross-entropy regularization against a uniform target to strengthen gradients for low-probability depths:
L ent = γ · 1 | V c | ∑ t ∈ V c − 1 R ∑ r = 0 R − 1 log p r ( t ) ,
where γ represents the cross-entropy regularization coefficient.
The gradient of the regularizer with respect to logit z j satisfies
∂ L ent ∂ z j ∝ p j − 1 R .
Thus, when the routing probability of a depth approaches zero, the regularizer still provides a non-zero corrective gradient. This discourages excessive concentration of routing probabilities and reduces the risk of collapse to a single exit depth.
The total auxiliary routing loss is the sum of the three components:
L route = L bal + L z + L ent .
The final training loss combines the main-task loss L CE with the auxiliary routing loss:
L = L CE + L route .

4. Experiments

4.1. Experimental Setup

4.1.1. Dataset and Evaluation Subset

We train and evaluate ARC-VLN on OpenFly [5], which contains 100,000 flight trajectories across 18 distinct scenes. These scenes combine simulated environments with point-cloud reconstructions of real-world settings, providing visual diversity and realism that help limit overfitting to one rendering style. We use the full OpenFly training split and evaluate on two test subsets, Test-Seen and Test-Unseen. Test-Seen contains 1,392 trajectories across seven seen scenes, while Test-Unseen contains 404 trajectories from one unseen scene. The evaluation comprises 1,796 trajectories in total.

4.1.2. Evaluation Metrics

We evaluate ARC-VLN across three dimensions: task performance, parameter efficiency and computational efficiency. Task performance is measured using navigation error (NE), success rate (SR), oracle success rate (OSR) and success weighted by path length (SPL). NE is the mean Euclidean distance between the UAV’s final position and the goal, measured in meters (m). SR is the proportion of episodes ending less than 20 m from the goal. OSR is the proportion of episodes entering the same goal region at any point along the trajectory. SPL weights successful episodes by the ratio of shortest-path length to actual flight distance. Failed episodes contribute zero, and the scores are averaged across all episodes.
Parameter efficiency is measured by the number of unique LLM backbone parameters (Par), reported in billions (B), with shared parameters counted only once. Computational efficiency is evaluated using average steps (AS), floating-point operations (GFL), inference latency (IL) and average inference memory (AIM). AS is the mean number of decision steps per episode, with fewer steps indicating more compact decision sequences when SR is maintained. GFL is the total floating-point operation count for complete inference across all evaluation samples, expressed in GFLOPs. IL is the mean forward-computation time per trajectory, measured in seconds (s), excluding environmental interaction overhead such as simulator image acquisition and pose updates. AIM is the mean GPU memory usage during inference, measured in gigabytes (GB).

4.1.3. Implementation Details

We use OpenVLA-7B with a LLaMA-2-7B backbone and dual-stream fusion of SigLIP-ViT-SO and DINOv2-ViT-L visual features. We use R = 3 recursive blocks, with coefficients α = 1 × 10 − 2 , β = 1 × 10 − 5 and γ = 1 × 10 − 2 for load-balancing loss, z-loss and cross-entropy regularization, respectively. To avoid early representation collapse, the routing warmup value decreases linearly from 1.0 to 0 over the first 3,000 training steps. Training uses three epochs, a global batch size of 16 and a learning rate of 2 × 10 − 4 .
For the experiments reported in Tables I and III, each method or model variant is evaluated seven times on each fixed test subset (Test-Seen and Test-Unseen). Evaluation metrics are computed separately for each subset in each run, and the arithmetic mean of each metric across the seven runs is reported.
5

4.2. Experimental Results

4.2.1. Comparison with Baseline Methods

Table 1 compares the navigation performance, parameter efficiency and computational efficiency of ARC-VLN and representative methods on Test-Seen and Test-Unseen. ARC-VLN achieved the lowest NE and highest SR and SPL among the compared methods, with fewer unique parameters and lower inference costs.
Task performance. On Test-Seen, ARC-VLN achieved the best NE (70.5 m), SR (33.4%) and SPL (31.1%) among the compared methods. Compared with OpenFly, NE decreased by 42.6%, with relative SR and SPL gains of 14.8% and 39.5%, respectively. NE was also 30.8% lower than that of NaVILA, which ranked second in NE.
On Test-Unseen, ARC-VLN again achieved the best NE (55.7 m), SR (29.3%) and SPL (27.3%). Compared with OpenFly, NE decreased by 64.9%, with relative SR and SPL gains of 8.1% and 93.6%, respectively. Compared with the respective runners-up, NE decreased by 44.2% relative to NaVILA, while SPL showed a relative gain of 48.4% over NavMorph. These results support improved navigation accuracy and path efficiency in the evaluated unseen scene.
Notably, ARC-VLN had a lower OSR than OpenFly. To further analyze the model’s ability to convert reaching the goal region into final success, we introduce the Stop Success Conversion Rate (SSCR) as an auxiliary metric. This auxiliary metric measures the model’s ability to translate having reached the goal region at some point into successfully terminating within it. We define SSCR as the ratio of SR to OSR:
SSCR = SR OSR × 100 % .
OSR records entry into the goal region, whereas SR records successful termination within it. Higher SSCR indicates that a larger proportion of goal-reaching episodes terminate successfully.
As shown in Figure 2 and Figure 3, ARC-VLN achieved SSCRs of 75.1% and 74.4% on Test-Seen and Test-Unseen, respectively, compared with 52.6% and 43.5% for OpenFly. These results show that ARC-VLN clearly outperformed OpenFly on this metric. Meanwhile, OpenFly’s AS values were 20.9 and 23.3, respectively, far higher than ARC-VLN’s 10.7 and 10.1. Together, these results indicate that OpenFly’s longer interaction sequences may have provided more opportunities to reach the goal region through additional exploration, partly explaining its higher OSR. However, its lower SSCR indicates that some episodes entered the goal region but subsequently left it and terminated unsuccessfully. ARC-VLN achieved higher SR and SSCR with fewer interaction steps. This pattern is consistent with less redundant movement after reaching the goal region and greater agreement between goal attainment and the final termination state.
NavMorph achieved SSCR values of 93.2% and 88.1% on Test-Seen and Test-Unseen, respectively, exceeding those of ARC-VLN. However, its SR values were only 17.8% and 22.3%, and its OSR values were only 19.1% and 25.3%. This indicates that the high SSCR of NavMorph is based on the fact that fewer trajectories can reach the target neighborhood. Overall, ARC-VLN achieved lower NE and higher SR and SPL while maintaining a high SSCR. This indicates more balanced performance in goal localization, final success, path efficiency and determining where to stop.
Parameter efficiency.ARC-VLN uses 2.7B unique LLM backbone parameters, 59.7% fewer than NaVid and OpenFly (6.7B) and 66.3% fewer than NaVILA (8B). As shown in Table 1, ARC-VLN achieved lower NE and higher SR and SPL with fewer unique LLM backbone parameters. These results indicate simultaneous improvements in parameter efficiency and navigation performance.
Computational efficiency.On Test-Seen, ARC-VLN reduced AS from 20.9 to 10.7 (a 48.8% reduction) and GFL by 57.7% compared with OpenFly. IL decreased from 11.0 s to 5.3 s, a reduction of 51.8%. On Test-Unseen, AS decreased from 23.3 to 10.1 (a 56.7% reduction), and GFL decreased by 77.1%. IL decreased from 11.7 s to 4.2 s, a reduction of 64.1%. These results show that ARC-VLN incurred lower computational costs and shorter model inference times than OpenFly in both seen and unseen scenes.
The reduction in computational cost primarily arises from two factors. First, token-type-aware routing and active-token compaction reduce per-step computation by excluding early-exiting visual tokens from subsequent recursive blocks. Fewer interaction steps further reduce cumulative inference costs across navigation trajectories.
ARC-VLN reduced AIM by 54.5% relative to OpenFly on both splits. Fewer unique parameters and active visual tokens contribute to the lower memory demand. Together, lower GFL, IL and AIM improve deployment feasibility on resource-constrained platforms.

4.2.2. Ablation Experiments

Table 2 compares configurations of parameter sharing (PS), dynamic routing (DR) and auxiliary routing losses; “–” marks an absent module. OpenFly is unchanged; Shared Backbone adds PS while retaining full-depth processing for all tokens. The w/o L ent configurations retain PS and the routing module but omit L ent . Spontaneous routing collapse without L ent varied in both onset time and exit depth across runs. Directly evaluating the resulting checkpoints would reflect both their final exit depths and their differing training histories, complicating performance comparisons across exit depths. To obtain controlled comparisons across prescribed exit depths, we therefore fixed all visual tokens to exit after B0, B1, or B2 throughout training and evaluation, yielding Exit_B0, Exit_B1, and Exit_B2, respectively. ARC-VLN combines PS, DR and all three losses for adaptive visual-token depths.
Effect of parameter sharing. As shown in Table 3, Shared Backbone reduced unique LLM backbone parameters from 6.7B to 2.7B (59.7%) compared with OpenFly. AIM decreased from 15.6 to 7.0 GB, a reduction of 55.1%. On Test-Seen and Test-Unseen, respectively, NE decreased by 17.1% and 35.1%, with relative SPL gains of 13.5% and 41.8%. AS decreased by 34.4% and 42.9%, and GFL by 24.0% and 35.5%, respectively. On Test-Seen, IL also decreased by 2.7% relative to OpenFly. However, relative SR reductions were 4.8% and 17.0%, and relative OSR reductions were 9.0% and 15.1% on Test-Seen and Test-Unseen, respectively. IL on Test-Unseen also increased by 52.1% relative to OpenFly. Thus, parameter sharing reduced resource demands and improved NE and SPL, but involved trade-offs in success rates and inference latency.
Effect of routing collapse. After L ent was removed, routing assignments for visual tokens collapsed to a single exit path. The model consequently lost the ability to assign different computational depths to individual visual tokens. Across the three configurations exhibiting routing collapse, NE, SR and SPL improved with increasing exit depth, although the gains differed markedly between stages. Moving from Exit_B0 to Exit_B1 increased SR and SPL by 38.3% and 42.2% on Test-Seen, and by 145.2% and 169.6% on Test-Unseen, respectively. From Exit_B1 to Exit_B2, the corresponding gains fell to 5.8% and 4.7% on Test-Seen, and 11.7% and 8.6% on Test-Unseen, respectively. Although each transition added one recursive block, the second produced markedly smaller relative gains in SR and SPL. This indicates that performance gains did not scale linearly with computational depth. Compared with Exit_B1, Exit_B2 achieved lower NE, AS and GFL on both test splits. However, OSR decreased by 6.1% and 6.7% on Test-Seen and Test-Unseen, respectively, and IL increased by 12.9% on Test-Unseen. Thus, uniformly increasing computational depth can improve some navigation metrics, but the benefits vary across metrics and may be accompanied by deterioration in others.
Exit_B2 performed relatively well among the three configurations exhibiting routing collapse. Compared with OpenFly, it still achieved better results on some navigation metrics despite having 59.7% fewer unique parameters and 54.5% lower AIM. On Test-Seen and Test-Unseen, NE decreased by 10.5% and 28.6%, respectively, and SPL increased by 10.8% and 43.3%. Both AS and GFL also decreased on the two test splits. However, Exit_B2 had lower SR and OSR and higher IL than OpenFly. These results show that fewer unique parameters can still support better performance on some navigation metrics. A larger parameter count did not confer consistent advantages across all metrics. Increasing parameter counts or computational depth alone therefore does not guarantee simultaneous improvements across all metrics.
Role of cross-entropy regularization and adaptive routing.At the same unique parameter count, the full ARC-VLN model outperformed Shared Backbone and the three w/o L ent configurations on both test splits. Compared with Shared Backbone, ARC-VLN reduced NE by 30.7% and 45.9% on Test-Seen and Test-Unseen, respectively. SR increased by 20.6% and 30.2%, and SPL increased by 22.9% and 36.5%, respectively. GFL decreased by 44.3% and 64.5%, and IL decreased by 50.5% and 76.4%, respectively. These results indicate that adding DR and its auxiliary losses to a backbone with PS can improve navigation performance while reducing cumulative inference costs per navigation task.
Compared with Exit_B2, ARC-VLN achieved relative SR increases of 21.5% and 27.4% on Test-Seen and Test-Unseen, respectively, with the same unique parameter count and AIM. GFL decreased by 47.6% and 67.7% on the two test splits, respectively. Together with the collapse to a single exit depth observed after removing L ent , these results indicate that cross-entropy regularization helps maintain effective routing assignments across multiple depths. This allows adaptive routing to assign different computational paths to individual visual tokens, yielding better navigation performance and computational efficiency than configurations with a uniform exit depth.
As shown in Figure 4 and Figure 5, ARC-VLN achieved SSCRs of 75.1% and 74.4% on Test-Seen and Test-Unseen, respectively, despite having a lower OSR than the other ablation configurations. Both values exceeded those of Shared Backbone and the three configurations exhibiting routing collapse. This indicates that, among trajectories that entered the goal region, a higher proportion ultimately terminated successfully with ARC-VLN. Together with higher SR and SPL and lower AS, these results show the full model’s advantages in both overall navigation performance and successful termination.

4.2.3. Routing Behaviour Analysis

We quantified visual-token exit distributions and used spatial visualizations to examine computation allocation in ARC-VLN. B0, B1 and B2 denote exits after 1, 2 and 3 recursive blocks, respectively. Text and action tokens always undergo full recursive computation and were excluded from these statistics.
As shown in Figure 6, visual-token exit proportions at B0, B1 and B2 were 19.1%, 34.0% and 46.9% on Test-Seen, respectively; 53.1% exited early. The corresponding proportions on Test-Unseen were 19.5%, 28.4% and 52.1%, respectively; 47.9% exited early. Active-token compaction excludes early-exiting visual tokens from subsequent recursive blocks, shortening sequences and reducing computation.
Figure 7 visualizes the spatial distribution of visual-token exit depths, with blue, orange and red denoting B0, B1 and B2, respectively. Different positions within the same observation receive different recursive depths, illustrating adaptive computation allocation at the visual-token level.

5. Conclusion and Future Work

We present ARC-VLN, an aerial VLN framework that combines recursive parameter sharing with token-type-aware adaptive computation to reduce model storage and inference costs. ARC-VLN shares language-backbone parameters across recursive stages and adaptively assigns exit depths to visual tokens while maintaining full-depth processing for text and action tokens. Active-token compaction reduces computation in subsequent recursive blocks, while cross-entropy regularization mitigates routing collapse and encourages visual-token allocation across multiple exit depths. On the evaluated OpenFly Test-Seen and Test-Unseen subsets, ARC-VLN achieves the lowest NE and the highest SR and SPL among the compared methods. Compared with OpenFly, ARC-VLN reduces the number of unique language-backbone parameters from 6.7B to 2.7B, a reduction of 59.7%. It also reduces the average number of decision steps per trajectory, cumulative computational cost, model inference time per trajectory, and GPU memory usage. These results demonstrate the effectiveness of token-type-aware adaptive recursive computation in improving navigation performance and inference efficiency in aerial VLN.
In the future, we will explore adaptive reasoning strategies that allocate reasoning effort according to navigation difficulty. We will also conduct real-world flight experiments on resource-constrained aerial platforms to evaluate ARC-VLN’s navigation performance, end-to-end latency, and energy consumption.

Funding

This work was supported in part by the Hunan Key Scientific and Technological Research Foundation under Grant 2024QK2001.

References

  1. Zhang, S.; Qiao, Y.; Wang, Q.; Guo, L.; Wei, Z.; Liu, J. FlexVLN: Flexible adaptation for diverse vision-and-language navigation tasks. IEEE Trans. Multimed. 2025, vol. 27, 6307–6318. [Google Scholar] [CrossRef]
  2. Tan, M.; et al. Source-free elastic model adaptation for vision-and-language navigation. IEEE Trans. Multimed. 2025, vol. 27, 3953–3965. [Google Scholar] [CrossRef]
  3. Lee, J.; et al. CityNav: A large-scale dataset for real-world aerial navigation. Proc. IEEE/CVF Int. Conf. Comput. Vis. (ICCV) 2025, 5912–5922. [Google Scholar] [CrossRef]
  4. Wang, X.; et al. Towards realistic UAV vision-language navigation: Platform, benchmark, and methodology. Proc. Int. Conf. Learn. Represent. (ICLR) 2025. [Google Scholar] [CrossRef]
  5. Gao, Y.; et al. OpenFly: A comprehensive platform for aerial vision-language navigation. Proc. Int. Conf. Learn. Represent. (ICLR) 2026. [Google Scholar] [CrossRef]
  6. Cai, H.; et al. FlightGPT: Towards generalizable and interpretable UAV vision-and-language navigation with vision-language models. Proc. Conf. Empir. Methods Nat. Lang. Process. (EMNLP), 2025; pp. 6659–6676. [Google Scholar] [CrossRef]
  7. Zhou, J.; Wang, S.; Yang, Z.; Yu, Z.; Li, T. FreeFly-Thinking: Aligning chain-of-thought reasoning with continuous UAV navigation. arXiv 2026, arXiv:2603.07181v2. [Google Scholar]
  8. Anderson, P.; et al. Vision-and-language navigation: Interpreting visually-grounded navigation instructions in real environments. Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. (CVPR), 2018; pp. 3674–3683. [Google Scholar] [CrossRef]
  9. Qi, Y.; et al. REVERIE: Remote embodied visual referring expression in real indoor environments. Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. (CVPR), 2020; pp. 9979–9988. [Google Scholar] [CrossRef]
  10. Zhu, F.; Liang, X.; Zhu, Y.; Yu, Q.; Chang, X.; Liang, X. SOON: Scenario oriented object navigation with graph-based exploration. Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. (CVPR), 2021; pp. 12684–12694. [Google Scholar] [CrossRef]
  11. Liu, S.; Zhang, H.; Qi, Y.; Wang, P.; Zhang, Y.; Wu, Q. AerialVLN: Vision-and-language navigation for UAVs. Proc. IEEE/CVF Int. Conf. Comput. Vis. (ICCV), Paris, France, 2023; pp. 15338–15348. [Google Scholar] [CrossRef]
  12. Lin, B.; et al. EvolveNav: Empowering LLM-based vision-language navigation via self-improving embodied reasoning. IEEE Trans. Pattern Anal. Mach. Intell. 2026, vol. 48(no. 8), 9782–9796. [Google Scholar] [CrossRef] [PubMed]
  13. Lan, Z.; Chen, M.; Goodman, S.; Gimpel, K.; Sharma, P.; Soricut, R. ALBERT: A lite BERT for self-supervised learning of language representations. Proc. Int. Conf. Learn. Represent. (ICLR) 2020. [Google Scholar] [CrossRef]
  14. Liu, Z.; et al. MobileLLM: Optimizing sub-billion parameter language models for on-device use cases. Proc. 41st Int. Conf. Mach. Learn. (ICML) 2024, vol. 235, 32431–32454. [Google Scholar]
  15. Bae, S.; Fisch, A.; Harutyunyan, H.; Ji, Z.; Kim, S.; Schuster, T. Relaxed recursive transformers: Effective parameter sharing with layer-wise LoRA. Proc. Int. Conf. Learn. Represent. (ICLR) 2025. [Google Scholar] [CrossRef]
  16. Bae, S.; et al. Mixture-of-Recursions: Learning dynamic recursive depths for adaptive token-level computation. Adv. Neural Inf. Process. Syst. vol. 38(2025), 107088–107133. [CrossRef]
  17. Xin, J.; Tang, R.; Lee, J.; Yu, Y.; Lin, J. DeeBERT: Dynamic early exiting for accelerating BERT inference. Proc. 58th Annu. Meeting Assoc. Comput. Linguistics (ACL), 2020; pp. 2246–2251. [Google Scholar] [CrossRef]
  18. Liu, W.; Zhou, P.; Wang, Z.; Zhao, Z.; Deng, H.; Ju, Q. FastBERT: A self-distilling BERT with adaptive inference time. Proc. 58th Annu. Meeting Assoc. Comput. Linguistics (ACL), 2020; pp. 6035–6044. [Google Scholar] [CrossRef]
  19. Raposo, D.; Ritter, S.; Richards, B.; Lillicrap, T.; Humphreys, P. C.; Santoro, A. Mixture-of-Depths: Dynamically allocating compute in transformer-based language models. arXiv 2024, arXiv:2404.02258. [Google Scholar]
  20. Zhang, J.; Meng, D.; Zhang, Z.; Huang, Z.; Wu, T.; Wang, L. p-MoD: Building mixture-of-depths MLLMs via progressive ratio decay. Proc. IEEE/CVF Int. Conf. Comput. Vis. (ICCV), 2025; pp. 3705–3715. [Google Scholar]
  21. Jiang, A. Q.; et al. Mixtral of experts. arXiv 2024, arXiv:2401.04088. [Google Scholar]
  22. Dai, D.; et al. DeepSeekMoE: Towards ultimate expert specialization in mixture-of-experts language models. Proc. 62nd Annu. Meet. Assoc. Comput. Linguist. (ACL) 2024, vol. 1, 1280–1297. [Google Scholar] [CrossRef]
  23. Lin, B.; et al. MoE-LLaVA: Mixture of experts for large vision-language models. IEEE Trans. Multimed. 2026, vol. 28, 4408–4419. [Google Scholar] [CrossRef]
  24. Zhang, J.; et al. NaVid: Video-based VLM plans the next step for vision-and-language navigation. Proc. Robotics: Science and Systems (RSS), Delft, Netherlands, Jul. 2024. [Google Scholar] [CrossRef]
  25. Yao, X.; Gao, J.; Xu, C. NavMorph: A self-evolving world model for vision-and-language navigation in continuous environments. Proc. IEEE/CVF Int. Conf. Comput. Vis. (ICCV), Oct. 2025; pp. 5536–5546. [Google Scholar] [CrossRef]
  26. Cheng, A.-C.; et al. NaVILA: Legged robot vision-language-action model for navigation. Proc. Robotics: Science and Systems (RSS), Los Angeles, CA, USA, Jun. 2025. [Google Scholar] [CrossRef]
Figure 1. Overview of ARC-VLN with recursive parameter sharing and token-type-aware routing.
Figure 1. Overview of ARC-VLN with recursive parameter sharing and token-type-aware routing.
Preprints 244106 g001
Figure 2. Distribution of visual token exit depths in ARC-VLN on Test-Seen and Test-Unseen.
Figure 2. Distribution of visual token exit depths in ARC-VLN on Test-Seen and Test-Unseen.
Preprints 244106 g002
Figure 3. Spatial visualization of visual token exit depths in ARC-VLN.
Figure 3. Spatial visualization of visual token exit depths in ARC-VLN.
Preprints 244106 g003
Figure 4. Stop success conversion rates in the ablation study on Test-Seen.
Figure 4. Stop success conversion rates in the ablation study on Test-Seen.
Preprints 244106 g004
Figure 5. Stop success conversion rates in the ablation study on Test-Unseen.
Figure 5. Stop success conversion rates in the ablation study on Test-Unseen.
Preprints 244106 g005
Figure 6. Distribution of visual token exit depths in ARC-VLN on Test-Seen and Test-Unseen.
Figure 6. Distribution of visual token exit depths in ARC-VLN on Test-Seen and Test-Unseen.
Preprints 244106 g006
Figure 7. Spatial visualization of visual token exit depths in ARC-VLN.
Figure 7. Spatial visualization of visual token exit depths in ARC-VLN.
Preprints 244106 g007
Table 1. Comparison of navigation performance, parameter efficiency and computational efficiency on the OpenFly benchmark
Table 1. Comparison of navigation performance, parameter efficiency and computational efficiency on the OpenFly benchmark
Test-Seen
Method NE↓ SR↑ OSR↑ SPL↑ Par↓ AS↓ GFL↓ IL↓ AIM↓
AerialVLN (2023, ICCV) [11] 128.2m 13.8% 35.1% 12.0% - 18.3 - - -
NaVid (2024, RSS) [24] 140.1m 21.9% 38.2% 19.9% 6.7B 18.1 7.2e8 8.6s 15.6 GB
NavMorph (2025, ICCV) [25] 133.7m 17.8% 19.1% 15.0% - 11.3 - - -
NaVILA (2025, RSS) [26] 101.9m 23.0% 50.8% 18.8% 8B 23.4 3.8e9 22.9s 17.1 GB
OpenFly (2026, ICLR) [5] 122.8m 29.1% 55.3% 22.3% 6.7B 20.9 10.4e8 11.0s 15.6 GB
ARC-VLN (Ours) 70.5m 33.4% 44.5% 31.1% 2.7B 10.7 4.4e8 5.3s 7.1 GB
Test-Unseen
Method NE↓ SR↑ OSR↑ SPL↑ Par↓ AS↓ GFL↓ IL↓ AIM↓
AerialVLN (2023, ICCV) [11] 201.1m 2.7% 21.2% 2.1% - 21.7 - - -
NaVid (2024, RSS) [24] 193.7m 15.8% 27.1% 10.6% 6.7B 17.9 2.1e8 8.6s 15.6 GB
NavMorph (2025, ICCV) [25] 105.6m 22.3% 25.3% 18.4% - 12.3 - - -
NaVILA (2025, RSS) [26] 99.8m 23.3% 58.0% 17.9% 8B 22.1 1.0e9 25.4s 17.1 GB
OpenFly (2026, ICLR) [5] 158.6m 27.1% 62.3% 14.1% 6.7B 23.3 3.1e8 11.7s 15.6 GB
ARC-VLN (Ours) 55.7m 29.3% 39.4% 27.3% 2.7B 10.1 7.1e7 4.2s 7.1 GB
Table 2. Model configurations for the ablation study of ARC-VLN
Table 2. Model configurations for the ablation study of ARC-VLN
Variant PS DR L ent Route
OpenFly × × – Full Depth
Shared Backbone ✔ × – Full Depth
w/o L ent ✔ ✔ × Exit_B0
Exit_B1
Exit_B2
ARC-VLN(Ours) ✔ ✔ ✔ Adaptive Depth
Table 3. Ablation results for navigation performance and efficiency on the OpenFly benchmark
Table 3. Ablation results for navigation performance and efficiency on the OpenFly benchmark
Test-Seen
Variant NE↓ SR↑ OSR↑ SPL↑ Par↓ AS↓ GFL↓ IL↓ AIM↓
OpenFly 122.8m 29.1% 55.3% 22.3% 6.7B 20.9 10.4e8 11.0s 15.6 GB
Shared Backbone 101.8m 27.7% 50.3% 25.3% 2.7B 13.7 7.9e8 10.7s 7.0 GB
w/o L ent Exit_B0 146.7m 18.8% 48.7% 16.6% 2.7B 28.5 9.9e8 20.6s 7.1 GB
Exit_B1 143.5m 26.0% 52.1% 23.6% 2.7B 20.1 9.5e8 19.1s 7.1 GB
Exit_B2 109.9m 27.5% 48.9% 24.7% 2.7B 11.1 8.4e8 11.8s 7.1 GB
ARC-VLN(Ours) 70.5m 33.4% 44.5% 31.1% 2.7B 10.7 4.4e8 5.3s 7.1 GB
Test-Unseen
Variant NE↓ SR↑ OSR↑ SPL↑ Par↓ AS↓ GFL↓ IL↓ AIM↓
OpenFly 158.6m 27.1% 62.3% 14.1% 6.7B 23.3 3.1e8 11.7s 15.6 GB
Shared Backbone 102.9m 22.5% 52.9% 20.0% 2.7B 13.3 2.0e8 17.8s 7.0 GB
w/o L ent Exit_B0 202.8m 8.4% 60.8% 6.9% 2.7B 38.2 3.3e8 23.2s 7.1 GB
Exit_B1 154.1m 20.6% 59.5% 18.6% 2.7B 20.4 2.5e8 14.7s 7.1 GB
Exit_B2 113.2m 23.0% 55.5% 20.2% 2.7B 14.5 2.2e8 16.6s 7.1 GB
ARC-VLN(Ours) 55.7m 29.3% 39.4% 27.3% 2.7B 10.1 7.1e7 4.2s 7.1 GB
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.
Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.