From RT1 to MolMoAct2: A brief history of VLAs

Introduction

Vision-Language-Action Model is one of the words that I came across frequently while starting out on twitter in the robot learning community. In 2026 with every "GPT moment for robotics" what I felt interesting was that robotics is yet to converge to a consensus on what is the big thing to scale and people strongly bet on different methods, one of them being VLAs.

I wanted to understand how we got here, what actually changed from RT-1 to newer models like MolmoAct 2, and which architectural decisions made these systems work. This blog is my attempt to trace that evolution, understand the trade-offs, and run a few small experiments along the way. Mostly, it's an excuse to update my own world model of robot learning.

But why do we need VLAs?

Consider a robot arm is halfway through a pick-and-place task and someone moves the bin two inches to the left. It misses. It tries again. It misses again. And finally stops.

That is not a sensor failure or a calibration issue. That is the fundamental problem with how robots have been built: they are trained for exact conditions, and the moment those conditions shift, even slightly, they fall apart. They can see. They can move. What they cannot do is reason about what they are seeing and decide what to do next.

A very simple architecture of VLAs

For a long time, these two ideas were robust but nobody had fully connected them.

Vision-language-models were capable getting remarkably capable. GPT-4V, Gemini, and LLaVA could look at an image and answer questions about it. You could show one cluttered desk and ask where the cup was or what was missing, and it would give you a sensible answer. What it could not do was reach out or move anything:

• The reasoning happened entirely inside model.

• No output was given to motors/ no connection to physical world.

• Basically strong at understanding but can't take actions.

Classical robot control, on the other hand, has been used for robot actions for decades in industrial robotics. Factory arms, pick-and-place systems were reliable, fast and precise but brittle in specific way. Each system was trained or programmed for one task, in one environment and under specific conditions. The system broken up the moment anything changed:

• Moving objects a few centimeters and it misses the target.

• Anything unseen and it just stops working and changed in lighting caused performance drop.

So the classical manipulation way had no generalization because it was just pattern matching and no thinking. For intelligent robotics generalization is necessary and VLAs felt a promising way to go ahead.

To think of it, the insight that produced VLAs was straightforward in hindsight. Take the reasoning capacity of vision-language-model and give it a new output modality (action head).

So after training it ene-to-end on robot demonstrations, the first results showed it actually transferred which showed the model's ability to understand scenes and follow instructions carried over into physical tasks better than imitation learning.

Vision-Language-Action Models

Tl;dr Vision-language-action (VLA) models take camera observations and a natural-language instruction and predict robot commands, hence replacing the classic separate perception and control pipelines. This shift in architecture lets robots generalize to conditions they were not explicitly trained for(though it depends on model and training), which scripted and classical control systems cannot do.

General VLA Architecture

Lets understand the working with an example. Imagine a robot in front of a red cup, you tell it "pick up the red cup". The images from camera are passed through the visual encoder which coverts the image patches into visual feature embeddings and the language instruction is tokenised and converted into text embedding. Many models also take robot state information such as joint angles and gripper opening as input and mapped into embeddings.

Next, the transformer processes these together, so for an instruction like “pick up the red cup”, it connects the instruction with the cup in the image and its position relative to the gripper. This information is represented internally.

Coming to the action head, it uses this representation to predict movements, such as changes in gripper position, rotation and opening. some models predict discretized action tokens, others predict continuous values directly or use diffusion/flow matching. Many predict several future actions together, called an action chunk.

Then the robot controller executes these commands, we get updated images and robot state, and repeat. For training, many VLAs start with a pretrained VLM and learn from robot demonstrations containing images, instructions and corresponding actions. basically the demonstrations teach the model how to connect what it sees and what we ask with the movements it should make.

A brief history of VLAs

The Coke can demo

This may be the most significant moment in modern robotics. In 2023, a researcher at Google set a table with a Coke can, pictures of Tom Cruise, Snoop Dogg, and Taylor Swift, and asked Google's newest robot brain, RT2, to move the Coke can to Taylor Swift. RT2 was too large to run on the robot itself. The robot sent one image at a time from its onboard camera to a TPU cluster, which sent back control signals. The robot controlled by RT2 slowly picked up the Coke can and awkwardly placed it on the edge of the picture of Taylor Swift. In 2025, Carol Hausman, one of the researchers from the team describes this as the moment it became clear to him that this was going to work.

Within a year of the 2023 Coke can demo, Hausman and many of the key members of the RT2 team had left Google, and reassembled to form Physical Intelligence. And the robots have gotten better since then. The latest robot brains from Physical Intelligence can open padlocks, fold your laundry, peel an orange, make a grilled cheese sandwich, make coffee, and clean up bedrooms and kitchens that it's never seen before.

SayCan: Using language models to plan

In 2022, the year ChatGPT was released, researchers at Google began exploring what role large language models might play in robotics. Their first notable result was a system called as SayCan. Basically here they used a large language model as a planning system to break down complex tasks into subtasks. For example, SayCan could break down cleaning up a spill into the subtasks of finding a sponge, picking up the sponge, going to the spill, and so on. Once the LLM in SayCan decided to pick up a sponge, a completely separate neural network that had been trained to imitate humans controlling robots to perform various small tasks, was used to compute the actual robot control signals. This meant that SayCan was effectively limited to a menu of actions the LLM could choose from.

This is where RT-1 comes in.

RT-1: Learning a unified robot policy

RT-1 is the Robotics Transformer 1 model by Google Robotics trained on 130k successful robotics episodes, 13 robots and 700 tasks and over 17 months. Its main idea is that given natural language instruction + camera images, it outputs discrete action tokens for robot arm, base and selection of mode.

The model takes one natural language instruction+ 6 images at a time and outputs discrete action tokens(contains 11 components- 3 arm translation, 3 arm rotation, gripper movement, base translation and rotation 3 and mode selection for arm/base/terminate).

RT-1 consists of FiLM EfficientNet+TokenLearner+ Transformer. First, they use Universal Sentence Encoder for language instruction which converts complete sentence into fixed size vector, it does not contain an LLM performing an explicit reasoning process, the USE basically supplies semantic representation of instruction.

After this, the model processes 6 images at a time(6 images for better temporal understanding and to show motion), each image is of 300 × 300 resolution, so each images is processed using an ImageNet-pretrained EfficientNet-B3 visual encoder which converts each image into 9 × 9 grid and each grid is mapped with 512 dim feature vector so total 81 tokens represent different regions of the image.

FiLM conditioning: The visual representation of an image can change depending on the instruction. The model generates two parameters gamma and beta with instruction embeddings and uses them in a function to scale and transform the current visual processing so that features associated with that particular language instruction become more useful.

Eg, open the drawer is the language instruction, so after FiLM conditioning the feature vectors are changed such that more weight is given to the visual features that should matter and in this case it can be drawer handle, cupboard. “pick up the can” may emphasize the can and gripper, “open the drawer” may emphasize the drawer and handle.

After EfficientNet, each image has 81 spatial tokens and there are 6 images in total so total 6 × 81 = 486 tokens which is expensive and difficult for self-attention, so they use TokenLearner to compress each image from 81 tokens to summary of 8 tokens. It produces eight learned weighted summaries of the 81 spatial locations. One token can combine information from multiple regions. Where one TokenLearner output is weighted combination of information across the image. zk= summation alpha ki × Fi. Because of this RT-1 runs faster.

The eight tokens from each of the six frames are arranged into a sequence of 48 tokens and processed by the decoder-only Transformer. i.e (z1,z2…z8)- decoder only Transformer - action prediction. The Transformer has 8 self-attention layers, total model parameters are 35 million out of which 19 million belong to Transformer.

Transformer connects info across different parts of process such as where can is currently, where gripper was in prev frames, whether gripper approaching can, whether instruction required picking/moving.

In the end the model outputs discrete action tokens, action contains total 11 components: 3 for arm translation, 3 arm rotation, 1 gripper movement, 3 base translation and rotation and one last for mode selection. They have used discretization here where the bin size is 256 bins, so it becomes classification problem. It operated on 3Hz frequency i.e. RT-1 roughly replans 3 times per sec, observe- predict one action- execute- observe again.

RT-1 uses discretization for this.

For training they use behavioural cloning where they train model to copy the expert human teleop actions given images and instruction. 130000 successful robot episodes. More than 700 tasks( picking objects, placing objects near each other, opening and closing drawers, etc).

RT-1 achieved approximately 97% success on seen tasks, 76% on unseen instructions, 83% under visual distractors and 59% in new backgrounds. The drop from 97% on seen tasks to 59% in new backgrounds shows that scaling the dataset improved robustness but environment generalization still unsolved.

RT-1 demonstrated that a single Transformer policy could replace many separately trained task-specific policies. Its main contribution was not a new reasoning mechanism, but showing that behavioural cloning could scale across a large and diverse collection of real-robot tasks while remaining fast enough for closed-loop control. SayCan performed high-level task decomposition, while RT-1 executed individual low-level skills.

What I found interesting is that removing the task diversity(reducing the no. of different tasks) made generalisation more worse than simply reducing the number of same demo task. Which means seeing many different behaviours can be more valuable than seeing huge no. of repetition of narrow no. of same behaviours.

I also found TokenLearner interesting because it creates an information bottleneck. RT-1 compresses 486 spatial tokens into only 48 tokens before the Transformer. This makes the policy faster, but it also assumes that eight learned summaries per image preserve everything required for manipulation. Small objects and precise geometry could potentially be lost during this compression.

Experiment 1: Understanding discretization

We saw that RT-1 outputs discrete action tokens. So a continuos command has to be mapped to one of a limited set of values. To understand how much information loss is caused by this rounding, I ran an offline reconstruction experiment where I took 843 recorded actions from three LIBERO demonstrations and rounded each action component to the nearest value on a uniform grid and tested 16, 32, 64, 128 and 256 values per dimension.

As expected, adding more number of bins reduced reconstruction error, but there is another question that what should be the range of these values.

Imagine marking equally spaced positions on a ruler. With a fixed number of marks, a shorter ruler places them closer than than otherwise. This improves precision within its range but any values beyond the borderline gets rejected.

So I compare two versions: one covered the full observed range of commands and the other shortened the range to the 1st–99th percentiles basically clipping commands outside the boundry.

We can see here for 16 bins, clipping has helped slightly as the finer spacing compensated for the information lost at the extremes whereas for 256 bins, the full-range version had roughly 5.5 times lower error. For 256 bins, although the rounding became very precise but the rejecting clipped values hurt more than precision helped and that better one step accuracy does not guarantee proportionally better long horizon behaiviour.

I also checked what happened when errors were added across consecutive commands. Smaller individual errors did not always produce a smaller final discrepancy because errors can either reinforce or cancel each other.

So the final takeaway from this is action resolution depends on both how many values are available and which range they cover.

RT-2: Teaching a VLM to act

RT-1 learned from robot demos, but its semantic knowledge was mostly limited to concepts represented in those demos, i.e. it does not know the meaning of every concept. Web-trained VLMs already know this because of image-captioning, visual-question-answering and language datasets.

So now the question was, can we take a VLM that already understands images and language and use it to produce actions?

The answer turned out yes! The trick was we could use actions as another language. For example, VLM: image of several objects + “Which object is the dinosaur?” → “The green toy.” So we use this information from the VLM and convert robot actions into text tokens: image + “Pick up the dinosaur” → “128, 91, 241, 5, 101, 127, 217” (discretized robot command).

Here, unlike RT-1’s six-image history, the main RT-2 formulation uses only the current image. Temporal behaviour comes primarily from closed-loop execution: act, observe a new image, act again.

RT-2 predicts an 8-component action which is discretized into 256 bins. It uses two different VLM families to assign action tokens: PaLI-X, both 5B and 55B versions (there are already individual tokens below 1000, so the action 154 can be directly used as a text token), and the PaLM-E 12B version (there are no already available action tokens, so the authors use 256 rarely used words and redefine them as action tokens, but since these are random words, there is no correlation between them).

One interesting concept I felt was autoregressive action generation: RT-2 generates 8 action tokens sequentially. Each token is predicted using the image, instruction and previously generated action tokens:

For example, when predicting the translation command along the y-axis, it can condition on the previously predicted x-axis command:

The paper’s ablation compares training from scratch, ordinary fine-tuning and co-fine-tuning, and shows that pretrained weights and retaining web data both improve generalisation. RT-2 was able to generalize shockingly well to objects, environments and tasks that were not in the human demonstration data. This is what makes the Taylor Swift demo so impressive. The robot control training data definitely did not include Taylor Swift. So, for RT-2 to solve this task, it had to learn how to bring together abstract concepts it had learned in its internet-scale pretraining with the robot control episodes. This means that these models can learn to connect the vast amounts of image, video and text data on the internet with real-world actions, potentially harnessing the full knowledge of the internet into robot brains.

This is why this demo is such a big deal. It answers the question, can large language models be trained to be robot brains? With a shaky, but definitive, yes. The RT-2 team coined a new name for this type of model, vision-language-action, or VLA, linking together vision, language and action into a single unified model.

That brings us to Open X-Embodiment and RT-X.

Open X-Embodiment and RT-X: Learning across robots

RT-2 showed that knowledge from web-pretrained VLMs could transfer to robot actions. But what about transferring experience** between different robots?** If one robot learned to pick up an object, could its demonstrations help another robot perform the same task?

Open X-Embodiment brought together 21 institutions to pool over 1 million robot trajectories across 22 robot embodiments and 527 skills.

The challenge was that different robots have different cameras, action spaces, and control systems. To make the datasets compatible, researchers standardized camera observations and converted actions into a common seven-dimensional representation: three translations, three rotations, and gripper opening. However, differences in coordinate frames and control conventions still remained.

They trained the existing RT-1 and RT-2 architectures on a mixture of data from nine robot embodiments, producing RT-1-X and RT-2-X.

The results were impressive. On skills absent from Google's own robot demonstrations but present in other robots' datasets, RT-2-X achieved 75.8% success compared to RT-2's 27.3%. This showed that experience could transfer across different robot embodiments.

What I found interesting was that more data didn't always help. The smaller RT-1-X struggled to fit the diverse training mixture and sometimes performed worse than policies trained on individual robots. So, simply pooling more demonstrations wasn't enough but the model also needed sufficient capacity to learn from them.

This raised another question: Could we build a pretrained robot policy that could be easily adapted to new robots, camera setups, and action spaces?

That's the gap that Octo aimed to fulfill

Octo: Making robot policies adaptable

RT-X showed that experience from different robots could improve a shared policy. But what if we wanted to use that policy on a new robot with different cameras or action commands, without training everything from scratch?

Octo is an opensource generalist robot policy pretrained on 800k robot demonstrations from 25 Open X-Embodiment datasets. They released two versions: Octo-Small(27M parameters) and Octo-Base(93M parameters). It takes camera observations and either a language instruction or a goal image, i.e. an image showing the desired result.

THere are various architectural changes compared to previous models. Octo consists of input encoders + Transformer + diffusion action head. First, they use a pretrained T5 language encoder(converts instructions into semantic vectors) to convert instructions into embeddings. A CNN converts camera images and goal images into patch tokens. Both of these tokens are passed together through the transformer.

They also add special learned tokens called readout tokens. These gather information from the instruction and camera observations inside the Transformer, and the action head uses their output to predict robot commands. Octo’s design also lets them add new inputs or change the action head during fine-tuning while keeping the pretrained Transformer weights.

Unlike RT-1 and RT-2’s discrete action tokens, Octo uses a diffusion head to generate continuous action chunks. Why? For the same scene and instruction, there can be multiple valid movements. Eg, to reach a cup behind an obstacle, the robot could move around either side. Directly predicting one action sequence using mean squared error can average these alternatives and produce a movement towards the obstacle. Diffusion can represent multiple possible action sequences and generate a sample rather than average them. It starts with random noise and gradually denoises it into a sequence of robot commands, conditioned on the Transformer’s output. One interesting detail i noticed is that the Transformer runs only once per prediction while the repeated denoising happens inside the smaller action head.

The evaluation was done across nine real-robot setups. After finetuning with 100 demos per task it acheived 72% average success across six setups compared to 20% for their policy trained from scratch.

So now with octo we can use the pretrained policy on other robots. i.e. with enough demonstrations and fine tuning, we can use the policy on robot with different wrist camera or end-effector commands. OpenVLA: An open-source VLA

OpenVLA is a 7B-parameter open-source VLA trained on 970k robot demonstrations from Open X-Embodiment. It consists of a visual encoder + projector + Llama 2 language model. They start with the pretrained Prismatic-7B VLM, which uses two vision encoders: SigLIP and DINOv2. The image is passed through both encoders and their features are combined. Basically, SigLIP provides features learned from image-language matching, while DINOv2 adds useful spatial information. A small MLP projector converts these combined features into embeddings which LLM can process.

The model predicts a 7-component action: 3 translation, 3 rotation and 1 gripper command. Unlike Octo’s diffusion-generated action chunks, the original OpenVLA predicts one action at a time with autoregression(similar to RT-2). These tokens are decoded into numerical commands executable for model and it gets new image for next prediction.Each action is discritized into 256 bins and clipped 1st-99th percentile. Here they have reused the last 256 tokens of LLama's vocab as action tokens.

While evaluating across 29 tasks on WidowX and Google robots, OpenVLA outperformed the much larger 55B RT-2-X by 16.5 percentage points in average success. But this includes difference in training data hence cannot generalize anything. But OpenVLA did not outperform RT-2-X everywhere. RT-2-X was better at performing different semantic tasks requiring internet concepts absent from the robot demonstrations such as Taylor Swift example. Unlike OpenVLA’s robot training did not retain web vision-language data unlike RT-2-X’s co-fine-tuning. So, interestingly, better robottask performance does not automatically mean better retention of the VLM’s web knowledge.

By early 2024, a number of key members of the RT2 team had left Google and reassembled to form the startup physical intelligence. In October of that year, the team demoed their first robot brain, Pi Zero. Compared to the RT2 Coke can Taylor Swift demo 15 months before at Google, Pi zero is remarkable. It starts to really feel like a robot that could help you around the house, performing tasks like getting laundry out of the dryer, folding the laundry, and cleaning up tables. How was the physical intelligence team able to improve on RT2 so significantly and so quickly? Like RT2, Pi Zero is a vision language action model built on top of a pre-trained multimodal LLM. Based on Pi Zero's strong performance, you might guess that the physical intelligence team increased the model size relative to RT2, but Pi Zero is actually smaller.

Each action is discritized into 256 bins and clipped 1st-99th percentile. Here they have reused the last 256 tokens of LLama's vocab as action tokens.

While evaluating across 29 tasks on WidowX and Google robots, OpenVLA outperformed the much larger 55B RT-2-X by 16.5 percentage points in average success. But this includes difference in training data hence cannot generalize anything. But OpenVLA did not outperform RT-2-X everywhere. RT-2-X was better at performing different semantic tasks requiring internet concepts absent from the robot demonstrations such as Taylor Swift example. Unlike OpenVLA’s robot training did not retain web vision-language data unlike RT-2-X’s co-fine-tuning. So, interestingly, better robottask performance does not automatically mean better retention of the VLM’s web knowledge.

By early 2024, a number of key members of the RT2 team had left Google and reassembled to form the startup physical intelligence. In October of that year, the team demoed their first robot brain, Pi Zero. Compared to the RT2 Coke can Taylor Swift demo 15 months before at Google, Pi zero is remarkable. It starts to really feel like a robot that could help you around the house, performing tasks like getting laundry out of the dryer, folding the laundry, and cleaning up tables. How was the physical intelligence team able to improve on RT2 so significantly and so quickly? Like RT2, Pi Zero is a vision language action model built on top of a pre-trained multimodal LLM. Based on Pi Zero's strong performance, you might guess that the physical intelligence team increased the model size relative to RT2, but Pi Zero is actually smaller.

How should a robot predict its next move?

So far, we've seen two approaches to action prediction: discrete action tokens in RT-2 and OpenVLA, and continuous action chunks generated through diffusion in Octo.

But for more dexterous tasks requiring precise, high-frequency movements, could we combine the semantic knowledge of pretrained VLMs with continuous action generation?

π0

I have seen people talk about this particular model a lot on twitter and that for a good reason. I saw a demo of π0 cleaning a table where it sometimes stacked dishes before moving them. which means it did not always pick up objects one by one. Similarly for laundry folding, with every fold the observation changes so it needs to keep it updated. So it is obvious that these policies used used task-specific post-training, so the skills did not come from the pretrained VLM alone.

π0 is a VLA model by Physical Intelligence which combines a pretrained VLM with an action expert to generate continuous robot commands. It consists of PaliGemma + an action expert. PaliGemma is a pretrained 3B-parameter VLM and the action expert is around 300M parameters.The model takes camera images, a language instruction and robot state such as joint angles and predicts a chunk of 50 future actions.

Instead of predicting discrete action tokens like RT-2 and OpenVLA, they add a smaller Transformer called the action expert. It follows Gemma’s architecture but is narrower and randomly initialized. It uses robot state and information from the VLM with attention to generate continuous movement commands.

The action expert uses flow matching to predict a chunk of 50 future actions. Basically, it starts with random noise and repeatedly updates it actions with images, instruction and robot state as input. All these refinement steps happen inside the model, and finally robot only executes these commands.

π0 combines VLM pretraining with continuous action generation, but producing each chunk still requires repeated refinement steps. Also, predicting 50 actions together does not mean every action uses a fresh observation. So now how much of the chunk gets executed before predicting again is also a choice, I have done some fun experiments with this which I will write in a separate blog!

SmolVLA

After reading all the above models with huge parameters, SmolVLA seemed the one we can actually use for finetuning because of it's size. SmolVLA has around 450M parameters(roughly 1/16th of openVLA). It's real-world base model was pretrained on fewer than 30k episodes from publicly shared community datasets.

Here they use SmolVLM2, a combination of SigLIP image encoder with the SmolLM2 language model. It also uses flow matching like π0 and outputs continuous action chunk.

One interesting choice is that they use only the first half of the VLM’s language decoder layers and reduce each image to 64 visual tokens. Basically, they do not need the complete language model to finish processing before using its features for movement.

They have used asynchronous inference setup. Normally, the robot might finish its queued actions and then wait for another prediction. Here, it requests the next chunk while still executing the current one which roughly doubles task throughput and reduces waiting time. But the queued actions are based on earlier observations, and not the fresh image at every step.

I have done some experiments with LIBERO-trained SmolVLA checkpoint for finding out how changing instruction affects the behaivior which I will include in next blogpost.

MolmoAct

MolmoAct

While reading MolmoAct, I was reminded of the object navigation work I did during my internship. The methods are different, but both make spatial information explicit rather than expecting the model to learn everything implicitly.

Most VLAs directly map observations and instructions to actions. MolmoAct instead introduces three stages: predicting depth, generating a visual trajectory, and finally producing robot actions.

For depth, they use Depth Anything v2 and a VQ-VAE to compress depth maps into a 10 × 10 grid of discrete tokens. These provide training targets, allowing MolmoAct to predict depth directly from camera images without running the depth estimator during inference.

Next, it predicts up to five image-space points describing the intended end-effector path, followed by a chunk of eight discretized robot actions.

What I found interesting was that we could now inspect the predicted depth and intended movement instead of only observing the final action. However, generating these intermediate tokens increases inference latency, and a reasonable-looking trajectory doesn't necessarily guarantee correct execution.

MolmoAct 2 builds on this with improved spatial reasoning, adaptive depth prediction, and a continuous flow-matching action expert, making the approach considerably faster and more practical.

Open Problems

After reading these papers, I keep coming back to the idea that demonstrations can teach a robot where to start, but it should also be able to learn from its own mistakes. Most VLAs discussed here are trained primarily through imitation learning. RL could take these pretrained policies further by using feedback from actual interactions to improve their behavior. Of course, collecting experience on real robots is expensive, and designing good reward signals isn't straightforward. So I don't see VLAs and RL as separate directions. One provides a policy, while the other offers a way to improve it through experience.

I'm also interested in combining VLAs with world models. Instead of just predicting the next movement, what if the model could also predict what would happen after executing it? This could allow robots to compare possible actions, plan ahead, or even learn from imagined rollouts. However, inaccurate predictions could lead to incorrect decisions, and the additional computation might make the robot slower to react.

I don't know what the final architecture will look like, but my intuition is that learning from demonstrations, predicting consequences, and improving through experience will all have a role to play. To me, the intersection of these ideas is one of the most interesting directions in robot learning, and something I'd like to explore further.

Conclusion

I started writing this blog to understand how VLAs evolved and update my own world model of robot learning. Going from SayCan's language-based planning to RT-1's unified policies, RT-2's web knowledge transfer, and eventually models like π₀ and MolmoAct, it's clear that the field has made substantial progress in a relatively short time.

But I'm not convinced there's a single winning approach yet. Different architectures make different trade-offs between generalization, action precision, inference latency, and the amount of robot data required. And while the demos have become much more impressive, there's still a considerable gap between performing a task successfully and doing it reliably in an uncontrolled environment.

The part I enjoyed most was exploring some of these trade-offs myself. Even the small discretization experiment showed how choices such as bin count and action range can significantly affect the commands a model produces.

.I've been exploring how action chunk sizes and replanning affect execution, along with how models like SmolVLA respond to changes in language instructions. I'll share the setups, results, and failures I encountered along the way.

If you've worked on similar problems or have suggestions for interesting experiments, I'd love to hear them!

Thanks for reading, hope you had as much fun as I had writing it.