Distilling a Swarm into 158 Million Parameters: Inside MiniUAV-VLA

Coordinating multiple unmanned aerial vehicles (UAVs) for cooperative missions requires agents that perceive their environment, reason about objectives, and generate joint actions. Vision–language–action (VLA) models unify these capabilities but lack efficiency for real-world multi-UAV deployment. This episode explores MiniUAV-VLA, a compact 158M-parameter model that uses MARL expert distillation to enable cooperative multi-UAV search and elimination missions.

What is Embodied AI 101?

Stay in the loop on research in AI and physical intelligence.

Distilling a Swarm into 158 Million Parameters: Inside MiniUAV-VLA.

MiniUAV-VLA: A Compact Vision–Language–Action Model for Cooperative Multi-UAV Search and Elimination via MARL Expert Distillation • Hongwei Han, Guanghong Gong, and Ni Li • Beihang University, School of Automation Science and Electrical Engineering, and State Key Laboratory of Virtual Reality Technology and Systems • Drones 10(8), 572 • 2026.

The Short Version.

MiniUAV-VLA is easiest to understand by first saying what it is not. It is not a fleet of four language models running independently onboard four aircraft. It is not a natural-language mission planner connected to a conventional flight stack. And it is not a vision model operating on egocentric camera feeds.

It is a centralized multimodal team policy. At every simulated timestep, one model receives a rendered bird’s-eye tactical image plus a compact textual serialization of the fleet state. It then emits four discrete movement commands—one for each UAV—in a single forward pass. The policy is trained not from human teleoperation, but by behavior cloning a successful QMIX multi-agent reinforcement learning policy.

That distinction matters because it locates the paper’s real contribution. MiniUAV-VLA is not yet a general-purpose language-controlled swarm foundation model. It is a proof of concept for a potentially useful pipeline:.

Train a strong cooperative MARL policy in simulation.

Roll it out to produce coordinated demonstrations.

convert those rollouts into image, structured-text, and action tuples.

Fine-tune a compact vision-language backbone to reproduce the teacher’s fleet-level decisions.

With 5,000 expert transitions, the resulting 158-million-parameter model reaches a reported mission success rate of 74.4%, compared with 100% for its QMIX teacher. Its most striking result, however, is architectural rather than task-specific: moving the action readout from the end of the training response to the end of the user prompt raises mean success from 40.6% to 76.2% across five independently trained model pairs.

The paper is therefore interesting at two levels. At the application level, it offers a small centralized policy for coordinated search. At the methodology level, it exposes a serious label-leakage failure mode that can arise whenever a generative vision-language model is fitted with a separate action head.

What Problem Is Actually Being Solved?.

The benchmark is a 30-by-30 two-dimensional grid containing four drones, six mobile targets, and randomly generated walls and trees. Each drone can move up, down, left, or right, or remain stationary. Episodes last at most 120 steps. A target is first marked as found when it enters a drone’s view radius, and then removed when it enters the attack radius. The standard configuration uses a view radius of six cells and an attack radius of four.

The targets are not static landmarks. Outside the fleet’s view range, they usually make random moves, with some probability of staying still. Once a drone comes near, they may move away from the closest drone. The reward encourages new discoveries, target removal, and full mission completion while penalizing collisions, redundant overlap among drone view regions, and every additional timestep. The overlap term is especially relevant: it gives the QMIX teacher a direct incentive to spread the fleet over the search area rather than sending all four agents toward the same region.

Despite the UAV terminology, this is not a flight-control problem. There is no altitude, attitude, thrust, velocity, acceleration, battery state, aerodynamic disturbance, or continuous trajectory. A control decision advances a marker from one grid cell to another. The “elimination” operation is likewise an abstract environment transition once a target enters a radius; no physical engagement system is modeled. The paper explicitly frames the environment as centralized, high-level decision-making rather than validation of a three-dimensional vehicle controller.

That makes the task useful as a controlled coordination benchmark, but it also defines the limits of the conclusions. Success here means learning fleet allocation, obstacle-aware movement, target pursuit, and completion under a time limit. It does not establish that the model can process real aerial imagery, maintain state estimates under sensor noise, tolerate packet loss, avoid other aircraft, or close a control loop around an actual quadrotor.

There is another important structural detail: although the underlying problem is introduced as a decentralized partially observable process, MiniUAV-VLA itself is centralized. The entire team state is assembled into a shared image and prompt, and one network outputs the action vector for all four drones. The paper does not evaluate decentralized onboard inference. In deployment terms, this is closer to a learned fleet coordinator than to four autonomous agents collaborating through local communication.

First Train a Teacher: Why QMIX Fits the Job.

The teacher is QMIX, one of the canonical value-decomposition methods for cooperative multi-agent reinforcement learning. In standard QMIX, each agent has a local utility network, while a mixing network combines those utilities into a team-level value during centralized training. The mixer is constrained to be monotonic in the individual utilities. This allows each agent to select its action locally while remaining consistent with the centralized team optimum represented by the mixer.

In MiniUAV-VLA, each teacher agent uses a recurrent network and receives features including its own position, teammate-relative information, nearby obstacles, discovered active targets, mission progress, and elapsed time. Crucially, the paper says that undiscovered target positions are not included in the teacher’s numeric observation. The mixer receives global state during training, and the finished QMIX policy achieves 100% mission success, requiring an average of 48.4 steps to clear all six targets.

QMIX is a sensible teacher because it has already solved the difficult credit-assignment problem. The demonstrations do not simply contain short paths toward whichever target is closest. They encode the consequences of a shared reward: separating the fleet, limiting redundant coverage, switching from exploration to pursuit, and coordinating around obstacles.

This is the central appeal of MARL-to-VLA distillation. Human operators do not need to demonstrate thousands of coordinated four-agent trajectories. Once the MARL expert exists, synthetic demonstrations are relatively cheap. The VLA student can then inherit a strategy found through millions of environment interactions without itself undergoing online reinforcement learning.

But notice what is lost in the transfer. QMIX was designed around centralized training with decentralized execution. MiniUAV-VLA distills that teacher into a centralized student. The student may provide a more convenient multimodal interface, but it does not preserve the teacher’s decentralized execution property. A communication outage between the fleet and central policy would therefore be a qualitatively different failure mode.

Turning MARL Rollouts into a VLA Dataset.

The authors roll out the trained teacher in closed loop and retain transitions from successful episodes. Each retained sample contains three main objects: a rendered tactical image, a structured textual prompt, and the teacher’s four actions. The principal model uses 5,000 such transitions, with 1,000- and 10,000-transition versions used in the data-scaling study.

The image is a 224-by-224 top-down rendering. It shows the grid, obstacles, color-coded drones, target markers, and view and attack regions. This is important terminology-wise: “vision” here means vision over a clean symbolic rendering, not perception from a physical camera. The visual encoder is being asked to recover spatial relationships from an image, but those relationships have already been segmented and rendered without occlusion, blur, lighting variation, or detector uncertainty.

The text channel is even more structured. It serializes the mission mode, sensing and attack radii, map size, timestep, action-ID convention, number and coordinates of drones, discovery and elimination counts, and a five-bit legal-action mask for every drone. The prompt is therefore best understood as a compact symbolic state vector expressed through tokens. The paper explicitly declines to claim generalization to natural-language paraphrases or unrestricted operator commands.

The target response contains the four expert actions and a fixed “thinking” sentence instructing the model to follow the QMIX policy while avoiding blocked cells. An audit reported in the paper found only one unique thinking string in the data. QMIX supplied actions, not linguistic explanations, and the sentence never contained the selected directions. It should therefore not be interpreted as a chain-of-thought trace or as evidence that the teacher’s decision process was translated into language.

This design creates two supervision signals. A language-modeling loss trains the backbone to reproduce the response, while a separate action loss trains a discrete control head. At inference time, the response is neither generated nor consumed. The model takes the current image and prompt, computes the action logits, and immediately advances the simulator.

Retaining only successful expert data produces a clean action manifold, but it also narrows the state distribution. The student observes what competent coordination looks like, not how an expert recovers after several poor decisions have pushed an episode toward timeout. That survivorship bias is a plausible contributor to the gap between the teacher’s 48.4-step completion time and the student’s 67-step average. The paper acknowledges this as an important target for future work.

The Model: A Small VLM with a Fleet Action Head.

MiniUAV-VLA combines a frozen SigLIP2 vision encoder, a MiniMind-3V causal language model, and a small multi-agent action head.

SigLIP2-base-patch16-224 contributes about 93 million frozen parameters. A 224-pixel image is divided into 16-pixel patches, producing 196 visual tokens. A two-layer projection network maps those patch features into the language model’s 768-dimensional hidden space. The choice of SigLIP2 is motivated by its dense local visual features, which are useful when a frozen encoder must preserve the positions of small map elements.

The MiniMind-3V component is an eight-layer causal transformer with eight attention heads, four key-value heads, rotary positional encoding, a 6,400-token vocabulary, and a 512-token context limit. Approximately 64 million language-model parameters and one million projection parameters are trainable. With the frozen vision tower included, the complete inference model is roughly 158 million parameters.

The action head is almost trivial: one linear projection converts the pooled 768-dimensional representation into 20 logits. Those logits are reshaped into four blocks of five, one categorical distribution per drone. The head itself adds only 15,360 weights.

The phrase “joint action prediction” deserves some precision. All four decisions are conditioned on the same global representation and are produced in the same pass, so the policy can certainly learn coordinated deterministic behavior. But the output head does not explicitly represent a distribution over all 625 possible four-drone action combinations. Nor does it generate drone actions autoregressively. Conditional on the shared hidden state, it produces four factorized categorical predictions. Coordination must therefore be encoded upstream in the common representation and in the correlations present in the teacher labels.

That is a reasonable compromise for four agents. It scales the output dimension linearly rather than exponentially. The cost is that the architecture assumes a fixed ordering and a fixed fleet size. Drone zero always owns the first five logits, drone one the next five, and so on. There is no permutation invariance, dynamic agent set, or mechanism for adding a fifth vehicle without modifying and retraining the output layer.

The student also has no explicit memory across environment steps. Each decision is recomputed from the current image and current prompt. The transformer is causal within one prompt-response sequence, but its context is not carried from one control cycle to the next. In practice, the centralized rendering, progress counters, and timestep make the supplied observation close enough to a tactical state snapshot for the model to act reactively.

Prompt-End Pooling: The Most Generalizable Result.

The paper’s strongest lesson concerns where the action head reads the transformer.

During supervised training, the full sequence contains visual tokens, user-prompt tokens, and the ground-truth assistant response. A seemingly natural implementation is to take the hidden state at the final sequence token and feed it to the action head. But at that position, a causal transformer has already attended to the textual action labels in the response.

This creates a shortcut. During training, the action head can recover the answer from a representation that has effectively read the answer. During deployment, no assistant response exists, so the model is asked to act from a prompt-only hidden state drawn from a different feature distribution. This is more specific than ordinary behavior-cloning covariate shift: it is direct right-context leakage into the control representation.

MiniUAV-VLA fixes the problem by extracting the hidden state at the final user-prompt token, immediately before the assistant response begins. Because that position is causally upstream of every response token, the action head cannot inspect either the fixed thinking sentence or the textual action array. More importantly, the information available at that position is the same during training and inference.

The effect is enormous. Across five matched training runs, last-token pooling averages 40.6% mission success, while prompt-end pooling averages 76.2%. Prompt-end pooling wins every pair by between 32 and 40.4 percentage points. It also raises target discovery, reduces episode length from roughly 105 steps to 66, and lowers the raw illegal-action rate.

Calling this a new reasoning mechanism would overstate the result. The last-token baseline is fundamentally misaligned with deployment, so part of the 35.6-point gain is simply the removal of label leakage. Nevertheless, this is exactly the sort of implementation error that can survive ordinary validation: token-level losses may look excellent while the closed-loop policy fails.

The broader design rule is valuable. Whenever a generative backbone is augmented with a non-generative control head, the readout token must have the same causal context in training and deployment. A dedicated control token at the end of the prompt, prompt-end pooling, or a carefully designed attention mask can all satisfy that requirement. Reading from a state that has consumed ground-truth output tokens cannot.

The auxiliary language loss can still shape the prompt representation. Future-token losses backpropagate through the shared transformer parameters and encourage the network to organize prompt information in ways useful for predicting the response. But the response tokens themselves cannot flow backward through causal attention into the already-computed prompt-end state. That distinction lets the model benefit from auxiliary sequence supervision without handing the action head its labels.

What the Experiments Show.

The headline comparison is straightforward:.

| Policy | Mission success | Notable detail | |---|---:|---| | Random legal actions | 9.4 ± 2.1% | Independent random motion | | Observation-limited greedy heuristic | 16.2 ± 3.2% | Pursues nearest visible target | | Frozen ResNet-18 vision policy | 14.4 ± 3.4% | Only its small action MLP is trained | | Trainable ConvNeXt-Small vision policy | 34.4 ± 5.6% | Roughly 51 million trainable parameters | | MiniUAV-VLA | 74.4 ± 4.6% | Image plus structured text | | QMIX teacher | 100% | Numeric observations and recurrent state |.

MiniUAV-VLA finds an average of 94.4% of targets and finishes successful or timed-out episodes in 67 steps on average. Its raw argmax is illegal on 15.5% of individual drone decisions, although these actions are corrected before execution.

The reported standard deviations in the main table are across five environment and rollout seed blocks, not across independently trained networks. Most learned baselines correspond to one checkpoint. The authors are appropriately cautious about treating the gaps as training-level significance tests. The prompt-pooling experiment is stronger in this respect because it actually retrains each variant five times.

The modality ablations support the claim that image and structured text are complementary. A fully trainable ConvNeXt improves substantially over the frozen ResNet, but remains about 40 points behind the complete model. The text-only policy’s target-found ratio reaches just 63.4%, despite receiving drone coordinates, mission progress, and legal-action masks. The visual map is consequently doing substantial spatial work.

What these ablations do not establish is that a language model is uniquely necessary. There is no comparably sized multimodal transformer that consumes the same rendered map and structured numeric features without language pretraining. The experiment shows that the chosen visual and textual channels are both useful within MiniUAV-VLA. It does not yet isolate the value of linguistic pretraining from the value of simply providing two well-engineered state representations.

The data-scaling experiment is encouraging but narrow. One thousand transitions produce 42% success. Five thousand produce 74.4%, a gain of 32.4 points. Doubling again to 10,000 reaches 79.8%. The curve suggests a major low-data threshold followed by diminishing returns under the fixed ten-epoch training schedule. The raw illegal-action rate similarly falls from 26.7% at 1,000 samples to about 15.5% at 5,000, with almost no additional improvement at 10,000.

The auxiliary-response experiment is more difficult to interpret. The full system reaches 74.4%. Removing the fixed thinking sentence lowers success to 59.8%, and removing the language-modeling objective as well gives 54%. This supports auxiliary sequence supervision as a useful regularizer. It does not demonstrate semantic reasoning, because the thinking text is identical in every example. An especially informative follow-up would replace it with an equal-length neutral string or rebalance the token losses, separating semantic content from extra supervision and sequence-length effects.

The legality filter adds 1.8 points of success, raising the raw policy from 72.6% to 74.4%, and shortens episodes by 3.3 steps. The gain is modest, but the 15.5% raw violation rate means the external constraint system is not decorative: roughly one in six per-drone argmax decisions must be rerouted to the highest-scoring legal option. The deployed controller should therefore be described as a learned policy composed with deterministic action masking, not as a neural policy that has internalized all movement constraints.

Zero-shot tests vary target count, map size, obstacle density, and target behavior while retaining four UAVs and the same action interface. Smaller maps are easier, while larger or denser environments reduce performance. Across the tested map sizes, success ranges from 67% to 95.6%. Replacing the usual stochastic targets with goal-directed evasive targets reduces success from 74.4% to 67.2%, with the targets completing their hidden goals in 25.3% of cases. These are useful robustness checks, but not demonstrations of open-world transfer.

Finally, inference takes a reported 28.47 milliseconds per decision on an RTX 4090. Peak allocated GPU memory is about 684 MiB. That is compact compared with billion-parameter VLAs, but an RTX 4090 is not an onboard mini-UAV computer. The paper does not measure embedded latency, power, thermals, radio delay, or quantized performance.

What Has the Student Really Learned?.

The most defensible interpretation is that MiniUAV-VLA learns a reactive approximation to a centralized fleet strategy. Its behavior reflects useful coordination because its training labels come from a policy optimized under a team reward. The image supplies global geometry, the prompt supplies bookkeeping and constraints, and the teacher actions identify good decisions on that state manifold.

The result is more than a nearest-target heuristic. The large gap over the greedy baseline suggests that the student has recovered some combination of area allocation, pursuit, and fleet deconfliction. But the rich input representation offloads much of the problem. Exact drone coordinates, progress counters, action legality, and a clean tactical rendering are all provided directly.

The visibility semantics deserve particular scrutiny. The paper describes a shared tactical image containing target positions, while the public renderer has a full-map mode enabled by default and draws active target markers in that mode. Its prompt builder also has an optional privileged-state field for target coordinates. Those defaults do not prove that the published runs used privileged target positions—the experimental invocation may override them—but reproductions should explicitly verify both settings. If undiscovered targets are rendered, the student is solving centralized routing toward known markers rather than search under partial observability.

The language claim should likewise remain narrow. The prompt is a stable machine-readable schema, not a family of operator utterances. The model is language-compatible in the architectural sense, and that may make future task conditioning easier. In the present experiments, however, text functions primarily as tokenized structured state. No instruction paraphrases, new mission descriptions, conversational corrections, or compositional commands are evaluated.

Likewise, “multi-agent VLA” refers to the output semantics, not to a society of language-conditioned agents. There is one model, one global context, and one ordered vector of four actions. This is still useful—many fleet-management systems are centralized—but it tackles a different systems problem from decentralized embodied agents that must build consensus over intermittent links.

How It Relates to the Broader VLA Landscape.

RT-2 established the influential action-as-language-token formulation: robot actions were discretized and incorporated into the same autoregressive vocabulary as natural-language outputs, allowing web-scale vision-language knowledge and robot trajectories to be co-trained. MiniUAV-VLA instead uses a dedicated action head, and its language channel is a fixed state serialization rather than a source of broad semantic task variation.

OpenVLA scales that generalist recipe to a seven-billion-parameter open model trained on 970,000 real-world robot demonstrations. Its target is cross-task manipulation and efficient adaptation to new robot domains. MiniUAV-VLA occupies almost the opposite corner: 158 million parameters, 5,000 synthetic transitions, one discrete simulated mission, and a fixed four-agent embodiment. Its data efficiency is impressive precisely because the task and representation are so constrained.

Octo takes another route, training a generalist transformer policy on roughly 800,000 trajectories and demonstrating adaptation across nine robotic platforms, multiple sensory configurations, and new action spaces. That adaptability highlights what MiniUAV-VLA’s fixed 20-logit head currently lacks: variable embodiments and interchangeable action interfaces.

Physical Intelligence’s π0 moves in the other direction on action representation, placing a flow-matching controller on top of a pretrained VLM to generate continuous, high-frequency action trajectories for single-arm, dual-arm, and mobile manipulation. MiniUAV-VLA’s one-step discrete predictions are far simpler, but also much cheaper and easier to supervise from a conventional MARL teacher.

Compact manipulation systems such as MiniVLA and TinyVLA similarly ask how much of a large VLA’s performance can be retained in a smaller model. MiniVLA reports matching its larger OpenVLA predecessor on LIBERO-90 with about seven times fewer parameters, while TinyVLA emphasizes fast, data-efficient adaptation. MiniUAV-VLA extends the small-model conversation into centralized multi-agent control, although on a substantially more abstract benchmark.

The closest conceptual comparison is therefore not any single VLA. MiniUAV-VLA sits at the intersection of policy distillation, cooperative MARL, and compact multimodal control. Its distinctive ingredient is using a MARL expert as an automatic source of coordinated multimodal demonstrations.

Reproducibility: The Paper and Repository Need a Precise Handshake.

The public repository includes the EPyMARL-derived training stack, custom environment, QMIX data generator, VLA dataset loader, model wrapper, supervised fine-tuning script, and closed-loop evaluator. That is a strong starting point, especially for a paper published on July 27, 2026.

As of July 29, 2026, however, the repository documentation appears to reflect multiple stages of the project rather than one frozen paper release:.

The README describes a four-cell view radius, while the article’s main configuration uses six.

The README’s example requests 5,000 rollout episodes, whereas the paper reports a 5,000-transition training set.

One visible six-cell training script uses a partial language-model freezing strategy, while the paper describes approximately 65 million trainable backbone and projection parameters.

The README tells users to train their own VLA checkpoint rather than identifying a versioned release containing the exact reported weights.

None of these issues invalidates the reported results, and the code may evolve rapidly given the publication date. But a serious reproduction should begin with an immutable commit, the exact dataset-generation command, the precise renderer visibility flags, trainable-parameter count, training seed, and checkpoint hash. The article—not the older README examples—should be treated as the primary specification until those artifacts are synchronized.

The Experiments That Would Make the Next Version Convincing.

The first priority is to remove representational privilege. Feed each UAV egocentric or locally cropped observations, maintain a learned temporal state, and allow only explicitly communicated information into the coordinator. That would test whether the model can perform genuine search rather than consume a ready-made tactical state.

Second, replace the fixed action head with an agent-set decoder. A permutation-equivariant transformer, graph policy, or autoregressive per-agent decoder could support variable fleet sizes and agent dropout. Training should randomize agent identities to prevent the model from tying roles permanently to D0 through D3.

Third, add stronger controls. The key baseline is not another large VLA, but a capacity-matched multimodal transformer with no language pretraining, receiving exactly the same image and structured numeric features. A centralized behavior-cloned MLP or graph network, DAgger, and direct offline distillation into a recurrent policy would help isolate where the VLM backbone genuinely adds value.

Fourth, close the offline-control loop. DAgger-style expert relabeling could expose the student to states induced by its own mistakes. Alternatively, the behavior-cloned VLA could be fine-tuned with environment rewards. Either route should directly target the remaining 26-point success gap and the slower trajectories.

Fifth, integrate constraints into learning rather than relying only on post-processing. Illegal logits can be masked before normalization during both training and inference, and the legal mask can be tested under corruption or omission. For physical UAVs, that constraint layer would eventually need to grow from grid occupancy into separation, geofencing, energy, communication, and dynamic feasibility.

Finally, demonstrate that the language channel behaves like language. Train over multiple missions and prompt formulations, then evaluate unseen paraphrases, new target priorities, search-only versus track-only objectives, operator corrections, and compositional constraints. Until then, “structured multimodal policy” is more precise than “language-reasoning swarm controller.”.

Bottom Line.

MiniUAV-VLA should not be read as evidence that a 158-million-parameter model can already fly and command an autonomous real-world swarm. The environment is two-dimensional, the policy is centralized, the state representation is heavily engineered, the fleet size is fixed, and language generalization is not tested.

What the paper does establish is still worthwhile. A successful MARL policy can serve as an efficient generator of coordinated VLA demonstrations. A compact multimodal transformer can recover much of that strategy from only a few thousand transitions. And when a generative backbone feeds a separate control head, the causal location of the action readout can matter as much as a major increase in data.

The enduring result may therefore be less about UAVs than about architecture hygiene: never train a control head on a hidden state that has already seen the answer it will not have at deployment. MiniUAV-VLA turns that simple principle into a 35-point closed-loop difference—and that is a lesson many embodied-AI systems can use.