Latest / Embodied AI 101 / DART: One-Shot VLA Policy Adaptation via Weight-Space Arithmetic

Transcript

DART: One-Shot VLA Policy Adaptation via Weight-Space Arithmetic · Embodied AI 101

• DART: One-Shot VLA Policy Adaptation via Weight-Space Arithmetic. Imagine you have a powerful vision-language-action (VLA) policy – a robot controller trained to follow language instructions in a rich visual environment. It works great in the environment you trained it in. Now you move the camera to a new angle or put the robot on a different arm – suddenly the policy fails at the same tasks. This is the classic domain shift problem for embodied AI: small changes in sensors or bodies make the learned policy brittle. Traditional solutions require collecting many new demonstrations in the new setup and fully fine-tuning the model, which is slow and expensive. The recent ECCV’26 paper by Kang et al. from Seoul National University introduces a clever fix: Domain ARiThmetic (DART). DART lets you adapt a pretrained VLA policy to a new environment with just one demonstration in that new setting. The trick? Treat the policy’s weight changes like a vector “translation” analogous to word-vector analogies. In effect, DART isolates that “environmental difference” as a domain vector in weight space, and then adds it to the base model. After processing this vector, the policy adapts to the new camera or robot without retraining on tons of data. In experiments across simulators and a real UR10e robot arm, DART smoothly outperformed standard one-shot fine-tuning and even advanced merging methods like RETAIN. Below, we’ll unpack how DART works and why it’s so effective. We’ll assume you’re familiar with VLA policies (e.g. large-language-model–based robot controllers like π₀.₅) and standard RL/IL techniques. We focus on intuition and algorithm steps, avoiding heavy math. The Challenge: Domain Shifts for VLA Policies. Vision-Language-Action (VLA) models combine a vision encoder, a language backbone, and an action module to map language instructions plus visual observations into actions. Examples include large pretrained “generalist” policies trained on broad robot task datasets. These models (like the π-series) have shown impressive multi-task ability. However, as Kang et al. note, such policies often fail to perform the same learned tasks under environmental shifts. What kind of shifts? For instance, mounting the camera at a slightly different height, rotating the gripper camera angle, or even swapping to a different but similar robot arm (e.g. from a Franka Panda arm to a UR5e). Each of these changes can drastically alter the pixel inputs or dynamics, breaking the policy’s assumptions. In practice, this is a big deal: robots in new labs, homes, or factories won’t perfectly match the “training room.”. In principle, you could collect new demos in the target environment and fine-tune the policy. But this is costly: to cover each target domain and each task requires many labeled trajectories. Recent works on VLA adaptation (like RETAIN) have shown that parameter merging or interpolation can help retain generalization, but even those methods require either mixing in pre-training data or tuning interpolation weights. Other approaches rely on heavy augmentation or adaptation of low-level encoders, which demand lots of data or complex losses. Test-time adaptation methods exist, but typically handle only mild shifts or need special objectives at inference time. DART aims to sidestep all that by using only one demonstration in the target domain and manipulating the policy’s weights directly. The key insight is that a shift in environment often acts like a consistent vector offset in the policy’s weight space, largely independent of which task is being performed. If so, one could find that offset from a single example and apply it universally. Kang et al.’s experiments show this holds roughly true for one-shot fine-tuned VLA models: the changes in weights due to a new camera or body can be disentangled from the changes needed for solving a particular task. In other words, one-shot updates contain separate components for “what the task is” and “how the world changed”, and those components add together nicely. DART leverages this by computing the domain component and then adding it to the base model. The DART Algorithm: Weight-Space Analogies. At a high level, DART’s process is as follows. Suppose we have a base policy with weights θ₀ that was trained in the source domain (the original camera position and robot). We also have a single demonstration of some task Tₘ in the target domain (the new environment). DART will use that one task to compute a “domain vector” δ and then form an adapted policy θ′ = θ₀ + α·δ, where α is a scaling factor. The magic is in how we compute δ. 1. Analogy in Weight Space. First, DART performs a pair of fine-tuning steps (conceptually, not necessarily done in deployment time): one on a demonstration of task Tₘ in the source domain, and one on the same task in the target domain. Concretely, let θ_{m,src} be the weights after fine-tuning θ₀ on the demonstration Tₘ in the source environment, and θ_{m,tgt} be the weights after fine-tuning θ₀ on the demonstration in the target environment. Define the update vectors as Δ_{m,src} = θ_{m,src} – θ₀ and Δ_{m,tgt} = θ_{m,tgt} – θ₀. These vectors capture how the policy needs to change to execute task Tₘ in each environment. Now comes the analogy step: we subtract one update from the other to isolate the domain shift. In formula, DART computes. Intuitively, we are saying: “the difference between how the policy adjusts for the target demo versus the source demo should (ideally) encode only what changed between environments.” This is directly analogous to classic analogy examples (“king – man + woman ≈ queen”) in word embeddings or other latent spaces. Here, “task-specific knowledge” should cancel out, leaving the pure domain difference. As the authors note, Δ_{m,tgt} – Δ_{m,src} effectively cancels out the task-specific directions, leaving the domain-shift information. In practice, θ_{m,src} might simply be θ₀ if the base policy was already capable of Tₘ, but fine-tuning on the source ensures both models start from the same θ₀ baseline, making the subtraction clean. Critically, Kang et al. observed that when you fine-tune a VLA model on a single task, the resulting weight change naturally splits into additive task and domain parts. This empirical disentanglement justifies the analogical subtraction. In other words, one-shot fine-tuning yields directions in weight-space that capture “what the robot learned” vs “how the world changed,” and those directions add linearly. Thus, δ computed this way tends to capture domain differences alone. 2. Filtering by Subspace Alignment. A raw subtraction is a good start, but it can still be noisy. The Δ updates may have components that don’t align perfectly (due to overfitting on the single demo, or nonlinear effects), so δ might include unwanted noise. To clean it up, DART uses a subspace alignment step. Here’s the idea: for each layer of the network, look at the singular vector bases of the source and target updates. Concretely, perform SVD (singular value decomposition) on Δ_{m,src} and Δ_{m,tgt} layer by layer. Let U_{src}^{(l)} be the matrix of principal directions (left singular vectors) for layer l in the source update, and U_{tgt}^{(l)} the same for the target update. DART computes an interaction matrix C^{(l)} = (U_{tgt}^{(l)})ᵀ U_{src}^{(l)}. Each column in C corresponds to a direction in U_{src} and measures how much it aligns with the target subspace. If a particular basis vector from U_{src} has very low overlap (low “energy” in C) with all of U_{tgt}, then it means that component of the source update was unique to the source fine-tuning and not present in the target update. DART discards those directions. Formally, it keeps only the columns of U_{src}^{(l)} whose corresponding alignment energy e_j = ||C_{:,j}||² is large. Let ũ_{src}^{(l)} be the matrix of the kept basis vectors. Then DART projects the source update Δ_{m,src}^{(l)} into that shared subspace:. This filtered update only contains the components of Δ_{m,src} that were “aligned” with Δ_{m,tgt}. In effect, we remove the parts of the source update that have no counterpart in the target’s update. This step filters out spurious dimensions that might corrupt the domain difference. 3. Scaling by Alignment Strength. Even after filtering, some misalignment may remain. DART therefore applies a scaling factor per layer to dampen stray components. After filtering, the residual target update Δ_{m,tgt} – ~Δ_{m,src} is scaled by a factor γ^{(l)}, the subspace alignment score. Intuitively, γ^{(l)} is the fraction of the target’s update that lies within the source subspace (after filtering). If Δ_{m,tgt} mostly lived in the same directions as the source update, γ is near 1; if not, γ is smaller, shrinking δ accordingly. So for layer l, DART sets:. In practice, Kang et al. compute γ^{(l)} from the same SVD overlap measures, ensuring that noisy or potentially irrelevant target directions are downweighted. This prevents, for example, a few large singular values in the target update from dominating the domain vector if they have no counterpart in the source. 4. Forming the Adapted Policy. After these steps, we have a refined domain vector δ (composed by stacking its layers δ^{(l)}). The final adapted policy parameters are obtained by adding δ (scaled by a global factor α) to the original weights:. Here, α is a learned coefficient (often tuned on a small validation set) that controls the overall magnitude of the adaptation. If α is 1, we fully inject the domain vector; if it’s less, we conservative scale. In any case, the result θ′ is a new policy meant to operate in the target domain. In summary: DART computes δ by subtracting source and target one-shot updates (an analogy), filtering it via aligned singular subspaces, and scaling the remainder before adding it back to θ₀. Crucially, all this requires no additional gradient steps on the policy except the two one-shot fine-tunings to get Δ_{m,src} and Δ_{m,tgt}. After computing δ, you can deploy θ′ directly. This process is architecture-agnostic (it treats θ₀ as a black box for weight manipulations) and extremely data-efficient – you only needed that one demonstration per domain. Experiments and Results. Kang et al. evaluated DART on a variety of tasks and domain shifts, both in simulation and on real hardware. They use two high-capacity VLA policy architectures (π₀.₅ and a faster variant π₀-FAST) and test three main scenarios:. LIBERO benchmark (simulation): This is a standard suite of robotic manipulation tasks (like pick-and-place, open-door, push-button, etc.) based on off-the-shelf data. The authors create “novel viewpoint” shifts by changing the camera height or angle from training. MimicGen cross-embodiment (simulation): Using the NVlabs MimicGen environment, they transfer between robot embodiments. For example, the source (training) environment uses a Franka Panda arm, while the target uses a different arm (e.g. Sawyer or UR5e) for the same tasks. Real UR10e robot: They also test on a physical Universal Robots UR10e arm. Here tasks like wiping a whiteboard or placing a plate in a rack are demonstrated once via teleoperation, then the policy adapts. Across all these, the pattern is consistent: with just one demonstration in the target domain, DART adapts effectively, whereas naive baselines struggle. In more detail, the authors report that DART achieved successful adaptation using only a single task demonstration, whereas other methods either required more data or performed poorly. Compared to baselines, DART shines:. Zero-shot baseline: This is just running the original policy in the new domain with no adaptation. Unsurprisingly, this yields low success rates under substantial domain changes (often under 50% success). One-shot fine-tuning: A straightforward approach is to fine-tune θ₀ on the one new demo. This helps on that particular task in that setting, but generally overfits – it still fails on variations (like other objects, viewpoints, or unseen tasks) and tends to degrade performance on the original capabilities. In the experiments, one-shot fine-tuning gave only modest gains. Parameter merging methods (e.g. RETAIN): Methods like RETAIN (from recent work on VLA finetuning) blend θ₀ and a fine-tuned θ to trade off generalization. While RETAIN greatly stabilized fine-tuning for robustness, it still needs careful tuning of merge coefficients and doesn’t explicitly separate domain and task. Kang et al. include RETAIN and similar variants as baselines. Other approaches: They also compare to any state-of-the-art test-time or adaptation schemes suitable, though details are specific to each benchmark. The results show DART consistently outperforming all baselines in one-shot tasks. For example, in the LIBERO novel-view tasks, a one-shot fine-tuned policy might reach only ~50% success, while DART often exceeded 90%. On MimicGen, DART-enabled policies achieved high success transferring from Panda to UR5e, whereas zero-shot or naive adapters failed on about half of tasks. Even in the real UR10e trials, DART-adapted policies could reliably execute the demonstrated task (and generalize to slight variations) after a single teach-in. In the authors’ words, DART “consistently outperforms existing baselines, including zero-shot inference, full one-shot fine-tuning, and prior parameter-merging techniques (e.g., RETAIN)”. Another notable finding is compositionality. Kang et al. demonstrate that domain vectors behave linearly: if you separately compute a domain vector for, say, camera-tilt change and another for robot-arm change, you can simply add them and achieve adaptation for both shifts at once. In practice they show combination tests (like a new viewpoint and new robot simultaneously) succeed by summing the corresponding δ’s. This modularity means DART can build a library of shift-vectors and mix-and-match them, a lightweight alternative to retraining for each combined scenario. To sum up, DART’s experiments validate that: (1) A single adjusted weight vector can carry domain knowledge across tasks; (2) The subspace filtering improves robustness; (3) The method works on real hardware; and (4) It beats strong one-shot baselines. This makes it a powerful tool for scaling up robot deployment. Putting It All in Context. The idea of doing arithmetic in weight space may remind some of task arithmetic or model editing in machine learning. Indeed, Task Arithmetic (TA) has shown that carefully chosen weight differences can encode concept shifts or new tasks. What DART shows is that domain shifts (like “our camera moved this way”) can similarly be vectorized. The elegance is that we need no special training or modification of the network – we rely on the empirical fact that fine-tuning is (approximately) linear around the operating point. It’s also instructive to contrast DART with previous VLA adaptation work. The RETAIN method (ICLR 2026) achieved robustness by simple linear interpolation between pretrained and finetuned policies. RETAIN worked well to preserve generality, but it treats all weight parameters together. DART, by contrast, explicitly isolates domain knowledge via subtraction. Because it filters and scales, it avoids corrupting the task-specific parts you want to keep. In effect, where RETAIN trades off old vs new knowledge via blending, DART tries to cleanly separate “what changed” from “what the task is,” then just applies the change factor. In experiments this leads to stronger out-of-domain performance than RETAIN’s merging alone. There are also analogies (no pun intended) to data-based approaches. For instance, the MimicGen work (Yang et al. 2026) argued that having matched demonstration pairings across robots (“data analogies”) greatly speeds up cross-embodiment transfer. DART complements this idea by not requiring explicit paired data; it creates an implicit analogy in weight space instead. This makes DART especially attractive when gathering real data is hard – you need only one demonstration in the new setup, not a whole paired dataset. From a robotics perspective, DART has appealing properties. It is architecture-agnostic and plug-and-play – as the authors emphasize, you can attach DART to any pretrained VLA model without altering its structure. It’s also nearly training-free after the initial base model: aside from computing two weight deltas via one-shot updates, the rest is analytical (SVDs and vector ops). Thus adaptation can be fast, which matters for on-site deployment. Finally, because it uses one demonstration, it is highly data-efficient; in fact the paper highlights it needs just “a single-task, single-demonstration target dataset” to succeed. For operators, this could translate into “teach the robot one example of the task in the new environment” and then deploy. That said, DART does have assumptions and limits. It assumes that the task representation learned by θ₀ is still valid in the new environment – i.e., a single demonstration truly captures only domain variation and not a drastically different objective. If the target domain introduced a qualitatively new challenge (like a new type of sensor missing that core vision feature), a single vector may not suffice. Also, fine-tuning on one demonstration may still overfit slightly, though DART’s filtering helps. The choice of the demonstration task can matter; presumably one should pick a relatively generic task whose update spans relevant subspaces. Kang et al. likely discuss selecting Tₘ, but the high-level point is that any representative task works as the “anchor” for domain inference. In practice, to use DART you would take your pretrained policy (say a π₀.₅ model trained in the lab), collect one trajectory of a task in the new setting (perhaps recorded via teleoperation or kinesthetic teaching), compute the domain vector δ as above (or use the provided code), and then immediately use θ₀+αδ. The authors have released their code for DART (https://github.com/snumprlab/dart), so trying it on your own policy should be straightforward. If you then move to a second new camera angle, you can reuse or recompute another δ and add them. Conclusion. DART – Domain ARiThmetic – introduces a powerful metaphor: treat a domain shift as an additive “translation” in policy weight space. With this view, a single demonstration can illuminate exactly how to shift the robot’s parameters to cope with the new world. Kang et al. demonstrate that this concept works in practice, across vision changes and even swapping out robot arms, without needing large target datasets. For roboticists, DART offers a fast patch for deploying VLA models in novel environments: no hours of data collection, just a quick demo and a weight-vector tweak. The success of DART suggests deeper truths about VLA models: that their fine-tuned weight changes are at least partially disentangled. As the field of embodied AI grows, techniques like DART show how “learning” can sometimes be as simple as arithmetic – on weights instead of pixels. We’ll likely see more work exploiting such analogies, making robot policies more adaptable and modular. Until then, DART stands out as a practical, clever method: the robot equivalent of “just add this vector,” unlocking one-shot generalization across domains.