Asimov v1 is a 1.2-meter tall, 35-kilogram humanoid robot designed to be both open-source and highly capable with 25 actuated degrees of freedom. What sets this project apart is its dual-compute architecture that separates media and network handling from real-time motion control, alongside a detailed MuJoCo simulation model that enables developers to test locomotion policies and control algorithms before deploying on physical hardware.
Asimov v1: a modular humanoid robot platform with multi-bus CAN and dual-compute control
At the core, Asimov v1 offers a complete open-source hardware and simulation package. The mechanical design is split into seven subassemblies, carefully engineered with 7075 aluminium and MJF PA12 nylon components for a balance of strength and weight. This leads to a robot that weighs 35 kg and stands 1.2 m tall, with impressive actuation capability — 25 actuated degrees of freedom plus 2 passive ones.
The electrical design includes wiring harnesses, schematics, and PCB layouts, reflecting the complexity of managing such a robot. Communication and control rely on a CAN bus architecture featuring six buses: five running at 1 Mbps and one at 500 kbps. This multi-bus setup allows for distributed control and sensor data aggregation without bottlenecks.
A notable architectural choice is the dual-board compute system. A Raspberry Pi 5 handles media processing and networking, while a Radxa CM5 board is dedicated exclusively to real-time motion control. These boards communicate over the CAN buses, enabling separation of concerns between high-level coordination and low-latency motor control.
The project also includes a MuJoCo simulation model, which is valuable for developing and testing control policies in a physics-accurate virtual environment. This simulation mirrors the robot’s kinematics and dynamics, providing a platform for reinforcement learning or classical control algorithm development without risking hardware damage.
Technical strengths and design tradeoffs in hardware and simulation
The dual-compute architecture is arguably the standout feature here. By isolating the media/network stack from motion control, the system reduces jitter and latency issues that would otherwise arise if a single processor handled both tasks. This design choice is common in production robotics but less frequently seen in open-source projects due to complexity.
The use of multiple CAN buses at different speeds is another practical engineering tradeoff. CAN is reliable and well-understood for real-time control, but bus bandwidth can limit scalability. Splitting communication over six buses balances throughput and real-time constraints, albeit at the cost of increased wiring and system complexity.
From a materials standpoint, the choice of 7075 aluminium for structural components is a solid engineering decision balancing stiffness and weight. Nylon parts made with Multi Jet Fusion (MJF) provide lightweight, durable components where metal isn’t necessary. This hybrid approach is typical in advanced robotics to optimize the mechanical footprint.
The MuJoCo simulation is a significant asset. It is well-integrated with the physical design, allowing for realistic testing of locomotion and manipulation. This reduces iteration time and hardware wear. However, MuJoCo is proprietary software, which may limit accessibility for some developers. Also, while the simulation is detailed, real-world factors like sensor noise and unmodeled dynamics always impose a gap between sim and reality.
The project targets a DIY kit price of around $15,000, which is reasonable for a humanoid robot at this scale but still a barrier for hobbyists. The roadmap mentions an Asimov API, locomotion policy, and mobile app, indicating plans to improve usability and software ecosystem, which will be critical for adoption.
Explore the project: documentation and repo structure
Without specific installation or quickstart commands in the README, the best way to engage with Asimov v1 is to start with the comprehensive documentation and the repo structure. The GitHub repository includes CAD files for mechanical subassemblies, electrical schematics, PCB designs, and the MuJoCo simulation model.
Key directories to explore:
- Mechanical CAD: Contains detailed subassembly files in standard CAD formats. Useful for understanding the robot’s build and for customization.
- Electrical CAD: Includes wiring harness layouts, schematics, and PCB files, critical for anyone replicating or modifying the electronics.
- Simulation: The MuJoCo model files that replicate the robot’s kinematics and dynamics.
- Firmware and Control: Source code for the embedded controllers running on the Radxa CM5 and Raspberry Pi 5. This code handles motor control, sensor integration, and CAN bus communication.
The README and associated docs outline the robot’s specs and provide a bill of materials for self-sourcing components. While the full build is non-trivial, the documentation is thorough enough for developers with hardware and robotics experience.
Verdict: a detailed open-source humanoid for robotics practitioners and researchers
Asimov v1 offers a robust starting point for anyone interested in humanoid robotics with real-time control and simulation capabilities. The dual-board architecture and multi-bus CAN setup demonstrate thoughtful engineering aimed at real-world performance rather than just proof-of-concept.
That said, the complexity of the build and the cost put it out of reach for casual hobbyists. Its biggest strength is the combination of detailed mechanical and electrical design with a simulation environment, facilitating iterative development and testing.
This project is best suited for robotics researchers, advanced hobbyists, and developers working on control algorithms who want a tangible platform to test and deploy their work. The roadmap towards an API and locomotion policies suggests that software usability will improve, increasing the project’s accessibility over time.
For those interested in humanoid robot development, Asimov v1 is worth studying for its architecture choices and practical design tradeoffs, especially the dual compute and CAN bus approach that are common in professional robotics but less often published openly.
Related Articles
- Inside CowAgent: An extensible autonomous AI assistant with multi-modal and multi-model architecture — CowAgent is an extensible AI assistant framework with autonomous task planning, long-term memory, and multi-modal suppor
- CrewAI: A lean Python framework for orchestrating autonomous AI agents with precise control — CrewAI is a Python framework for autonomous AI agents emphasizing speed, flexibility, and precise control through ‘Crews
- Inside AI Engineering Hub: a hands-on collection of production-ready AI projects — AI Engineering Hub offers 90+ production-ready AI projects spanning LLMs, RAG, AI agents, and MCP, organized by difficul
- A-MEM: dynamic semantic memory management for LLM agents inspired by Zettelkasten — A-MEM is a Python agentic memory system that dynamically organizes LLM agent memories using semantic embeddings and auto
- CopilotKit: Building dynamic agentic UIs with the AG-UI protocol — CopilotKit introduces the AG-UI Protocol, enabling AI agents to dynamically render and update UI components in React app
→ GitHub Repo: asimovinc/asimov-v1 ⭐ 471 · Shell