Flex: End-to-End Text-Instructed Visual Navigation with Foundation Models

## Abstract

Abstract End-to-end learning directly maps sensory inputs to actions, creating highly integrated and efficient policies for complex robotics tasks. However, such models are tricky to efficiently train and often struggle to generalize beyond their training scenarios, limiting adaptability to new environments, tasks, and concepts. In this work, we investigate the minimal data requirements and architectural adaptations necessary to achieve robust closed-loop performance with vision-based control policies under unseen text instructions and visual distribution shifts.
To this end, we design datasets with various levels of data representation richness, refine feature extraction protocols by leveraging multi-modal foundation model encoders, and assess the suitability of different policy network heads. Our findings are synthesized in Flex ( F ly- lex ically), a framework that uses pre-trained Vision Language Models (VLMs) as frozen patch-wise feature extractors, generating spatially aware embeddings that integrate semantic and visual information. These rich features form the basis for training highly robust downstream policies capable of generalizing across platforms, environments, and text-specified tasks.
We demonstrate the effectiveness of this approach on quadrotor fly-to-target tasks, where agents trained via behavior cloning on a small simulated dataset successfully generalize to real-world scenes, handling diverse novel goals and command formulations.

## 1 Introduction

A significant dimension of human reasoning is mediated through the combination of vision and language, facilitating our mobility in the physical world and our ability to follow directions. Such flexibility and concept understanding are highly desirable in autonomous robots, enabling interactions with humans and handling variants of complex real-world tasks from few representative examples. This inspires an exploration of the conditions necessary to equip robots with a human-like intuition and capacity to execute tasks across various contexts.

End-to-end learning.
Despite progress in end-to-end deep learning for autonomous navigation (Chib & Singh, ), and improvements in safety (Xiao et al., ) and generalization (Chahine et al., ; Quach et al., ), reasoning at the level of raw pixel and sensor data still suffers from significant limitations. End-to-end models remain very much black-box, inherently incapable of user interaction, and confined to the scope seen in training data.

Foundation Models.
Immense strides have been made in developing language-augmented foundational vision models with robust capabilities in open-world visual understanding, for tasks including classification (Radford et al., ; Yang et al., ), detection (Li et al., ; Zhong et al., ), segmentation (Kirillov et al., ; Li et al., ), and, captioning (Li et al., ; Wang et al., ). Within robotics, benefits have mostly been reaped in open-vocabulary detection and object manipulation (Chen et al., ; Liu et al., ), intermediate to high-level planning (Ahn et al., ) and even direct action prediction (Brohan et al., ). In navigation, similar approaches separating detection and control (Maalouf et al., ), or generating way-points plans (Shah et al., ) have been adopted to navigate to open-set goals.

Less is More: Streamlining robotics control with minimal design and data. Rather than following the trend of training increasingly large foundation models on massive datasets of robotics demonstrations (Brohan et al., ; Shah et al., ; Brohan et al., ), we focus on exploiting minimal simulation datasets, utilizing pre-trained frozen encoders with minimal adaptations, and efficiently training small policy heads, while still achieving generalization on out-of-distribution (OoD) scenarios.

Leveraging off-the-shelf foundation models. Multi-modal foundation model encoders produce unified embeddings from image and text inputs (Li et al., ; ; Radford et al., ). While effective for open-set tasks, global embeddings are less suited for end-to-end robot learning, where granular and local information prove to be critical. In fact, we show that robotics demands go beyond scene-level understanding, requiring spatial, text-fused geometric information. Existing methods (Wang et al., ; Jatavallabhula et al., ; Amir et al., ) fall short of fully integrating text commands into these descriptors to support interactive generalization. We bridge this gap by proposing a general approach for extracting text-patch fused features from VLM architectures, applicable to a wide range of vision-based robotic learning tasks.

Hence, we introduce Flex; a minimal methodology that leverages rich multi-modal descriptors from VLMs to enable user interactive end-to-end visual navigation agents. Our key contributions are:

- •
The identification of the core components needed for robust multi-modal generalization in robotic tasks, combining spatial and lexical features via patch-wise descriptors from VLMs.
- •
The development of a training pipeline for closed-loop visual navigation agents that generalize across unseen environments, using real-time natural language instructions to achieve adaptability well beyond the training scope.
- •
Extensive experiments on drone fly-to-target tasks, showcasing the ability to generalize from limited simulated training data to diverse real-world scenarios, successfully adapting to new objects, environments, and text instructions.

## 2 Preliminaries

End-to-end multi-modal imitation learning.
The setup considered is that of an end-to-end control system $f$ that generates commands ${\bm{u}}\in\mathbb{R}^{n}$ where $n$ is the dimension of the output vector. The system takes multi-modal input comprising of a RGB image ${\bm{\mathsfit{I}}}\in\mathbb{R}^{h\times w\times 3}$, with $h,w$ representing the frame height and width respectively, and a natural language text command $T$. $f$ can be seen as the composition of a feature extraction backbone $\phi$ and a policy head $\pi$, such that $f=\pi\circ\phi$, and yielding control commands through ${\bm{u}}=f({\bm{\mathsfit{I}}},T)=\pi(\phi({\bm{\mathsfit{I}}},T))$.

Throughout this work, we do not seek to train or fine-tune $\phi$, but instead, investigate how architectural choices leveraging frozen VLM encoders can yield dense feature representations ${\bm{\mathsfit{F}}}\in\mathbb{R}^{h^{\prime}\times w^{\prime}\times d}$ that integrate both spatial and semantic information tailored to robotics applications (Figure 1). We thus only train the policy network head $\pi$, parameterized by weights $\theta$ adopting the Imitation Learning (IL) paradigm of learning from expert demonstrations.

Indeed, given a dataset $\mathcal{D}=\{({\bm{\mathsfit{I}}}_{i},T_{i},{\bm{u}}_{i})\}_{i=1}^{N}$ consisting of $N$ samples, where each sample contains an RGB image ${\bm{\mathsfit{I}}}_{i}$, a natural language command $T_{i}$, and a ground truth control command ${\bm{u}}_{i}\in\mathbb{R}^{n}$, the policy network $\pi_{\theta}$ is trained to minimize the Mean Squared Error (MSE) between the predicted control command $\hat{{\bm{u}}}_{i}=\pi_{\theta}(\phi({\bm{\mathsfit{I}}}_{i},T_{i}))$ and the ground truth label ${\bm{u}}_{i}$. With the notation adopted the training objective $\mathcal{L}$ is given in equation 1.

$$ $\displaystyle\mathcal{L}(\theta)=\frac{1}{N}\sum_{i=1}^{N}\|\hat{{\bm{u}}}_{i} -{\bm{u}}_{i}\|_{2}^{2}$ (1) $$

Autonomous Drone Fly-to-target Task.
The scope of this research extends to a broad array of robotics tasks that rely on the use of both images and text. In the interest of cohesive illustration, we delve into a single running example throughout this manuscript. We explore quadrotor flight and more specifically a vision-based fly-to-target task where the goal can be specified by the human user via natural language. In this context, the control command ${\bm{u}}\in\mathbb{R}^{4}$ comprises of scalar translation velocities $v_{x},v_{y},v_{z}$ and the drone’s desired yaw rate $\dot{\psi}$. The input RGB frame ${\bm{\mathsfit{F}}}\in\mathbb{R}^{224\times 224\times 3}$ is obtained from the drone’s front-facing camera and the text command $T$ is provided by the user.

Problem statement. We seek to establish the bare design criteria for training robust, text-instructed, end-to-end control agents. Specifically, our goal is to delineate the conditions for effective leveraging of off-the-shelf models to extract meaningful features suitable for compact downstream policy networks. Our agents should not only excel in learning tasks from very simplified datasets in simulation but also demonstrate robust generalization capabilities to handle previously unseen scenarios.
We probe into the three pillars of the IL framework and attempt to answer the following questions:

- 1.
Dataset design: What is the minimal degree of data diversity required to obtain sufficiently rich feature representations?
- 2.
Feature extractor: What are the suitable feature extractors for text and vision-based robotics learning? How should they be employed to offer potent downstream generalization capability?
- 3.
Policy network: What is the impact of the choice of policy network architecture on the performance and interpretability of the trained agents?

## 3 Methods

### 3.1 Training data

A desirable property for an imitation learning system is to master a task from a handful of representative expert demonstrations without requiring extensive enumeration of use cases or intensive randomization and augmentation techniques.
Hence, relying on internet-scale trained VLMs for feature extraction largely mitigates the impediments on training dataset size, diversity and augmentation. We investigate the extent to which this statement holds, and limit ourselves to the use of a single simulated scene to generate four training datasets, evaluating the impact of diversity in the goal and text instruction phrasing on generalization capabilities of trained agents:

1. One object and one command, containing demonstrations reaching a single goal object (red sphere) with a single command syntax (”Fly to the red ball”).

1M. One object and multiple commands, with the same goal object, but each run instructed with a lexical alternative of the instruction (as discussed in Appendix A.3).

2. Two objects and one command, with red and blue spheres as the example goals and single command wording in either case (”Fly to red/blue ball”).

2M. Two objects and multiple commands, containing both colored spheres and variations of the syntax between demonstrations. (Training run sequence frames are provided in Figure 10)

### 3.2 Patch-wise Text-vision Spatial Features

Generic image-text features.
Robust OoD generalization relies on universal rather than domain-specific features for policy learning. Foundation model encoders leverage internet-scale data to learn generic features from a wide spectrum of contexts. Moreover, incorporating textual instructions demands an extractor capable of seamlessly integrating text inputs with visual features. Thus, a natural choice is pre-trained VLM as our feature extractor cornerstone. More specifically, BLIP-2 (Li et al., ) is used throughout this work, as it is specifically designed to fuse multi-modal information from large-scale textual and visual datasets, providing a cohesive representation.

Spatial resolution for robotic tasks.
Foundation models typically output a global feature vector representing the entire image. This coarse representation is unsuitable for robotics, where policy learning depends on fine-grained spatial information to effectively interpret and respond to the scene.
Thus, we propose a method to extract spatial feature vectors for specific areas in an image. To obtain the global descriptor for a frame, we collect such features for multiple areas/patches covering the whole image.
Specifically, given an input frame/image ${\bm{\mathsfit{I}}}\in\mathbb{R}^{h\times w\times 3}$, an input text command $T$, and the patch-resolution $h^{\prime}\leq h,w^{\prime}\leq w$, we provide a method which utilizes a multi-modal foundation model $\texttt{VLM}:\mathbb{R}^{h\times w\times 3}\to\mathbb{R}^{d}$ to derive a tensor of feature descriptors $\mathbf{F}\in\mathbb{R}^{h^{\prime}\times w^{\prime}\times d}$, that fuses all the semantic information of ${\bm{\mathsfit{I}}}$ with the text input $T$ and maintains its location in the scene.
For simplicity purposes, we equate $h^{\prime}$ and $w^{\prime}$ to the number of (non-overlapping) patches used to divide the input image ${\bm{\mathsfit{I}}}$ when applying VLM on it (we will discuss how $h^{\prime}$ and $w^{\prime}$ can be adjusted to any values $\leq h,w$, respectively) and $n=h^{\prime}w^{\prime}$.

Notations. Let IMG-DESC be the image encoder of VLM consisting of $L$ layers. For every layer $\ell\in\left\{1,\cdots,L\right\}$, we use $Q^{\ell},K^{\ell}\in\mathbb{R}^{n\times d_{k}},V^{\ell}\in\mathbb{R}^{n\times d}$ to denote the output query, key, and value matrices of the $\ell$th attention layer, during the feedforward pass of applying IMG-DESC on ${\bm{\mathsfit{I}}}$, i.e., during $\texttt{IMG-DESC}({\bm{\mathsfit{I}}})$.
We now describe our mechanism for extracting patch-text fused features $\mathbf{F}^{(j)}$ for a single patch ${\bm{\mathsfit{I}}}^{(j)}$, where $j\in\left\{1,\cdots,n\right\}$. Then, this can be applied sequentially or in parallel to all patches.

Figure: Figure 1: Flex pipeline: The drone front view frame capture is successively masked then, in conjunction with a user-specified text instruction, encoded via a pre-trained VLM to create a grid of rich per patch features. A trainable policy network computes the translation velocities and yaw rate commands to be executed by the quadrotor.
Refer to caption: x1.png

Single patch feature extraction. To derive the feature vector $\mathbf{F}^{(j)}$ for the $j$th patch, we introduce an attention mask $m^{(j)}=(m_{1}^{(j)},\cdots,m_{n}^{(j)})^{T}\in[0,1]^{n}$. Each component $m_{i}^{(j)}$ within this vector, ranging between 0 0 and $1$, determines the contribution of the $i$th patch to the target patch feature $\mathbf{F}^{(j)}$. For instance, to completely exclude patch $i$, set $m_{i}^{(j)}=0$. Additionally, to control the masking, we introduce $\alpha\ll 0$ as the parameter controlling the intensity of the masking effect; as $|\alpha|$ increases, the masking effect becomes stronger.

Now, to extract the patch feature vector $\mathbf{F}^{(j)}$, we propose to modify the $\ell$-th attention layer to employ the masking provided by $m$ as follows:

- 1.
Set $M^{(j)}=[m^{(j)},\cdots,m^{(j)}]^{T}\in\mathbb{R}^{n\times n}$; a matrix of $n$ rows each is equal to $m^{(j)}$, and define $\mathbf{1}\in\mathbb{R}^{n\times n}$ to be an all-ones matrix.
- 2.
Compute $G^{\ell}:=Q^{\ell}{(K^{\ell})}^{T}$; the matrix multiplication of the key and query matrices at the $\ell$-th attention layer.
- 3.
A masked version $\hat{G}^{\ell,(j)}$ of $G^{\ell}$ which focuses on the features of the patches (area) described by $m^{(j)}$ is computed as
$\hat{G}^{\ell,(j)}=G^{\ell}+(\mathbf{1}-M^{(j)})\cdot\alpha,$
This operation adjusts the attention scores in $\hat{G}^{\ell,(j)}$ according to the mask vector $m^{(j)}$. The $\mathbf{1}-M^{(j)}$ term ensures that patches with an attention mask of 1 remain unchanged, while those with a mask near 0 have their scores reduced to $\alpha$, effectively masking them.
- 4.
With the modified attention scores, the final attention weights are obtained using the softmax function. The attention layer output is now computed as:
$\begin{split}F_{\ell}^{(j)}&:=\text{SoftMax}(\hat{G}^{\ell,(j)})(V^{\ell})^{T}
.\end{split}$
(2)

Notably, we use values of $\alpha\ll 0$ with a very large $\left|\alpha\right|$. Observe that at the end of this process, when $m_{i}^{(j)}=0$, the corresponding descriptor in $\hat{G}^{\ell,(j)}$ becomes a vector where all entries are approximately $\alpha$. Since $\alpha$ is a very large negative number (e.g., assumably $-\infty$), the result after applying the soft operation will cause its contribution to be close to 0 0 thus not affecting the final output. When $m_{i}^{(j)}=1$, the corresponding descriptor in $\hat{G}^{\ell,(j)}$ is not affected at all, thus, its contribution remains the same through the process.

Text-Patch fusion. Let TEXT-DESC be the Text Encoder of VLM, and let TEXT-IMG-Fusion be its text-vision fusion block. Following the $\ell$th attention layer, its output is fed standardly as input to the remaining vision encoder model as $\texttt{IMG-DESC}^{\ell\rightarrow}(F_{\ell}^{(j)})$, where, $\texttt{IMG-DESC}^{\ell\rightarrow}$ denotes the remaining part of the vision encoder of the foundation model after the $\ell$-th layer. In parallel to the vision encoding, the text command $T$ is encoded via the text encoder $\texttt{TEXT-DESC}(T)$, and then both text and patch descriptors are fused to create the final text-patch fused descriptor as

$$ $\mathbf{F}^{(j)}:=\texttt{TEXT-IMG-Fusion}(\texttt{IMG-DESC}^{\ell\rightarrow} (F_{\ell}^{(j)}),\texttt{TEXT-DESC}(T)).$ $$

We note that this method can be extended to any region-wise feature extraction by generalizing the definition of patches to include arbitrarily shaped regions.

Extracting $m\times m$ resolution descriptors. Let $h^{\prime}$ and $w^{\prime}$ denote the number of non-overlapping patches used to divide the input image ${\bm{\mathsfit{I}}}$ by VLM. For simplicity, we set $h^{\prime}=w^{\prime}=16$ (as in BLIP-2) and define $m\leq w^{\prime}$ as the desired resolution, where $w^{\prime}$ is divisible by $m$.
We have $w^{\prime 2}$ patches ($16\times 16$ in BLIP-2), each identified by its coordinates $(x,y)$ on the grid ($x,y\in\{1,\cdots w^{\prime}\}$). While extracting a descriptor for every patch provides detailed information, we seek a minimalist design and smaller resolutions for simpler training.
To extract $m\times m$ feature descriptors, we split the $w^{\prime}\times w^{\prime}$ grid into $m\times m$ sub-grids, each containing $w^{\prime}/m\times w^{\prime}/m$ patches. We extract a descriptor for each sub-grid by setting the corresponding coordinates in the mask vector $m$ to 1 and the rest to 0.

We consider multiple resolutions, splitting the image into 1 (entire image, mask 16$\times$16), 4 (masks 8$\times$8), 16 (masks 4$\times$4), 64 (masks 2$\times$2), and 256 (masks 1$\times$1) square patches. Detailed examples of grid splits and masks are provided in Section A.1 of the appendix.

### 3.3 Policy network

We aim to identify the most effective policy network architecture for learning from generic extracted features with limited simulated training data.
Ideally, we want to preserve text-patch details while aggregating information across layers, enabling decisions from nuanced, context-rich descriptors tailored to the task.
Vision Transformers (ViT) are of interest as they maintain spatial resolutions across layers. We also consider simpler architectures such as Convolutional Neural Networks (CNN or Conv), and Multi-Layer Perceptrons (MLP) for learning the control policy. A detailed description of each model and its parameters is provided in Appendix A.5.

## 4 Experiments

### 4.1 Fly-to-any-target Task

Task description. The objective is to develop a vision-based quadrotor navigation agent capable of reaching arbitrary user-specified goals present in its field of view (FOV) while ensuring generalization across visual scenes, in simulation as well as in the real world.

Evaluation protocol. A single test run consists of initializing a scene with a number of objects in the drone’s FOV and providing text instructions about the goal to reach. The closed-loop inference is run for a fixed number of steps, 80, slightly larger than the average training sequence length. The test is successful if the agent can navigate towards the user-instructed object and center it in the middle of the frame. Failures, on the other hand, can be identified when the drone loses the object (the target exits the FOV and/or another visual cue is centered in on), or fails to approach or center in on the goal.
The evaluation of the closed-loop performance of our system is based on monitoring the success rates on repeated runs in various evaluation configurations.

### 4.2 Experimental Setup

#### 4.2.1 Simulation

Simulator. We use the PyBullet physics engine, building off the codebase presented in (Panerati et al., ). The drone dynamics we use are based on Bitcraze’s Crazyflie 2.x nano-quadrotor.
The physics simulation runs at 240Hz, and we allow low-level flight control to occur at the same frequency, although inference runs at a much slower rate of 3Hz. Indeed, for inference or data collection, we simulate the evolution of the system with constant commands for the number of steps corresponding to the desired period.

Background scenes. In addition to the in-distribution (InD) scene which we use for training, Samurai, we design a second very different-looking environment; Stadium. In stark contrast to the training environment which has tiled flooring, the Stadium environment ground is covered by green textured grass and field lines. Also, the Stadium stands include large portions of purple walls and its structure is distinctly different from that of the Samurai temples. The Stadium environment is used for scene generalization evaluation in simulation.

Test scenarios. Each feature extractor, policy head, and dataset combination considered is tested in simulation on an increasingly demanding suite of scenarios. In each case, we gather the success rates over multiple runs, randomly initializing the positions of the potential target goals, the quadrotor distance to the objects, and the initial heading angle. Each scenario is run in both the InD (Samurai) and OoD (Stadium) scenes.
The breakdown of scenarios considered (depicted in Figure 11) is as follows:

1. Red and Blue Spheres: Easiest setup providing a measure of the mastery of the unaltered training task and performance changes based only on the change of scene and/or instruction phrasing.

2. Mixed Color Spheres: Tests the generalization capability with respect to colors with a choice of two out of red, blue, green, yellow, and purple spheres appearing at initialization.

3. Red shapes: Evaluates the sensitivity and adaptability to shapes of same color (red) with two out of a sphere, a cube, and a pyramid positioned in the quadrotor’s initial FOV.

4. Mixed Color Shapes: Similar to above with the object colors also randomized to be any of red, blue, green, yellow or purple.

5. Open Dictionary: Hardest setup that goes beyond shapes and colors, with a range of objects in a more cluttered scene. Three objects are placed in the drone FOV picked amongst a red sphere, blue sphere, a light-colored Jeep, an Australian cattle dog , a brown Horse, a tall and narrow Palm Tree, a toy Space Rocket, and a whole Watermelon.

#### 4.2.2 Real-World transfer

Hardware. Our setup utilizes a DJI M300 RTK quadcopter interfaced with a DJI Manifold 2 computer and the DJI Onboard SDK, processing commands on a base station via Wifi to achieve a runtime frequency of just over 1 Hz with our highest resolution models. Flight tests are conducted on an urban university campus lawn, with targets including various cardboard cutouts positioned on tripods. More details are provided in Appendix A.4.

Test setup. We deploy the system with the ViT policy head on the drone hardware in a series of tests with various props as targets and in different two-object initial configurations, in an urban campus environment. This is the ultimate challenge exposing the agents simultaneously to sim-to-real transfer, new scene generalization as well as new object instruction handling.

## 5 Results

### 5.1 Dataset Design

Figure: Figure 2: Success rate as a function of the dataset richness on all five simulation test scenarios. Darker lines correspond to the InD scene, and lighter colors to the OoD background. Each data point is obtained from 100 runs with command syntax ”Navigate to the [OBJECT]”.
Refer to caption: x2.png

The degree of dataset richness required for generalisation is evaluated by training Flex instances of 256-patch resolution and a ViT policy head on all of the four datasets described in Section 3.1. The success rates on the simulation test cases are depicted in Figure 2. There is a clear gap in performance between models trained on single object examples and two objects. Indeed, the former systematically try to reach the red ball when present regardless of the text instruction. They also generalize significantly worse to open dictionary objects (under 50% success rate). The gains from instruction augmentation are less potent, especially on simple geometries and color variations. However, the open dictionary setup suggests that augmentation, which acts both on the action but also choice of noun for the goal object, can offer interesting performance benefits. Thus, we conclude that training with two goal objects along with instruction augmentation (which is cheap to implement as described in Appendix A.3) are recommended practices to attain satisfactory generalization.

### 5.2 Feature Extraction Resolution

Figure: Figure 3: Success rate as a function of the feature extractor resolution on all five simulation test scenarios. Darker lines correspond to the InD scene, and lighter colors to the OoD background. Each data point is obtained from 100 runs with command syntax ”Navigate to the [OBJECT]”.
Refer to caption: x3.png

A central claim in this work is that simply using a pre-trained VLM as a text and whole image encoder is not suitable for robotics applications. This hypothesis, along with the question of the resolution of spatial features required to achieve robust visual navigation are investigated by training five Flex instances with a ViT policy head on the 2M dataset. We increase patch resolution from a single patch containing the entire image to the BLIP-2 limit of 16$\times$16 non-overlapping square patches. The performance in each case on our test suite is provided in Figure 3. The results clearly corroborate the claim regarding the failure of entire image processing. Indeed, there is a definite pattern of performance improvement with patch resolution, with a minimum of 64 patches (8$\times$8 grid division of the input frame) needed to guarantee generalization close to the 90% mark on all test setups.

### 5.3 Policy Networks

Figure: Figure 4: Success rate as a function of the policy head architecture on all five simulation test scenarios. Darker lines correspond to the InD scene, and lighter colors to the OoD background. Each data point is obtained from 100 runs with command syntax ”Navigate to the [OBJECT]”.
Refer to caption: x4.png

Performance. Policy heads, the only trainable component of Flex, are a crucial factor for the quantitative performance of the agents, but also dictate the of trajectories and behavior exhibited by the closed-loop navigation system. The former is tested on 256-patch full resolution models trained on the 2M dataset for all four policy architectures considered (presented in Section 3.3). Results are provided in Figure 4. Basic MLP policies, though capable of achieving the original training task both in and out-of-distribution, suffer from a drastic loss in performance on all but the mixed color spheres task InD, with close to complete failure in the OoD setting. This indicates that the VLM patch-wise features are not sufficiently simple and universal for direct mapping into correct decision commands. Thus, an important role in useful task information retrieval has to be played by an adequate policy architecture. Both the Conv and ViT policies offer somewhat strong performance. The latter consistently surpasses the former by 10 % or more, and with dips below the 90% performance bar only in OoD settings where confusion between purple goals and the purple background occur.

Figure: Figure 5: Absolute error to expert per policy network for each of the output dimensions ($v_{x},v_{y}$ and $v_{z}$ are in m/s while $\dot{\psi}$ is in rad/s). Each data point is obtained from 22.5k frame-instruction pairs.
Refer to caption: x5.png

Flight behavior. Stark differences in closed-loop behavior are observed: the MLP policy leads to very erratic closed-loop navigation and shows reluctance to stop at the goal, the Conv head exhibits aggressive piloting resorting to abrupt turns in front of goals, while ViT offers much smoother trajectories closer to those seen in training. To back these observations, we generate a total of 30 expert demonstration runs (sphere, cube and pyramid goals with all five color variations in both InD and OoD scenes), that are identical in the initial placement of the target and expert 150-command sequence.
We run the models on the expert frames with five text variations of the text instruction including commands in French and Italian (see Appendix A.6). The difference between each scalar output and its corresponding expert command for all objects, scenes, instructions and sequence frames is depicted in Figure 5. The figures seem to corroborate the qualitative observations, showing significantly smaller deviations from expert decisions with the ViT policy ($\sim$40% better than its counterpart on the crucial yaw rate command $\dot{\psi}$), and smoother flight control (3$\times$ and 8$\times$ smoother than Conv and MLP on sideways crabbing $v_{y}$). Thus, we empirically establish ViT’s superiority as a policy head in terms of generalization performance as well as flight behavior.

### 5.4 Robust ViT Decisions

Figure: Figure 6: Feature clustering and visualization through the 64-patch ViT policy network. The instruction is ”Navigate to the blue pyramid” with a frame (top left with a grid overlay separating the patches) from the OoD simulation scene. The top row depicts the cluster memberships by color, with the goal belonging to blue. The bottom row visualises the features’ t-SNE embeddings in 3D.
Refer to caption: x6.png

Similarity-based clustering and visualization.
The ViT policy offers a structured representation of features across the network as per patch feature spatial attribution is respected up until the last linear decision layer. We leverage this structure and apply similarity-based clustering of features to elucidate the decision process.
Indeed, at a given layer, we first L2-normalize all patch-wise features before applying $k$-means clustering ($k$ selected via the ”elbow” technique). We note that $k$-means minimizes intra-cluster variances, hence acts on squared Euclidean distances.
For visualization, we apply the t-distributed stochastic neighbor embedding method (t-SNE) in 3D to the normalized features, using the squared Euclidean distances as our metric (cf. Algorithm 1 in Appendix A.7). The choice of metric is motivated by the proportionality of the square Euclidean distance to the cosine distance for L2-normalized vectors.
Thus, we ensure consistency in both clustering in the original feature space based on cosine distance and the preservation of local similarity structure for visualization. Using Figure 6 for illustration, the pyramid cluster accurately espouses the approximate region of the goal for all layers. However, the t-SNE projections seem to show that goal (blue) and background (other) features are not clearly separable from the start (BLIP-2 extraction level). Visually, we conjecture that, as the features are transformed by the attention layers, the non-essential background features become both increasingly indistinguishable from each other and dissimilar to the goal patches, with growing margin for a clear decision boundary to leverage only task related information.

Figure: Figure 7: DBI and cluster to goal patch size ratio geometric averages across the 64-patch ViT network layers. Each data point is averaged from 30 runs of 150 frames ($N=4.5\text{k}$).
Refer to caption: x7.png

Cluster separability scoring. We tailor the global clustering Davies-Bouldin Index (DBI) (Davies & Bouldin, ), to associate it only with the cluster in which the frame patches intersecting the goal object lie, or goal cluster for short (if applicable, the cluster is picked by majority number of members). Whereas the original index is the average similarity measure of each cluster with its most similar cluster, we take only the highest pairwise similarity score between the goal cluster and the others.
Here, similarity is defined as the ratio of intra-cluster distances to inter-cluster distances (details in Appendix A.7).
Thus, we obtain a metric that favours configurations in which the cluster of interest is less dispersed and farther apart from others, with lower values indicating higher separability of the cluster. Figure 7 depicts the geometric means of the DBI and the ratio of goal cluster to target size across network layers on frames from 30 runs with various goal objects and scenes. It clearly supports the claim that through the ViT layers, the goal cluster contains mostly target patches and is increasingly separated from the rest of the features for subsequent linear mapping to commands. This robust decision mechanism appears to be invariant for various scenes, goal objects, and instruction formulations.

### 5.5 Real-World Deployment

Flex (2M Dataset, 256-patches, ViT policy) transfers seamlessly to the real world and gracefully handles a variety of new scenarios. Indeed, the system exhibits highly robust performance of the task on the outdoor campus lawn, with new unseen objects as goals and various backgrounds and lighting conditions, with no notable failures. Frames from an example run can be seen in Fig 8 (successful runs for six other different goals are depicted in Fig 9 of Appendix A.6).

Figure: Figure 8: Flex sample real test run: Frames from a test run with text instruction ”Fly to the man with a wig”. Time increases from left to right. In the last frame, the cardboard cutout is blown off the tripod support by the drone propellers. The wig remains.
Refer to caption: x8.png

## 6 Related Work

Learning via simulations. Neural network policies mapping perception to control have shown significant potential in autonomous navigation challenges (Pomerleau, ; Bojarski et al., ; Wang et al., ; Chahine et al., ; Yin et al., ; Kaufmann et al., ). However, developing robust large-scale models is challenging as they require extensive training data that is time-consuming, costly, and poses potential safety risks (Kendall et al., ). Thus, training robot policies in simulation became a practical alternative. (Amini et al., ; Tedrake et al., ; Panerati et al., ; Shah et al., ). Still, simulated environments do not fully capture real-world intricacies, leading to transfer gaps that degrade performance and introduce safety risks. Training policies through intermediate visual abstraction (Müller et al., ; Toromanoff et al., ; Behl et al., ), aligns with our work but does not utilize multimodal foundation models.

VLMs and foundation models in Robotics. Integrating foundation models into robotics has enhanced proficiency in dynamic, open-set environments. These models excel in applications like 3D mapping (Huang et al., ; Ding et al., ), detection and following systems (Maalouf et al., ; Liu et al., ; Ghiasi et al., ; Li et al., ), control and planning (Tellex et al., ; Bisk et al., ; Ahn et al., ; Brohan et al., ; Li et al., ), and 3D scene segmentation and understanding (Peng et al., ; Jatavallabhula et al., ). They also show versatility across multiple data modalities (Ramesh et al., ; Crowson et al., ; Patashnik et al., ; Ramesh et al., ; Maalouf et al., ), heralding a new era of robots capable of sophisticated reasoning and interaction. In autonomous vehicles, explainable and language-based representations provide introspection and counterfactual reasoning about events (Kim et al., ; Omeiza et al., ; Kuo et al., ; Tan et al., ; Zhong et al., ). However, none of these works have enabled autonomous vehicles to execute an end-to-end task given via a single text command.

Contrasting recent approaches with our goal.
Recent advances in vision-based navigation, like RT-1 (Brohan et al., ) and RT-2 (Brohan et al., ), represent significant progress but differ fundamentally from our objectives. RT-1 was trained on over 130K real-world demonstrations,
while RT-2 incorporates extensive internet-scale pre-training with models up to $55$ billion parameters. Similarly, Vint (Shah et al., ) was trained from scratch on hundreds of hours of navigation datasets, and VLN-BERT (Hong et al., ) adapts BERT by training on 200K interactions via the PREVALENT dataset, totaling $>6$ million image-text-action triplets. NavGPT (Zhou et al., ) leverages GPT models for zero-shot action prediction, and TG-GAT (Su et al., ) was designed for aerial navigation based on dialog history, trained in $6,269$ dialog-trajectory pairs. All these approaches are in stark contrast with our minimalist perspective.

Patch features. Several methods have been proposed for extracting spatial feature descriptors using foundation models, but they face limitations: (i) some are not multimodal (Amir et al., ); (ii) others, fine-tuned for 2D-pixel alignment, causing the loss of many concepts (Ding et al., ); (iii) some rely on segmentation models like SAM (Kirillov et al., ), which can be inefficient and miss important regions (Jatavallabhula et al., ; Maalouf et al., ); and (iv) others don’t fuse text queries with patch descriptors for semantic relation (Wang et al., ).

## 7 Conclusion

This work establishes the essential dataset and model requirements for robust generalization in text-instructed end-to-end visual navigation agents using pre-trained VLM encoders as multi-modal feature extractors. Our findings include the failure of training on a single data context (leads to over-fitting), and the adequacy of two examples to train models that handle a wide spectrum of similar use cases. We also advocate for simple text-space augmentations, which can improve performance in more nuanced test settings. We shed light on the shortcomings of low-resolution patch-wise feature extraction, with the fly-to-target task necessitating at least 8$\times$8 patches. Finally, we ascertain the superiority of the ViT architecture as a policy head, in terms of task success and flight behavior, while uncovering aspects of its robust context invariant decision process via similarity-based clustering.

The synthesis of these findings is Flex, a new minimalist training framework capable of producing user-interactive highly generalizing visual navigation agents. Our solution elegantly handles a suite of in-simulation challenges and proves readily deployable in the real-world, robustly achieving direct sim-to-real open dictionary out-of-distribution generalization.

## Appendix A Appendix

### A.1 Example for extracting m × m 𝑚 𝑚 m\times m italic_m × italic_m resolution descriptors

In this example, assume $w^{\prime}=4$ (i.e., we have $16$ patches in total), and the desired resolution is $2\times 2$ ($m=2$). The original grid of patches is denoted by:

$$ $\begin{bmatrix}p_{1,1}&p_{1,2}&p_{1,3}&p_{1,4}\\ p_{2,1}&p_{2,2}&p_{2,3}&p_{2,4}\\ p_{3,1}&p_{3,2}&p_{3,3}&p_{3,4}\\ p_{4,1}&p_{4,2}&p_{4,3}&p_{4,4}\end{bmatrix}.$ $$

The Coarser grid (of sub-grids) is given by:

$$ $\begin{bmatrix}\begin{bmatrix}p_{1,1}&p_{1,2}\\ p_{2,1}&p_{2,2}\end{bmatrix}&\begin{bmatrix}p_{1,3}&p_{1,4}\\ p_{2,3}&p_{2,4}\end{bmatrix}\\ \\ \begin{bmatrix}p_{3,1}&p_{3,2}\\ p_{4,1}&p_{4,2}\end{bmatrix}&\begin{bmatrix}p_{3,3}&p_{3,4}\\ p_{4,3}&p_{4,4}\end{bmatrix}\end{bmatrix}.$ $$

Finally, to extract a descriptor for each of these $4$ subgrids, we use $4$ calls to our methods with $4$ different masks, each mask corresponding to a subgrid. The masks are given by the row stacking of these matrices:

$$ $\begin{bmatrix}1&1&0&0\\ 1&1&0&0\\ 0&0&0&0\\ 0&0&0&0\end{bmatrix},\quad\begin{bmatrix}0&0&1&1\\ 0&0&1&1\\ 0&0&0&0\\ 0&0&0&0\end{bmatrix},\quad\begin{bmatrix}0&0&0&0\\ 0&0&0&0\\ 1&1&0&0\\ 1&1&0&0\end{bmatrix},\quad\begin{bmatrix}0&0&0&0\\ 0&0&0&0\\ 0&0&1&1\\ 0&0&1&1\end{bmatrix}.$ $$

### A.2 Discussion

Limitations and Future Work
The framework presented in this manuscript is limited to instantaneous decisions. Indeed, the policy can only act with information from the current image and has no access to a history of representations or actions. We are keen to incorporate our potent multi-modal feature encoding scheme into sequential decision-making processes. This would enable Flex to go beyond generalization between environments and objects, and handle instructions over actions, sequences of steps, and behavior modes. An additional limitation of this work is its computational overhead, which renders it impractical for real-time execution on small mobile robotic platforms. This pertains to the wider effort in edge AI research to enable the deployment of foundation models directly on edge devices. The robotics community will reap great benefits from these advances that will enable the widespread adoption of methods such as Flex.

### A.3 Training

Dataset description. A unique simulated dataset is used for training by all models discussed throughout this paper. It consists of 300 goal approach flight sequences (22,844 frames in total, 76.15 frames per run on average), with a 90% training and 10% validation split. The same two objects, a red and a blue sphere, are used in every sequence. All frames of a give sequence are labelled with the same text, a natural language instruction sentence providing information on whether to fly to the red or blue goal. We balance the number of runs headed for each of the two possible options.

Trajectory design. Both spheres are initially positioned in the drone’s field of view such that all trajectories generated carry recovery information (with the farthermost target at the border of the image). They are positioned at the same altitude and relative position, equidistant from the drone. We randomize the initial distance to the targets, thus ensuring the size of the objects in the image is varying. This ensures we expose the network to trajectories that recenter and approach the goal target from a wide spectrum of angles and distances. The control signals are obtained with the ground truth knowledge available to us from the simulator, where PID controllers generate the vertical velocity commands $v^{z}$ to reduce the altitude gap, the forward velocity commands $v^{x}$ to reduce the distance gap, and the yaw rate $\dot{\psi}$ to pilot the drone towards the instructed goal (centered in the middle of the frame).

Label design. Each approach sequence is associated with a unique text instruction. We introduce text domain augmentation by generating 25 synonyms to the verb ”fly to” and noun ”target”. The verb phrases include: migrate towards, glide to, whiz to, steer towards, manoeuvre to, zoom to, elevate towards, approach, propel to, make way to, orient towards, venture towards, soar to, advance to, progress towards, journey to, hover to, proceed to, drift towards, rush to, shift to, head towards, ascend towards, scene towards, travel to. The object terms include: signpost, point, terminus, stage, station, location, interest, goal, setting, checkpoint, cue, objective, coordinate, emblem, locus, target, marker, beacon, spot, destination, signal, symbol, sight, position, aim.
We uniformly sample from these terms to form instructions in the format:
VERB PHRASE the [COLOR] OBJECT

Training run sequence frames are depicted in Figure 10.

Training details. The loss used is the Mean Squared Error (MSE) between the network predicted commands and the values with which a dataset frame is labeled, with equal weights between all scalar outputs. We train the models for 20 epochs, using the Adam optimizer with a learning rate of $1\cdot 10^{-4}$. Frames are uniformly sampled from the dataset to ensure shuffling. We take the checkpoint with the best validation loss for each model. All training was performed on a single NVIDIA GeForce RTX 3080 Ti GPU, with 12 GB memory and 10240 CUDA cores, with a single full training run taking around 45 hours. The major compute bottleneck originates in repeated calls to the BLIP2 based multi-modal patch encoding, which can be alleviated by encoding and storing the entire dataset features once instead of re-encoding at every epoch. Our setup is capable of handling 2.8 frames per second on average during training.

### A.4 Real world setup details

Hardware. Our platform is a DJI M300 RTK quadcopter. The M300 interfaces with the DJI Manifold 2 companion computer, enabling programmatic control of the drone. The DJI Onboard SDK (Software Development Kit)
and its associated ROS wrapper
provide an interface for feeding the drone’s low-level flight controller with desired high-level translation velocities and yaw rate commands.
The flight controller onboard the DJI M300 is a black box system provided by the manufacturer which controls the four-rotor speeds to track the velocities specified by the companion TX2 computer. It is worth mentioning that the dynamics of the platform we use do not match those of the nano-quadrotors simulated.
Input images gathered by the gimbal-stabilized camera, which follows the drone’s yaw to always point forward, are available to the companion computer via the SDK.
The onboard computer runs an NVIDIA Jetson TX2, which has GPU capability. However, Flex  inference on a single image takes over 10 seconds. Thus, establish a connection over Wifi between the onboard TX2 computer and a standalone
Lenovo 16” ThinkPad P16 Gen 2 with Intel Core i9-13980HX (13th Gen) CPU and NVIDIA RTX 5000 GPU with 16 GB GDDR6 VRAM. The TX2 sends the latest image to the machine which runs inference and replies with the control command to execute.
We reach a runtime frequency of just over 1 Hz with our setup.

Real world scene. We conduct our flight tests on an outdoor lawn in an urban university campus. In addition to having to bridge the sim-to-real transfer gap, agents are also exposed to a completely new visual scene, with various buildings, reflective structures, and trees. Lighting conditions from various starting positions now expose the agents to sunlight from various angles, making for a very challenging sim-to-real generalization scenario.

Goal objects. We use cardboard cutouts that we position on tripods at a safe flight altitude as targets. The list of props contains a red disk, blue disk, white disk, yellow square, yellow star, and human figure printed cutout on top of which a wig is placed.

### A.5 Model Details and Parameters

Policy models We train four different policy head architectures:
A Vision Transformer (ViT) architecture consists of three Transformer blocks with a patch size of 1x1, a dimensionality of 128, and four attention heads. The multilayer perceptrons (MLPs) in this model have a dimensionality of 256. A fully-connected layer maps to a 4-dimensional output. The convolutional network (Conv) architecture includes three 1x1 convolutional layers. The first layer has an input dimension of 64, and all layers have a hidden dimension of 128. Each layer is followed by ReLU activation and dropout, and the output is flattened to (128 * 16 * 16) and a fully-connected layer maps to a 4-dimensional output. Finally, the Multilayer Perceptron (MLP) architecture begins by average pooling the [B, 64, 16, 16] patches into [B, 64, 1, 20]. It then applies a fully-connected layer with dimension 1280, using ReLU activation and a dropout rate of 0.3. A fully-connected layer maps to a 4-dimensional output.

**Table 1: Vision Transformer Policy Parameters**
| Parameter | Value |
| --- | --- |
| Image Size | 32x1 |
| Patch Size | 1x1 |
| Number of Classes | 4 |
| Dimension | 128 |
| Depth | 3 |
| Heads | 4 |
| MLP Dimension | 256 |
| Channels | 64 |
| Dimension per Head | 32 |

**Table 2: Convolutional Network (Conv) Policy Parameters**
| Parameter | Value |
| --- | --- |
| Number of Layers | 3 |
| Hidden Dimension | 128 |
| Activation Function | ReLU |
| Dropout | 0.3 |

**Table 3: Multilayer Perceptron (MLP) Policy Parameters**
| Parameter | Value |
| --- | --- |
| Pooling | Average Pooling |
| Pooled Dimension | [B, 64, 1, 20] |
| FC Layer 1 Dimension | 1280 |
| Activation Function | ReLU |
| Dropout Rate | 0.3 |
| FC Layer 2 (Output) Dimension | 4 |

**Table 4: Model Parameters Breakdown**
|  | ViT | Conv | MLP |
| --- | --- | --- | --- |
| Total Model | 1,173,055k | 1,172,822k | 1,172,654k |
| VLM Encoder | 1,172,600k | 1,172,600k | 1,172,600k |
| Last Layer Projection | 49k | 49k | 49k |
| Trainable Params | 454k | 222k | 54k |
| Policy network | 405k | 172k | 5k |

### A.6 Robustness to syntax formulations

Testing alternative commands . We generate a set of five text command variations for each object amongst the sphere, cube and pyramid and colors blue, red, green, purple and yellow, in order to test the robustness of models to syntax and language formulations. The skeleton of each command (left) and an example for the green sphere (right) are given below:

- •
Fly to the [OBJECT]
- •
Navigate to the [OBJECT]
- •
Reach the [OBJECT]
- •
Vole vers [OBJECT IN FRENCH]
- •
Vola verso [OBJECT IN ITALIAN]
- •
Fly to the green ball
- •
Navigate to the green ball
- •
Reach the green ball
- •
Vole vers la balle verte
- •
Vola verso la palla verde

Figure: Figure 9: Flex in the wild: screenshots of test runs with the ViT policy network (one per row, time increases from left to right) performed on a lawn on the urban campus with various goal objects, backgrounds and lighting conditions. The text instruction used in each case is by the first image.
Refer to caption: x9.png

Figure: Figure 10: 2M training examples
Refer to caption: x10.png

Figure: Figure 11: 256-patch ViT closed-loop inference in simulation
Refer to caption: x11.png

### A.7 Feature clustering and analysis

We provide the algorithms used to perform feature clustering and visualization (Algorithm 1) and compute the cluster score (Algorithm 2).

Figure: Algorithm 1 Feature Clustering Analysis Algorithm

Figure: Algorithm 2 Compute-DBI

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 5
presentation: 3
questions: See weakness part.
soundness: 2
strengths: 1. This paper is well written and easy to read.
2. The experiment part is good with analysis in feature robustness quality. Real-world experiments are given.
summary: This work studied robust multimodal representations for drones. It combines spatial and lexical features via patch-wise descriptors from VLMs. The training pipeline for closed-loop visual navigation agents that generalize across unseen environments, using real-time natural language instructions to achieve adaptability well beyond the training scope. Extensive experiments on drone fly-to-target tasks, showcasing the ability in generalization and real-world deployment
weaknesses: 1. The motivation of using mask-based patch features is unclear to me. I think it can be simply replaced by ViT style patch feature encoding and attention-based interaction. And for some downstream policy nets like MLP, the spatial feature is eliminated by average pooling. Why the spatial dimension is necessary? 
2. Following above, I do not find any ablation studies on different feature designs.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. I am mostly interested on how the evaluation data is different from the training data. I am happy to fix my score, if I could understand the performance is not from scene memorization.
soundness: 3
strengths: 1. Integrating visual navigation with the vision-language foundation model is an interesting direction.
2. The performance of this paper is reasonable with targeting and query on a limited set of objects.
3. The paper writing is in general good except the introduction.
4. The paper evaluates their methods in both simulation and real scenarios.
summary: This paper introduces FLEX, a method for making drones understand and follow natural language commands. Instead of building everything from scratch, it cleverly uses an existing vision-language model (BLIP-2) to process both camera images and text instructions. The system was trained on simple simulated scenarios with just two colored balls, yet surprisingly, it worked well in real-world tests with various objects. The key innovation is how it breaks down camera images into patches and processes them alongside text commands, allowing the drone to understand both what it sees and what it's looking for.
weaknesses: 1. The paper writing is strange where the introduction section is quite similar to related work.
2. The training data seems to be rich with 1, 1M, 2, 2M, however those four datasets contain only a limited amount of target, and query, which I think is not enough for an open world navigation paper.
3. In addition the paper didn't handle how to solve image sequences for navigation work, which means that they predict action frame by frame.
4. One interesting thing is that in order to correctly navigate in the scene, actually we need to know the depth information, however, the amount of data the paper trained is not enough for that kinds of generalization.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: See weakness
soundness: 2
strengths: 1. The motivation to investigate frozen VLM encoders for semantically rich and spatially aware embeddings without extensive retraining is clear and well-grounded, offering a promising approach to simplify training in complex robotic tasks.
2. The experimental setup is thorough, exploring various dataset configurations and policy architectures, which provides valuable insights into design choices for multi-modal robotic policies.
summary: This paper conducts an empirical study on using features extracted by frozen Vision-Language Pretrained Models (VLMs) for downstream policy learning in object-guided quadrotor visual navigation. The policy is trained with synthetic data in simulation and demonstrates a real-world deployment example, providing an initial test of generalizability.
weaknesses: 1. Limited Task Scope: While the use of VLM features for visual navigation is compelling, the experiments are restricted to quadrotor object navigation. Broader experiments across different robotic tasks or navigation scenarios could help demonstrate Flex’s general applicability, aligning with the paper’s claims of “closed-loop visual navigation agents that generalize across unseen environments.”
2. Feature Extractor Generalizability: Although the study aims to investigate “suitable feature extractors for text and vision-based robotics learning,” the experiments focus solely on BLIP-2 and modifications to its Q-former. Including other VLMs, such as CLIP or ImageBind, would strengthen the claim of generalizability and demonstrate the adaptability of the proposed method across diverse VLM architectures.
3. Task Complexity: In the current setup, the target is observable from the beginning, and language instructions are relatively simple. Visual navigation in complex settings involves learning semantic associations between language and visual cues and exploring the environment effectively to locate and reach the target. Here, the task primarily involves target identification and navigation, with limited indication of the benefits of end-to-end learning over modular approaches like GOAT. Clarifying the advantages of end-to-end learning in this setup would improve the paper’s impact.
4. Language Instruction Scope: The difficulty and complexity of language instructions in the dataset are not discussed. Unlike works in Zero-Shot Object Navigation (ZSON) or Zero-Shot Vision-and-Language Navigation, which leverage the language comprehension capabilities of VLMs, the findings in this paper are limited to basic instructions. This limitation makes it challenging to support claims of Flex being “user-interactive,” as the current level of interaction falls short of handling more complex language instructions effectively.

Meta-review: This paper investigates the use of frozen pre-trained vision-language models (VLMs) with the philosophy of making it lightweight and minimal in terms of both training and data. The approach uses a patch-based representation along with a proposed masking approach to perform feature extraction. Results are demonstrated on a drone scenario tested in simulation and real world. Reviewers appreciated that the topic of VLM integration towards vision-based navigation is interesting and that the paper is easy to read. However, overall reviewers had significant concerns about the paper, including the motivation of the method (e.g. use of masking, 2xnd), the limited amount and complexity of evaluation tasks (BS4x, mJid) and situation with respect to other methods (e.g. GOAT mentioned by BS4x). and lack of comprehensiveness in terms of other feature extractors (BS4x). After reviewing the rebuttal, many of these issues still remain. The use of VLMs, both in terms of frozen models and fine-tuned, is a topic that is both interesting but also being explored by a large number of works (including some cited by the authors, methods like GOAT, etc.). Such methods are often compared across a number of vision-based navigation benchmarks with varying complexity, open-vocabulary variants, etc. to demonstrate the universality of the proposed architectures proposed. The current paper proposes another point in this space of possible designs (which is quite large), but only shows results on very limited settings. Further, aspects such as generalization (e.g. what variations, distribution shifts, new objects/scenes/tasks will it generalize to?) is not explored at all. As such, I agree with all of the reviewers that this paper is below the bar for acceptance. I recommend that the authors address the major concerns of the reviewers and significantly expand both the justification of the design and the scope of evidence for its effectiveness.

Decision: Reject