Closed loop without context switching
A traditional robotics project pipeline is split into isolated stages: first, demonstrations are collected on real or simulated hardware, then the data is transferred to a separate system for training, and after that, the trained model needs to be deployed back onto the robot. Each transition requires format conversion, manual synchronization, and environment setup. As a result, a lot of time passes from recording the first episode to running the policy, and any changes to the data become a separate operation.
The new approach, presented by the AWS team in August 2026, closes this loop in one place. Instead of several disconnected tools, a single agent is proposed that can record demonstrations, send them to cloud storage, train a model on them, and return an updated checkpoint to the robot. The key idea is not to transfer data between systems, but to work with it in a streaming fashion, directly from storage.
Agent tools and SDK
The foundation of the solution is Strands Robots — an open SDK from AWS distributed under the Apache 2.0 license. It provides robotics abstractions, simulation, and the LeRobot stack as a set of AgentTools. These tools are composed into a single Strands agent: the robot, simulator, and data processing become interchangeable modules.
The central Robot() factory resolves a name against a registry of supported devices. The registry includes manipulators, humanoid robots, mobile bases, and standalone arms. One of the available configurations is SO-100, a lightweight manipulator often used for experiments. Thanks to this registry, the same code works with both simulation and a real device: you only need to change the mode parameter.
The agent receives a command in natural language, such as "record a demonstration and sync it to a bucket," and calls the appropriate tool itself. This allows building complex scenarios without a hardcoded sequence of steps — control logic is delegated to the language model, while the SDK handles low-level operations with the robot and data.
Unified data format
An important detail is the LeRobot dataset format. At the time of publication, more than 90,000 datasets and models on Hugging Face Hub already use this format, published by over 8,000 different authors. Thanks to this adoption, LeRobot has become the de facto standard for storing robotics demonstrations.
A recording made through Strands Robots is saved directly in the LeRobotDataset format. This means any tool that can read LeRobot can work with this data without any conversion. There is no need to write separate converters for each backend: the data is read equally well in training scripts, visualization tools, and other robotics frameworks.
Streaming storage
For storing large volumes of demonstrations, Hugging Face Storage Buckets is used — a new type of object storage introduced in March 2026. Unlike regular dataset repositories, a bucket is mutable, non-versioned storage built on Xet technology. This provides two important advantages: writing and updating data without creating new versions, and efficiently transferring only changed bytes during synchronization.
The bucket lives in the same hf:// namespace as regular datasets, so the familiar hf CLI is used to work with it. Data can be streamed directly from storage without downloading the entire dataset. For large demonstration videos, this is critical: there is no need to wait for a full download to start training.
The data loop in practice
To understand how all this works together, let's look at an example from the official AWS blog, where the Strands Robots, LeRobot, and Hugging Face Storage Buckets stack is used for a full loop. An agent with a robot tool is created, with simulation mode active by default:
python from strands import Agent from strands_robots import Robot
sim = Robot("so100") agent = Agent(tools=[sim])
The agent can be given a command in natural language: "record a pick-the-cube demonstration and sync it to the my-org/robot-fave repository." The command is not parsed by a predefined template — the agent's reasoning model determines the sequence of actions itself: start recording, form a dataset, and send it to the bucket.
python agent("Record a pick-the-cube demo and sync it to my-org/robot-fave.")
Synchronization is designed so that on repeated runs, only changed bytes are uploaded — there is no need to rewrite the entire dataset. After the demonstration is saved, the same Robot() object can stream the dataset back. Inside the stream_dataset() method, data is read frame by frame, video is decoded on the fly, and therefore no local copy of the dataset is required.
python for batch in sim.stream_dataset( "my-org/robot-fave/cube_pick", repo_type="bucket", ).dataloader(batch_size=64): ...
This code can be used directly in the training process: batches come from storage, the model is trained, and then the prepared checkpoint is deployed on the same Robot() — for this, you only need to change one keyword argument. Demonstrations recorded on real hardware are returned to the same bucket in the same way and become available for the next training iteration. The result is a continuous loop: data is collected, the model is trained on streaming data, the updated policy is rolled out to the robot, and the process repeats.
Requirements for running
To reproduce the experiment, you will need Python 3.12 or newer and Linux or macOS. On Apple Silicon, the MuJoCo backend is supported for simulation. The package is installed with the command:
pip install "strands-robots[sim-mujoco,lerobot]>=0.5.1"
Additionally, the lerobot set is included, which includes LeRobot (at least version 0.6.1), the datasets, av, and torchcodec libraries. To run the agent, one of the supported model providers is required: Amazon Bedrock with configured AWS credentials, Anthropic API, OpenAI, or local Ollama. Having this choice allows experimenting both in the cloud and fully locally.
A runnable companion is available alongside the article — the notebook examples/notebooks/05_streaming_data_loop.ipynb, which reproduces the entire described loop. It is a convenient starting point to see the Strands Robots, Hugging Face Storage Buckets, and LeRobot stack in action.
Conclusions
The main result is the ability to package the entire robotics policy development loop into a single circuit. Recording, storage, training, and deployment use the same abstractions and formats. This radically reduces the number of "glue" steps between stages and simplifies experimentation: to change the data, you only need to update the demonstrations in the bucket, and to update the policy, you simply retrain the model on streaming data and change one argument when creating the robot.
