Vision-Language-Action Models: The Action Interface Is the Hard Part

RT-1 was a 35-million-parameter transformer that ran at 3 Hz and needed 130,000 human-collected demonstrations across 13 robots to cover 700 tasks. Every one of those demonstrations was teleoperated by a person, one episode at a time, with a manual scene reset in between. A language model of the same era consumed more text in a minute of training than that entire dataset represents in human hours.

The natural response was to stop collecting and start borrowing: take a vision-language model that already knows what a sponge is, and teach it to move. That is the vision-language-action model, and the idea works. What the field discovered in the three years since is that the borrowed part was never the bottleneck. Semantics transfer beautifully. What does not transfer is a way to emit continuous, high-frequency, multimodal actions, and every architectural decision in VLA research since RT-2 is an attempt to bolt a control interface onto a model that was designed to emit words.

Why this matters: VLAs are the first credible route to general-purpose manipulation, and the interesting engineering is not in the transformer. It is in how actions are represented, how a chunk of them is committed to, how heterogeneous robot data is pooled, and how any of it is evaluated when a single success rate carries a 20-point error bar. Those are the parts that decide whether a demo becomes a product.

TL;DR

• Representing actions as text tokens made robot policies inherit web-scale semantics, and capped control frequency: every action step costs a full autoregressive decode of one token per dimension, which at 50 Hz means a sustained 350 tokens per second on a single stream.
• π₀ breaks the cap by amortising. A 300M-parameter flow-matching action expert on a 3B PaliGemma backbone emits a 50-step chunk in 10 network evaluations, reaching up to 50 Hz for dexterous tasks like laundry folding.
• The alternative fix keeps tokens and compresses them: FAST applies a discrete cosine transform to the action chunk before quantising, matching diffusion VLA performance while cutting training time up to 5×.
• Action heads must be generative, not regressive. Two demonstrators shown the same clutter reach opposite ways; a mean-squared-error policy averages them into a collision.
• Pooling helps: Open X-Embodiment combined 22 embodiments from 21 institutions covering 527 skills, and OpenVLA at 7B beat the 55B RT-2-X by 16.5 absolute points across 29 tasks.
• Scale is not the binding constraint. Evaluation is. At the common 20 trials, a 70% success rate has a 95% interval running from 50% to 90%, so most published policy comparisons cannot support their conclusions.

At a Glance

flowchart LR
    A[Camera plus instruction] --> B[VLM backbone]
    B --> C[Action interface]
    C --> D[Action chunk]
    D --> E[Robot executes prefix]
    E --> A
    F[(Teleop data)] -.-> B
    G[(Web VQA data)] -.-> B

    classDef blue fill:#1e40af,stroke:#3b82f6,stroke-width:1px,color:#fff
    classDef purple fill:#6d28d9,stroke:#a78bfa,stroke-width:1px,color:#fff
    classDef amber fill:#b45309,stroke:#fbbf24,stroke-width:1px,color:#fff
    classDef teal fill:#0e7490,stroke:#22d3ee,stroke-width:1px,color:#fff
    classDef slate fill:#334155,stroke:#64748b,stroke-width:1px,color:#e2e8f0
    class A blue
    class B purple
    class C amber
    class D,E teal
    class F,G slate

The amber box is where the arguments are. Everything to its left is a solved commodity; everything to its right is physics.

Before Anyone Borrowed a Language Model

Robot learning spent the 2010s solving a different problem: how to train at all without destroying hardware. The answer was simulation, and the obstacle was that simulators lie. Domain randomisation attacked that directly by randomising physics and appearance every episode so no policy could depend on any single wrong parameter, and automatic domain randomisation removed the hand-tuning by growing the ranges as the policy improved, which is how OpenAI transferred a Rubik's-cube-manipulating hand from simulation to real hardware and observed memory-augmented policies adapting at test time (OpenAI et al., 2019, arXiv:1910.07113).

The other half was throughput. Physics on CPU with policies on GPU meant a PCIe round trip per step; Isaac Gym put both on the device with physics buffers handed to PyTorch as tensors, reporting 2 to 3 orders of magnitude improvement over conventional RL training (Makoviychuk et al., 2021, arXiv:2108.10470). Legged locomotion went from a cluster job to a coffee break, and most of the visible progress in quadrupeds and humanoids since is downstream of that iteration speed.

Manipulation did not benefit equally, because contact-rich tasks depend on friction transitions and deformation that simulators model poorly. So manipulation stayed with imitation learning from human demonstrations, and the question became how few demonstrations you could get away with. ACT answered with action chunking: predict a sequence of future actions rather than one, which suppresses compounding error and absorbs the non-stationarity of human teleoperation, reaching 80-90% success on six fine manipulation tasks including opening a translucent condiment cup, from ten minutes of demonstrations per task (Zhao et al., RSS 2023, arXiv:2304.13705).

Then RT-1 showed that a single transformer trained on 130,000 demonstrations could do 700 tasks at 3 Hz with 35M parameters, and RT-2 showed you could skip most of the collection by starting from a vision-language model (Brohan et al., RSS 2023, arXiv:2212.06817; Brohan et al., 2023, arXiv:2307.15818).

timeline
    title From simulators to vision-language-action models
    2017 : Domain randomisation makes sim-trained vision transfer
    2019 : Automatic domain randomisation solves a Rubik's cube on real hardware
    2021 : Isaac Gym moves physics onto the GPU, 2 to 3 orders of magnitude faster
    2022 : RT-1 does 700 tasks at 3 Hz from 130k teleoperated demonstrations
    2023 : RT-2 emits actions as text tokens from a web-pretrained VLM
         : Diffusion Policy models action chunks generatively, plus 46.9 percent
         : ACT gets 80 to 90 percent on fine tasks from ten minutes of demos
         : Open X-Embodiment pools 22 embodiments from 21 institutions
    2024 : OpenVLA at 7B beats the 55B RT-2-X by 16.5 points
         : pi-zero adds a flow-matching action expert and reaches 50 Hz
    2025 : FAST compresses action chunks with a DCT and cuts training time 5x

How a VLA Actually Emits an Action

A robot action is a short real-valued vector, typically end-effector delta pose plus a gripper command, wanted at tens of hertz. A language model emits one discrete symbol at a time from a fixed vocabulary. Reconciling those is the entire problem, and four answers exist.

Answer one: pretend actions are words

RT-2 discretises each action dimension into 256 bins and emits the bin indices as text tokens, so a robot policy is literally a VLM being fine-tuned on a strange dialect. The payoff is large and real: co-fine-tuning on internet VQA data alongside robot trajectories produces generalisation to novel objects, the ability to follow instructions absent from the robot data, and rudimentary semantic reasoning such as selecting a rock as an improvised hammer.

The cost is arithmetic. With \(d\) action dimensions at one token each and control frequency \(f\), the decode rate required is

For a 7-DoF arm at 50 Hz that is 350 tokens per second, sustained, on one sequence with no batching to hide latency. That is at or beyond what a well-optimised 7B model delivers on a single accelerator and far out of reach for a 55B one. RT-1's 35M model hit 3 Hz with about 15 ms of inference; scaling the same interface up trades frequency for semantics, and dexterity needs both.

Per-dimension binning has a second, subtler cost. Consecutive actions in high-frequency data are strongly correlated, and independent per-timestep binning discards that structure entirely, which is why the scheme degrades badly on exactly the dexterous data it most needs to model (Pertsch et al., 2025, arXiv:2501.09747).

Answer two: keep tokens, compress them

If the problem is that a smooth 50-step trajectory becomes 350 near-duplicate bin indices, compress the trajectory before quantising. FAST applies a discrete cosine transform to the action chunk, quantises the coefficients, and byte-pair-encodes the result, so a smooth trajectory becomes a short token string whose length reflects its actual complexity. It scales to 10,000 hours of robot data, matches diffusion VLA performance, reduces training time by up to 5×, and succeeds on tasks where standard discretisation fails outright. The released FAST+ tokeniser was fit on 1M real trajectories and is intended to be used off the shelf.

This is the conservative answer, and its virtue is that nothing else changes: the policy remains a language model, so every existing training and serving tool applies unmodified.

Answer three: attach a continuous head

The aggressive answer removes tokenisation from the action path. π₀ keeps a 3B PaliGemma backbone for perception and language and adds a separate 300M-parameter action expert that emits continuous actions by flow matching, 3.3B parameters in total, producing chunks of horizon \(H = 50\) at up to 50 Hz for dexterous tasks, trained on a mixture including over 10,000 hours of robot data spanning 7 robot configurations across single-arm, dual-arm and mobile platforms (Black et al., 2024, arXiv:2410.24164).

Training regresses a denoising vector field over noised action chunks conditioned on observation and instruction. Write \(A_t\) for the demonstrated chunk of \(H\) actions, \(\epsilon\) for a noise sample, and interpolate linearly between them, \(A^\tau = (1-\tau)\,\epsilon + \tau A_t\), so that \(\tau = 0\) is pure noise and \(\tau = 1\) is the demonstration. The path velocity is constant along that segment, which gives the regression target directly:

At inference the chunk is produced by starting from noise and integrating that field from \(\tau = 0\) to \(\tau = 1\) with forward Euler in 10 steps. (Sign and direction conventions differ between papers; what matters is that the target is a difference of two samples and needs no simulation to compute.) Ten network evaluations for fifty actions is the whole trick: the expensive computation is amortised across the chunk rather than paid per action.

Why generative rather than a plain regressor? Because the correct action is genuinely multimodal. Two demonstrators facing the same cluttered scene will reach around opposite sides of an obstacle, and a squared-error policy learns their average, which drives straight into it. Modelling a distribution over chunks is the same argument that gave Diffusion Policy an average improvement of 46.9% across 12 tasks from 4 benchmarks (Chi et al., RSS 2023, arXiv:2303.04137).

Answer four: do not use a language model at all

Diffusion Policy and ACT are not VLAs. They are task-specific visuomotor policies trained from scratch on demonstrations, and on a single well-specified task with enough demonstrations they are competitive with or better than a generalist. What they lack is the ability to follow an instruction they have never seen, or to recognise an object that was not in the training set. The generalist premium is paid in data and compute and bought back in semantics.

flowchart TB
    subgraph TOK[Discrete tokens]
        A1[Bin each dimension] --> A2[Decode d tokens per step]
        A2 --> A3[Frequency capped]
    end
    subgraph FAST[DCT tokens]
        B1[DCT over chunk] --> B2[Quantise plus BPE]
        B2 --> B3[Short strings, same stack]
    end
    subgraph FLOW[Flow action expert]
        C1[Noise a chunk] --> C2[Regress velocity field]
        C2 --> C3[10 Euler steps per chunk]
    end
    subgraph SCRATCH[Task-specific policy]
        D1[Train from demos only] --> D2[No language grounding]
    end

    classDef amber fill:#b45309,stroke:#fbbf24,stroke-width:1px,color:#fff
    classDef purple fill:#6d28d9,stroke:#a78bfa,stroke-width:1px,color:#fff
    classDef teal fill:#0e7490,stroke:#22d3ee,stroke-width:1px,color:#fff
    classDef rose fill:#be123c,stroke:#fb7185,stroke-width:1px,color:#fff
    class A1,B1,C1,D1 amber
    class A2,B2,C2 purple
    class A3,D2 rose
    class B3,C3 teal

Seeing It in Motion

The control loop is where chunking earns its keep and creates its own hazard.

sequenceDiagram
    participant S as Sensors
    participant B as VLM backbone
    participant E as Action expert
    participant C as Controller
    participant R as Robot
    S->>B: Images plus instruction
    B->>E: Conditioning features
    loop 10 Euler steps
        E->>E: Integrate velocity field
    end
    E->>C: Chunk of 50 actions
    C->>R: Execute first 20 actions
    Note over C,R: Open loop for 400 ms
    R->>S: New observation
    Note over S,E: Re-plan discards the unused 30 actions

Committing to a chunk buys temporal consistency and cuts inference cost per action. It also means the robot is blind for the duration of the executed prefix. Execute all 50 actions and a slipping object is not noticed for a full second; re-plan every step and the amortisation vanishes. Real systems execute a prefix and re-plan, which is receding-horizon control, and the prefix length is an explicit dial between latency and reactivity.

Pooling data across robots is the other half of the picture, and it has a shape worth drawing: a pyramid where each layer is larger, cheaper and less relevant than the one below it.

flowchart TB
    W["Web image-text, near-free"] --> X["Simulation, cheap but wrong physics"]
    X --> Y["Cross-embodiment teleop, shared action space"]
    Y --> Z["In-domain teleop, exact robot and scene"]
    Z --> P[Deployed policy]
    W -. semantics only .-> P
    Z -. contact and calibration .-> P

    classDef slate fill:#334155,stroke:#64748b,stroke-width:1px,color:#e2e8f0
    classDef amber fill:#b45309,stroke:#fbbf24,stroke-width:1px,color:#fff
    classDef purple fill:#6d28d9,stroke:#a78bfa,stroke-width:1px,color:#fff
    classDef teal fill:#0e7490,stroke:#22d3ee,stroke-width:1px,color:#fff
    class W slate
    class X amber
    class Y purple
    class Z purple
    class P teal

Open X-Embodiment is the third layer made real: 22 embodiments, 21 institutions, 527 skills, 160,266 tasks, with RT-X models showing positive transfer, meaning a policy trained on the union beats the same policy trained only on the target robot's own data (Open X-Embodiment Collaboration, 2023, arXiv:2310.08864). Making that pooling possible requires forcing agreement on a shared action space, usually end-effector deltas plus a gripper scalar normalised per dataset, a shared observation interface of images plus instruction, and a common control rate. Everything embodiment-specific is lost in that projection, which is why pooled generalists reach well and insert badly.

[IMAGE: Side-by-side trajectory plots for one reach-around-obstacle task. Left: samples from a flow-matching action head showing two distinct clusters passing either side of the obstacle. Right: the mean-squared-error regression output, a single trajectory passing through the obstacle. Caption: "Averaging two valid demonstrations produces an invalid action. This is why the head must be generative."]

Watch It Run

By the Numbers

Sources: RT-1 parameter count, demonstration count, task count and 3 Hz control rate from the RSS 2023 paper (arXiv:2212.06817); ACT from arXiv:2304.13705; Diffusion Policy from arXiv:2303.04137; RT-2 from arXiv:2307.15818; Open X-Embodiment counts from arXiv:2310.08864; OpenVLA from arXiv:2406.09246; π₀ figures from arXiv:2410.24164; FAST from arXiv:2501.09747. Success rates from different papers were measured on different hardware, objects and protocols and are not directly comparable; see the evaluation section below for why that caveat is stronger than it sounds.

[IMAGE: Grouped bar chart of training data scale on a log axis: web image-text pairs (billions), simulation steps (billions), Open X-Embodiment trajectories (hundreds of thousands), in-domain teleoperated demonstrations for one task (hundreds). Annotate each bar with marginal cost per sample. Caption: "Five orders of magnitude separate the cheapest and the most relevant data."]

A Concrete Example

A dual-arm robot folding a shirt, running a π₀-style policy. Work out what one second of operation costs.

Step 1: the chunk. The policy emits \(H = 50\) actions. At a 50 Hz control rate, that chunk covers exactly

Step 2: the re-plan policy. The controller executes only the first 20 actions, 400 ms, then re-plans from a fresh observation. The remaining 30 actions are discarded. So chunks are generated at

Step 3: the compute per second. Each chunk costs one backbone pass over the images and instruction, plus 10 Euler steps through the 300M action expert. Per second of wall clock:

• backbone forward passes: \(2.5 \times 3\text{B params}\)
• action expert forward passes: \(2.5 \times 10 \times 300\text{M params} = 7.5\text{B params}\)

The expert, at a tenth of the backbone's size, does 2.5× more parameter-work per second than the backbone. The compute profile of a VLA is not the compute profile of the VLM it was built from, which is a useful thing to know before sizing an on-robot accelerator.

Step 4: the discrete-token comparison. Emit the same behaviour as bin indices. Two 7-DoF arms plus two grippers is 16 dimensions, one token each, at 50 Hz:

Every token is a full forward pass over the whole model. At 3.3B parameters that is 2.64 trillion parameter-visits per second against the action expert's 10.5 billion, a factor of roughly 250. The frequency ceiling on token-based VLAs is not an implementation detail waiting for a better kernel; it is two orders of magnitude of structural overhead.

Step 5: the reactivity cost. During each 400 ms open-loop window, the shirt can slip. At 50 Hz the policy would have noticed within 20 ms; with a 400 ms prefix it notices up to 20 control steps late. Shortening the prefix to 10 actions halves the blind window and doubles chunk generation to 5 per second, taking the expert's work to 15B parameter-visits per second. That is the dial, priced.

Where It Breaks

Behaviour cloning drifts, and chunking only delays it

A policy trained on expert demonstrations sees only states the expert visited. The first small error takes it slightly off-distribution, where its predictions are worse, which produces a larger error. Chunking suppresses the high-frequency component of this by committing to coherent multi-step motion, and it does not remove the underlying problem, which is that the training distribution has no coverage of recovery. This is why policies fail in a characteristic way, smoothly and confidently executing a doomed motion rather than stalling.

Evaluation cannot resolve the differences being claimed

Robot evaluation is a sequence of Bernoulli trials, and the standard error at success rate \(\hat{p}\) over \(n\) trials is \(\sqrt{\hat{p}(1-\hat{p})/n}\). At \(\hat p = 0.7\) and the customary \(n = 20\), that is 0.102, so the 95% interval runs from roughly 50% to 90%. Detecting a genuine 10-point difference near 70% at conventional power takes on the order of 300 trials per condition, which at two minutes per trial with manual resets is over ten hours of human labour per policy.

Confounds compound the noise. Success depends on the initial object placement, and an operator who has just watched a policy fail will place the object differently. Lighting drifts, cameras get bumped, grippers wear, so evaluating policy A in the morning and B in the afternoon confounds policy with time of day. Interleaving trials removes most of that and costs nothing. Simulated evaluation is the obvious escape, and SIMPLER is the serious attempt to make it trustworthy, explicitly targeting control and visual disparities and validating through paired sim-and-real runs that rankings and distribution-shift sensitivity carry over (Li et al., 2024, arXiv:2405.05941).

The shared action space is a lossy compression of dexterity

End-effector delta pose plus a gripper scalar cannot express a five-finger regrasp, a whole-body motion, or a force-controlled insertion. Anything that does not survive projection into the pooled space is invisible to a cross-embodiment model no matter how much data is added. Force and torque channels are also routinely dropped to make datasets compatible, which removes exactly the signal contact-rich tasks depend on. A pooled generalist is systematically better at reaching than at inserting, and that is an interface property, not a capacity property.

Negative transfer lands on the robots with the most data

Pooling pulls the policy toward the modal embodiment in the mixture. Data-poor platforms gain; a platform with abundant in-domain data can be dragged off its own optimum. Mixture weights are therefore a tuned hyperparameter, and the weights that help one target hurt another, which makes "train one generalist for everyone" more aspiration than method.

Language grounding is shallower than the demos suggest

A VLA that follows "pick up the red bowl" is doing something real, and it is usually not compositional reasoning. Instructions in robot datasets are short, templated and highly correlated with the visual scene, so a policy can perform well by matching the instruction to a training cluster. The tell is negative instructions, unusual attribute combinations, and spatial relations, which degrade far faster than object nouns.

Continuous heads hide their own uncertainty

A discrete policy expresses doubt through its token distribution. A flow head integrates noise into a trajectory and returns something decisive whatever the observation, so "the policy does not know what to do here" has no natural signal. Detecting it requires added machinery: sampling several chunks and measuring disagreement, ensembling, or tracking chunk-to-chunk variance across re-plans.

Alternative Designs

The last two rows are not competitors so much as a different bet about where physics is learnable. Locomotion is forgiving, self-correcting and well simulated, so simulation-first works. Manipulation is none of those, so it stays demonstration-first, and the world-model line (Hafner et al., 2023, arXiv:2301.04104) is the attempt to get simulation-like sample efficiency without a simulator.

How It Is Used in Practice

Deployment reality diverges from the papers in three ways worth naming.

Data collection is the product. Teams building on VLAs spend most of their capital on teleoperation rigs, operators and scene resets, not on training. The model architecture is largely settled; the differentiator is hours of relevant demonstrations, which is why the interesting infrastructure work is in low-cost bimanual teleoperation hardware and in automated reset mechanisms.

Fine-tuning is where the generalist becomes useful. The pattern is pretrain-then-specialise: take a pooled checkpoint, fine-tune on a few hundred in-domain demonstrations of the actual task on the actual robot. OpenVLA's demonstration that LoRA fine-tuning on consumer GPUs preserves performance matters commercially far more than its benchmark margin, because it puts adaptation inside a small team's budget.

Safety lives outside the policy. No serious deployment lets a learned policy command a robot directly. There is a controller enforcing joint limits, velocity caps, force thresholds and workspace boundaries beneath it, and the policy's chunk is a suggestion that the controller may clip. This changes the effective action distribution, sometimes in ways the policy was never trained on, which is a real and under-discussed source of deployment-time behaviour change.

Insights Worth Remembering

1. The action interface, not the backbone, sets the frequency ceiling. Emitting one token per dimension per timestep costs a full model forward per token. Amortising over a chunk is the only route to dexterous control rates, whether by compressing tokens or by attaching a continuous head.

2. Action heads must model distributions, not means. Multiple valid demonstrations averaged together produce an invalid action. Every successful modern policy head, diffusion or flow, is generative for this reason and not for elegance.

3. Chunking trades reactivity for compute, explicitly. Prefix length is a dial with a computable price on both sides. It should be chosen from task dynamics, not inherited from a config file.

4. Pooled data buys semantics, not contact. What survives projection into a shared end-effector action space is coarse motion and object identity. Fine dexterity and force control do not, so a generalist checkpoint is a strong prior and a weak specialist.

5. Evaluation is the field's binding constraint. At 20 trials, most reported differences are noise. Until trial counts, confidence intervals, interleaved protocols and failure taxonomies are standard, progress is being measured with an instrument too coarse to see it.

6. Compute at inference is dominated by the small head. In a 3B-plus-300M design running 10 solver steps per chunk, the 300M expert does several times the parameter-work of the backbone per second. Size the accelerator for the head.

7. A demo is not a deployment. The gap is filled with teleoperation hours, safety controllers that clip the policy's output, and a reset procedure. None of those appear in a paper's method section and all of them determine whether the thing works on a Tuesday.

Open Questions

Can video substitute for teleoperation? Genie learns a latent action model from unlabelled internet video, inferring what action occurred between frames with no ground-truth labels (Bruce et al., ICML 2024, arXiv:2402.15391). Whether inferred latent actions can be aligned with a specific robot's action space well enough to substitute for real demonstrations is measured only in narrow settings so far. If it works, the data asymmetry that defines the field disappears; if it does not, teleoperation remains the rate limiter.

What is the right amount of embodiment-specific structure? Current pooling erases embodiment differences to make data compatible. An alternative is to keep them and condition on an embodiment descriptor, letting the model learn what transfers. Both are being tried; there is no clean matched comparison, and the answer determines whether "one model, many robots" is an architecture or a marketing line.

Do solver steps trade off against policy quality in a predictable way? Ten Euler steps is a convention. Nobody has published a clean curve of task success against integration steps across tasks, so a widely used efficiency knob is currently set by folklore.

Is reinforcement learning necessary on top of imitation? Behaviour cloning cannot exceed its demonstrators and has no coverage of recovery. Adding on-robot RL is the obvious fix and is bounded by the same evaluation and reset costs that limit everything else. Whether offline RL on pooled data can substitute is an open empirical question with active work on both sides.

How much does the safety controller change the learned distribution? Clipping a policy's output at deployment produces actions the policy never emitted and never trained on. The magnitude of this effect appears in no published evaluation, and it is the kind of gap that shows up as an unexplained deployment regression.

Sources and Further Reading

1. Brohan, A., Brown, N., Carbajal, J., et al. (2023). "RT-1: Robotics Transformer for Real-World Control at Scale." RSS 2023. arXiv:2212.06817
2. Brohan, A., Brown, N., Carbajal, J., et al. (2023). "RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control." arXiv:2307.15818
3. Open X-Embodiment Collaboration (2023). "Open X-Embodiment: Robotic Learning Datasets and RT-X Models." arXiv:2310.08864
4. Kim, M. J., Pertsch, K., Karamcheti, S., et al. (2024). "OpenVLA: An Open-Source Vision-Language-Action Model." arXiv:2406.09246
5. Black, K., Brown, N., Driess, D., et al. (2024). "π₀: A Vision-Language-Action Flow Model for General Robot Control." Physical Intelligence. arXiv:2410.24164
6. Pertsch, K., Stachowicz, K., Ichter, B., et al. (2025). "FAST: Efficient Action Tokenization for Vision-Language-Action Models." arXiv:2501.09747
7. Chi, C., Xu, Z., Feng, S., et al. (2023). "Diffusion Policy: Visuomotor Policy Learning via Action Diffusion." RSS 2023. arXiv:2303.04137
8. Zhao, T. Z., Kumar, V., Levine, S., & Finn, C. (2023). "Learning Fine-Grained Bimanual Manipulation with Low-Cost Hardware." RSS 2023. arXiv:2304.13705
9. Lipman, Y., Chen, R. T. Q., Ben-Hamu, H., Nickel, M., & Le, M. (2023). "Flow Matching for Generative Modeling." ICLR 2023. arXiv:2210.02747
10. Makoviychuk, V., Wawrzyniak, L., Guo, Y., et al. (2021). "Isaac Gym: High Performance GPU-Based Physics Simulation For Robot Learning." arXiv:2108.10470
11. OpenAI, Akkaya, I., Andrychowicz, M., et al. (2019). "Solving Rubik's Cube with a Robot Hand." arXiv:1910.07113
12. Hafner, D., Pasukonis, J., Ba, J., & Lillicrap, T. (2023). "Mastering Diverse Domains through World Models." arXiv:2301.04104
13. Bruce, J., Dennis, M., Edwards, A., et al. (2024). "Genie: Generative Interactive Environments." ICML 2024. arXiv:2402.15391
14. Li, X., Hsu, K., Gu, J., et al. (2024). "Evaluating Real-World Robot Manipulation Policies in Simulation." arXiv:2405.05941

Free to read, no ads, no sign-up. If it was useful you can buy me a coffee.