Dream Labs and Hardware Agnosticism
Dream-1 takes the foundation-model API playbook into robotics. A look at its world-action architecture, founders, the hardware-agnostic parallel in AI chips, and the physical-world constraints.

Dream Labs recently came out of stealth with $90 million in seed funding and Dream-1, a robot foundation model accessible through an API starting at $3/hour. The pitch is pretty interesting: connect a robot the model has never seen, give it a task, and potentially get it working without collecting new training data or fine-tuning.

Hardware agnosticism is one of the concepts I've been particularly interested in lately. The idea is simple: intelligence shouldn't have to be built from scratch for every machine. We've already seen versions of this in cloud computing and AI chips, but applying it to robots is a different challenge. Software can be copied and updated easily; physical machines have different bodies, mechanical limits and real-world consequences when things go wrong.
Dream Labs: One AI model for different robots
Most robots are still highly specialised. A robotic arm might be excellent at sorting components in one factory but require extensive programming or new training data to perform a different task. Move that same AI model to a robot with different joints, motors or sensors, and much of the work may need to be repeated.
Dream Labs wants to make robot intelligence more reusable. Instead of building a separate AI system for every robot, developers can access Dream-1 through an API and connect it to supported hardware.
How does Dream-1 actually work?
Dream-1 builds on DreamZero, research developed at NVIDIA's GEAR Lab. It uses a World Action Model (WAM), which learns to predict both robot actions and how the physical scene changes as those actions unfold.

Traditional Vision-Language-Action (VLA) models generally work like this:
Camera image + instruction → Robot actionFor example, show a robot a cup and ask it to pick it up. The model predicts how to move its arm.
A World Action Model takes this further:
Current scene + instruction → Predicted future scene + robot actionsIt doesn't just learn what movement to make. It also learns to predict how the scene might change as the robot acts. DreamZero uses video prediction to help learn these relationships.
Dream-1 turns that research into an accessible system. Its control pipeline can be understood in three parts:
First, the AI decides what to do. Dream-1 receives camera observations, the robot's current state and a task instruction. It generates a sequence of actions, with each API response covering roughly 1.6 seconds of movement.
Second, the robot translates those actions into its own movements. Instead of predicting every motor angle directly, Dream-1 uses a shared end-effector action space. An end-effector is simply the part of the robot interacting with the environment, such as its gripper. The model predicts where that gripper should go, while an inverse kinematics (IK) solver calculates how the robot's individual joints should move to get there.
Think of telling two people to pick up the same cup. The goal is identical, but their arms don't necessarily move in exactly the same way.
Third, a small local controller handles fast execution. According to the team's technical discussions, Dream Labs also uses a lightweight neural controller called System 0, with around 100,000 parameters, running at 250 Hz. That's one motor-control update every 4 milliseconds. The larger model handles action generation, while the smaller local controller helps execute them without relying on the cloud for every tiny motor adjustment.

This combination is what makes the architecture interesting: a reusable AI model, hardware-specific translation and fast local control.
How good is it?
Dream Labs reports testing Dream-1 on 27 previously unseen robots in simulation and additional real-world configurations. In the independent RoboCurve evaluation, it achieved 59.3% average task progress on RoboDojo-RC Tier 1, outperforming the other models tested at the time on that metric.

But importantly, 59.3% progress isn't a 59.3% task-completion rate.
The company also offers Fine-tuning-as-a-Service (FaaS). Some unfamiliar robots improved substantially after just five minutes of additional demonstrations, while more different configurations required considerably more data.

Fine-tuning improved performance on ten of twelve robots in its beta evaluation.
So, hardware-agnostic doesn't mean universally plug-and-play. At least not yet. Still, moving from robot-specific training pipelines to reusable intelligence that can be accessed for a few dollars per hour is an interesting shift.

Who's behind Dream Labs?
Dream Labs was founded in 2026 by four researchers and engineers with backgrounds across NVIDIA, Google DeepMind and the robotics research community.

Joel Jang - Co-founder and CEO
Previously worked on NVIDIA's GR00T robotics research programme and helped develop DreamZero, DreamGen and related world-model research. His academic background spans language models and robotics, including research at KAIST and the University of Washington.
Yunhao Ge - Co-founder and CTO
Previously led video-model research within NVIDIA's GR00T programme and contributed to the Cosmos family of world models. He holds a computer science PhD from USC and has worked on computer vision research at Stanford.
Scott Reed - Co-founder and Chief Scientist
Previously spent eight years at DeepMind, where he led the development of Gato, an early generalist agent trained across language, vision, games and robotic tasks. He later worked on NVIDIA's GR00T programme.
You Liang Tan - Co-founder and Chief Product Officer
Has a background in mechanical engineering, robotics software and machine learning. His previous work spans ROS 2, Open Robotics, Berkeley's RAIL Lab and NVIDIA's open-source robotics initiatives.
It's an interesting combination: world-model researchers, generalist AI expertise and people who understand the unglamorous engineering required to make real robots work. Dream Labs' $90 million seed round was led by B Capital, with participation from Kindred Ventures, A.Capital, Unusual Ventures and others.
The company is essentially betting that robotics will develop a reusable intelligence layer, rather than requiring every manufacturer to build its own AI stack from scratch.
Hardware agnosticism: beyond robots, into chips
Hardware-agnostic software can work across different hardware configurations. Computing already uses several forms of this abstraction: operating systems hide hardware details from applications, virtualisation provides software-defined computing environments, and cloud APIs let developers access large models without managing the GPUs behind them.
The same principle is increasingly relevant to AI accelerators.
The semiconductor parallel
AI software often depends heavily on its hardware. NVIDIA’s CUDA ecosystem illustrates this: specialised kernels, memory management and compiler tools help developers optimise workloads for NVIDIA GPUs, but can make transferring them to another accelerator difficult.
The ambition is to let developers run a model across NVIDIA GPUs, AMD GPUs, Google TPUs, AWS Trainium and other accelerators without rebuilding the entire software stack. Several projects address different parts of this challenge:
- OpenXLA provides compiler infrastructure that translates machine-learning computations into instructions optimised for particular hardware.
- ONNX Runtime uses hardware-specific execution providers to run supported models across different processors.
- Modular’s MAX aims to offer a more unified programming and inference environment across different types of computing hardware.
These tools handle more of the low-level work, giving developers a common interface while retaining hardware-specific implementations.
There is a useful parallel with Dream Labs. A compiler representation or runtime can separate a model’s computation from a particular accelerator. In robotics, a common action format and control interface can separate learned behaviour from a particular arrangement of joints.
Portability shifts the responsibility for handling hardware differences to another layer. A model running on both NVIDIA and AMD GPUs may perform differently because of memory bandwidth, supported operations and compiler optimisations. Similarly, robots receiving the same instruction may differ in arm length, motor strength, sensor accuracy and gripping ability. Abstraction makes those differences easier to manage; they still shape the result.
Why this matters commercially
More portable software could lower switching costs and reduce dependence on particular hardware vendors. Robot manufacturers could focus on motors, actuators, sensors and mechanical design, while specialist AI companies provide intelligence. Developers choosing chips could place greater weight on performance, cost, energy efficiency and availability, with fewer constraints imposed by software compatibility.
However, the abstraction layer can create dependencies of its own. Applications may become closely tied to a platform’s APIs, tools or deployment environment. Hardware agnosticism can therefore shift control towards the software provider, making the openness and portability of that layer commercially important too.
The physical world is much less forgiving
The original has enough information. My last version cut useful details about standards, updates and costs. This version keeps those points while tightening the wording.
Different machines have different limits
A shared action format cannot fully account for differences in reach, joint limits, gripping force, payload, friction and sensor accuracy. Two arms given the same gripper target may have different abilities to reach it safely while holding a glass.
Dream-1 relies on each robot’s inverse kinematics software to translate targets into joint movements. Its shared interface offers less control over the arm’s exact path, so hardware-specific controls and adaptation remain necessary.
Cloud access brings practical trade-offs
Dream-1’s API provides access to powerful models without equivalent onboard computing. However, network delays, outages and late responses can disrupt physical tasks. Average response time does not establish whether a system consistently meets its deadlines.
A hybrid design can keep fast control, safety monitoring and fallback behaviour on the robot while sending less time-sensitive work to cloud models. The balance depends on the application, available computing power and operating environment.
Dream-1’s advertised $3 per hour covers inference. Hardware, integration, connectivity, maintenance, supervision and safety engineering add to the total cost. As smaller models improve, onboard processing could become more attractive for some workloads.
Generalisation and reliability are different tests
Generalisation means handling unfamiliar tasks or hardware. Reliability means performing consistently under relevant operating conditions.
Picking up a new object demonstrates capability. Repeating it thousands of times despite changing light, sensor noise, wear and obstacles requires further engineering. Operators need evidence about failure rates, recovery mechanisms and behaviour under difficult conditions.
Model updates can also alter behaviour that customers have already validated. Deployments therefore need controlled releases, version tracking and renewed testing where changes affect operation.
Safety, responsibility and security must be built in
Physical AI must meet requirements appropriate to its application and location. Industrial robot standards such as ISO 10218 address robots and their integration into working systems, while consumer and medical applications face different requirements.
When one model controls many machines, responsibilities must be clear across the model provider, manufacturer, integrator and operator: who validates behaviour, manages updates and responds to failures?
Sensitive factories, laboratories and other sites may also restrict external processing of camera feeds and operational data. Deployment needs access controls, appropriate data handling and dependable safety measures.
Dream Labs describes Dream-1 as a research beta that has not been validated for safety-critical use. Its ability to transfer across robots is promising, but dependable deployment still requires substantial engineering.
Where does this go next?
I see hardware agnosticism leading towards more modular systems. Robot makers could combine shared models with their own hardware, application-specific training and local safety controls. Developers could choose processors based on cost and performance while reusing more of their software. Both approaches reduce the work required when hardware changes, creating opportunities for model providers, compilers, integration tools and deployment platforms.
Deployment could also support improvement. OpenAI’s early models were imperfect, and real-world feedback helped identify weaknesses and guide further development. Dream Labs is pursuing a similar loop: useful robots generate experience that can improve future models. But robotics requires stronger safeguards, and progress depends on relevant, permissioned data and careful validation.
For Dream Labs, would love to watch how well capabilities transfer to unfamiliar robots, how reliably they perform over time and how much setup each deployment requires. Hardware will retain its physical limits, but intelligence could become much easier to carry between machines.


