DART-VLN: Test-Time Control for VLN

• The paper introduces a test-time control framework that applies memory decay to reweight visual evidence without altering stored content.
• It incorporates a lightweight anti-loop regularization to penalize immediate reversals, reducing inefficient backtracking during navigation.
• Experimental results on R2R and REVERIE benchmarks show shortened trajectories, lower runtime, and stable performance improvements.

DART-VLN is a training-free test-time control framework for discrete vision-language navigation (VLN) that targets two failure modes of memory-based agents under partial observability: stale historical evidence at memory readout and inefficient local backtracking during action selection. The framework combines Test-Time Memory Decay, a read-side memory reweighting rule that suppresses stale and redundant evidence without rewriting stored content, with Anti-Loop Regularization, a lightweight next-hop penalty that discourages immediate reversals during action selection. It introduces no new learnable parameters and leaves the learned backbone unchanged. In experiments on R2R and REVERIE, decay-only provides stable read-side gains, while decay+anti-loop achieves the best overall quality-efficiency trade-off, yielding shorter trajectories, lower runtime, and improved navigation performance in key settings (Zhang et al., 1 Jul 2026).

1. Problem setting and design objective

The framework is defined for memory-based discrete VLN agents operating with frozen backbones. The motivating observation is that such agents must act under partial observability, yet remain vulnerable at test time even when the backbone is strong. The two specific failure modes identified are stale historical evidence at memory readout and inefficient local backtracking during action selection (Zhang et al., 1 Jul 2026).

DART-VLN addresses these issues strictly at inference time. Its control logic is external to the learned model: memory slots are reweighted only during readout, and action logits are shifted only before argmax-decoding or stop-decision. No slot is rewritten or removed by the decay rule, and no changes are made to the learned backbone or the stop head by the anti-loop controller. This suggests a deliberate separation between representational capacity learned during training and reliability-efficiency corrections imposed at test time.

2. Test-Time Memory Decay

Test-Time Memory Decay assumes an explicit memory of slots $\{m_i\}$, for example GridMM. For each slot $i$, it maintains three scalar metadata: $a_i \in \mathbb{N}$, the “age,” defined as the number of steps since the slot was last refreshed; $c_i \in \mathbb{N}$, the “visit count,” how many times the agent has observed that slot’s region; and $n_i \in [0,1]$, the “novelty,” an exponential moving average of the instantaneous feature change (Zhang et al., 1 Jul 2026).

The instantaneous novelty at time $t$ is

$$v_i = \operatorname{clip}(1 - \cos(f_i^{old}, f_i^{new}), 0, 1).$$

The novelty EMA update is

$$n_i \leftarrow p \cdot n_i + (1-p)\cdot v_i,\qquad p=0.5 \text{ in practice.}$$

The read-side weight is computed as

$$w_i = \operatorname{clip}\Bigl(\exp(-N \cdot a_i)\cdot \Bigl(1-\alpha\cdot \frac{c_i}{c_i+1}\Bigr)\cdot (0.5+0.5\cdot n_i),\; w_{\min}, w_{\max}\Bigr),$$

with $N=0.12$, $i$0, $i$1, and $i$2. The three multiplicative factors have distinct roles: $i$3 down-weights stale slots; $i$4 down-weights repeated slots; and $i$5 favors slots still showing fresh features. During readout, each slot embedding $i$6 is multiplied by $i$7 before memory aggregation.

The corresponding pseudocode specifies the following read-side sequence: for each slot, compute $i$8; update $i$9; compute $a_i \in \mathbb{N}$0; then multiply each slot embedding $a_i \in \mathbb{N}$1 by $a_i \in \mathbb{N}$2 before passing to the backbone’s memory-read module. Because $a_i \in \mathbb{N}$3 is a deterministic function of stored metadata, no extra learnable parameters are introduced and no slots are altered. A plausible implication is that the method targets read-side calibration rather than memory rewriting.

3. Anti-Loop Regularization

Anti-Loop Regularization modifies next-hop selection after the backbone has produced unpenalized action scores $a_i \in \mathbb{N}$4 for each reachable candidate viewpoint $a_i \in \mathbb{N}$5. At step $a_i \in \mathbb{N}$6, define $a_i \in \mathbb{N}$7 as the immediate graph neighbor on the shortest-path from current node $a_i \in \mathbb{N}$8 to $a_i \in \mathbb{N}$9. The penalty is

$c_i \in \mathbb{N}$0

with $c_i \in \mathbb{N}$1, $c_i \in \mathbb{N}$2, and $c_i \in \mathbb{N}$3. The first term penalizes immediate reversal to the previous viewpoint $c_i \in \mathbb{N}$4, and the second is a weak repeat-visit penalty applied when entering a node for the $c_i \in \mathbb{N}$5-th or later time. The final adjusted score is

$c_i \in \mathbb{N}$6

At inference time, before argmax-decoding or stop-decision, $c_i \in \mathbb{N}$7 is subtracted from each candidate’s logits (Zhang et al., 1 Jul 2026).

The regularizer is explicitly conservative. It only shifts local scores and does not alter the learned backbone or stop head. The paper further notes a limitation: anti-loop does not guarantee monotonic endpoint gains and may hinder recovery if a backtrack were genuinely needed. This suggests that the method is optimized for reducing inefficient local reversals rather than enforcing globally optimal route corrections.

4. Inference loop and controller integration

The combined DART-VLN inference loop begins from $c_i \in \mathbb{N}$8 with empty trajectory $c_i \in \mathbb{N}$9 and zeroed visit counts. For each step $n_i \in [0,1]$0, the instruction and current observation at $n_i \in [0,1]$1 are encoded, the weights $n_i \in [0,1]$2 are recomputed, weighted memory is aggregated, candidate scores $n_i \in [0,1]$3 are produced by the backbone, next-hop penalties are computed, and adjusted scores $n_i \in [0,1]$4 are formed. The next action is selected by

$n_i \in [0,1]$5

with termination if STOP is selected. The simulator is then stepped, $n_i \in [0,1]$6 is appended to $n_i \in [0,1]$7, the visit count of $n_i \in [0,1]$8 is updated, matched memory-slot metadata are refreshed by setting $n_i \in [0,1]$9, incrementing $t$0, and refreshing $t$1, while all other slots have their ages incremented (Zhang et al., 1 Jul 2026).

Algorithm 1 is summarized as: $t$2

The integration strategy is notable for what it does not change. The framework leaves the learned backbone unchanged, introduces no new learnable parameters, and confines intervention to memory readout and local action scoring. This suggests an architectural role as a test-time controller rather than a retrained VLN policy.

5. Experimental results on R2R and REVERIE

The evaluation uses two benchmarks. R2R (Room-to-Room) measures Success Rate (SR), Path Length (TL), Navigation Error (NE), SPL, plus wall-clock runtime. REVERIE is a joint navigation+object grounding benchmark with Oracle SR (OSR), SR, SPL, RGS (Remote Grounding Success), RGSPL, TL, and runtime. The compared methods are the GridMM baseline (frozen backbone), update-only, decay-only, full-mode (update-only + decay-only), and decay+anti-loop, which is the DART-VLN mainline (Zhang et al., 1 Jul 2026).

On R2R, the reported results are:

• GridMM: TL=13.27 /14.43 m, NE=2.83 /3.35 m, SR=64%/73%, SPL=44%/62%, runtime=938 s/2313 s
• decay-only: TL=13.29/14.52, NE=2.59/3.19, SR=64/74, SPL=46/63, runtime=743/1621
• decay+anti-loop: TL=12.41/13.80, NE=2.69/3.38, SR=66/74, SPL=47/63, runtime=666/1330

The key observation reported for R2R is that decay-only sharply cuts NE and runtime, while adding anti-loop further shortens paths and preserves SR/SPL.

On REVERIE val unseen, the reported results are:

• GridMM: TL=23.20 m, OSR=57.48%, SR=51.37%, SPL=36.47%, RGS=34.57%, RGSPL=24.56%, runtime=4330 s
• decay-only: TL=23.15, OSR=58.12, SR=51.98, SPL=36.60, RGS=34.68, RGSPL=24.72, runtime=2998
• decay+anti-loop: TL=21.57, OSR=57.99, SR=52.34, SPL=37.53, RGS=35.37, RGSPL=25.44, runtime=1498

The key observation reported for REVERIE is that read-decay alone reduces runtime (~30%) with mild SR/SPL gains, while adding anti-loop produces the best overall quality-efficiency trade-off.

The ablation summary further states that decay-only is the most stable single intervention, cleanly improving or holding all metrics while reducing runtime; update-only and full-mode, which involve write-side rewrites, yield less reliable gains and sometimes hurt performance; and decay+anti-loop builds atop decay-only, with anti-loop providing further path-length and runtime reductions. A plausible implication is that read-side control is more robust than write-side intervention under frozen backbones.

6. Behavioral analysis, limitations, and research directions

Behavioral analysis isolates local backtracking. On R2R val unseen, GridMM has backtrack rate 2.30%, average steps 6.02, and TL=13.27; decay-only has backtrack 3.51%, steps=6.00, and TL=13.29; decay+anti-loop has backtrack 2.01%, steps=5.90, and TL=12.41. On REVERIE val unseen, GridMM has backtrack 8.43%, steps=8.52, and TL=23.20; decay-only has backtrack 8.45%, steps=8.52, and TL=23.15; decay+anti-loop has backtrack 5.99%, steps=8.46, and TL=21.57. The interpretation given is explicit: read-decay alone does not affect local reversal, whereas anti-loop sharply reduces immediate backtracks, yielding shorter trajectories (Zhang et al., 1 Jul 2026).

A qualitative example uses the instruction “Go through the hallway and stop near the sofa.” The baseline trajectory includes two backtracks and one wrong revisit, with TL≈20.8 m and 13 steps, whereas the decay+anti-loop trajectory avoids reversals entirely, with TL≈12.4 m and 7 steps. This example is consistent with the reported reduction in local backtracking.

The stated limitations are narrow but consequential. The method was tested only on discrete-graph VLN with a GridMM backbone; continuous environments or other memory structures may require tuning. Anti-loop is conservative and may hinder recovery if a genuine backtrack is needed. Future directions proposed in the paper are to extend the approach to continuous control, learn adaptive penalty strengths at test time, or combine it with lightweight planning for guaranteed correction. More broadly, the reported results show that modest test-time control can make memory-based discrete VLN more reliable and efficient without retraining.