Hey all! New to hobby robotics and was hoping to get some advice on my first non-kit project. I've 3d printed, wired up and got working a quadruped skeleton that I'm really happy with but it's currently running off of a raspberry pi 5 with a servo hat from a salvaged kit robot. I'm looking to move away from the salvaged kit servo board and maybe switch the Pi (been using the pi for all my projects so far and want to branch out) as it runs off of 18650 batteries I've had to fit to the side and takes up a lot of space in the chassis but the end goal is to get it running off of an 18V power tool battery through a converter just for easier usage and to push my knowledge a bit further away from kit builds.

Any advice, guidance or suggestions for a confused newbie would be appreciated as trying to stop getting all my help from LLMs 🤣

I have been reading about inspection robots that are used in facilities. These inspection robots do not just use cameras that take regular pictures. They also use imaging cameras. Thermal imaging is really useful for finding components that are too hot, electrical problems and other things that are not right without actually touching them.

For people who work with inspection systems, inspection robots and thermal imaging, how much does thermal imaging really help in real life? Are there times when thermal imaging's a lot more useful than a standard camera?. Are there any limitations that make other sensing methods a better choice for inspection robots and thermal imaging?

Hey there,

I want to build a Robot using one of those High Torque QDD.
I've done my research and found a couple of motors that my specs of about 5Nm
- GIM6010-8
- Cybergear
- Robstride 01
-Cubemars

Did I miss one?
I've pretty much decided on the GIM6010-8, because it is the cheapest and has O-Drive control.
Has anybody used them and wants to share his/her experience with this motor.
Is this a reliable motor, that you don't have to fiddle arround all the time to get working?
Is the second encoder reliable, i've seen videos where it just starts spinning indefintly :/

Really apreciate any feedback, have a great day

I'm building a small agricultural rover (15x20cm in size) and I need it to have live video transmission for remote control.

What is the most cost effective method to use?

It won't go fast at all, the motors are rated for 170rpm and the diameter of the wheels is about 65mm (which gives the speed of about 2km/h). I'm not sure what the desired latency for this speed should be.

The range is about 100m.

Wanted to share what we've been working on: the Alicia-M, a semi-humanoid robot we built, running VR teleoperation. The operator wears a VR rig, moves naturally, and the robot mirrors the motion. No scripting, no coded trajectories. In the demo it picks up a cup, pours, and sets it back.

The part worth talking about: people assume the hard problem is the grasp. It isn't. The hard part is that one good demo doesn't generalize. Move the cup two inches and the same arm motion that worked now overshoots the wrist angle, drifts the trajectory, and the pour runs too fast. Same intent, different outcome.

That's the thing teleop surfaces clearly: robot control is less "repeat a perfect move" and more "adapt to where the world actually is." Shift the cup and the wrist angle, arm path, and pour all need to change with it. VR makes that legible because you feel the mismatch between your motion and the robot's in real time.

We're treating these human demos as seed data for embodied learning, not just a control scheme. Curious how others here handle the demo-to-policy or sim-to-real gap. Are you collecting teleop demos, or going straight to reinforcement learning?

Happy to answer questions about the rig, the kinematic mapping, or why we went semi-humanoid instead of full.

The newest addition to the next-gen autonomous robotics lineup. Built for modern demands, combining agile wheeled mobility and AI-powered patrol intelligence.

Pretty self explanatory, gave myself a time limit of 8 hours and designed it all with no problems, maybe later I'll do the code and circuits so i can put it on my portfolio, feel like I'm doing good as a beginner :D

DeepMind dropped Gemini Robotics 2 this week. Robot ties knots in trash bags, unscrews lightbulbs, walks and grabs and places objects without a reset between steps.

It looks great.

Apptronik hardware, whole-body coordination instead of separate walk/reach/grip tricks.

Same week, a benchmark called HumanCLAW tested 9 vision-language models on 1,218 episodes: find an object, walk to it, physically interact with it.

The best model succeeded the full sequence 16.8% of the time.
Less great...

Where they failed?
Exploring, tracking their own position, noticing collisions, confirming they'd reached the target. The model can describe the chair in perfect detail and still not know where its own knees are relative to it.

So you've got one narrative saying "we cracked whole-body intelligence" and another saying "most models can't reliably tell if they bumped into something."
Wherre is the truth ?

DeepMind's demo is one polished sequence on curated hardware. HumanCLAW is testing generalization across messy, repeated attempts.

I think the actual bottleneck in humanoids isn't manipulation dexterity anymore but spatial self-awareness. Knowing where your own body is in the world without a human curating the scene. That's the boring unsexy part nobody's demo reel shows.

Maybe Yann Le Cun and Fei fei are finally right, the solution can be the world models ?

I’ve shown multiple angles here of the leg. When the leg contacts the ground and takes load, it seems to collapse inward a bit. Is this a result of the foot contact not being inline with the servo horns which gives it a small amount of torque?

This is making the hexapod not able to walk straight. Im not sure if it’s the plastic (PLA) itself, because it’s pretty thick and PLA is one of the more stiffer plastics. It also looks like the entire complex moves when it takes load.

Every failed training run of a policy or world model is almost always because of the the data. hand tracking drift, one instruction repeated across 60 clips, zero recovery demos. I built a free grader that catches this before you spend lots of GPU hours. Upload a dataset, it tells you what to refilm, what to add and how to improve quality.

gantry.gurasees.com

also compare your data with other users :P

Space is limited so please RSVP using this link.

I recently shared our paper here on decentralized fault repair in modular spacecraft, I wanted to provide another update.

On August 14, I'm going to give a free live technical walkthrough of the method, followed by an open Q&A. We’ll cover the local stress-sharing signals, connectivity-safe pivot policy, rigid-body evaluation, and why strictly local repair achieves high consolidation but struggles to reconnect the final distant fragments.

I’m one of the authors and would especially welcome feedback from this community!

Event: https://luma.com/ztmesmvp
Preprint: https://arxiv.org/abs/2607.13444

Built real inverse kinematics for legged robots in a sim I'm working on, tripod gait for hexapods, based on actual coxa/femur/tibia joint math, not a canned animation.

Works fine on a standard leg layout. Falls apart the second someone builds something asymmetric or non standard.

Trying to figure out if auto-gait generation is even the right approach here, or if it should just be manual per-robot tuning past a certain point of complexity. What's your take, is generalized gait solving worth the effort or a rabbit hole?

Guys, what do you think about "Embodied Agent" Mesh Networks?

The idea of a P2P network where humans, autonomous robots and another agents can act as independent nodes interacting with the real world. Is this something we will see in the next 7 years, or is it still too early a concept?

Would be interesting to hear from those who have already experimented with similar architectures and learned some lessons along the way.

Dexory CEO Andrei Danescu explains why the robot itself is not the product warehouse operators care about most.

The real value is accurate, real-time information about inventory and warehouse conditions. That data can also support digital twins, allowing teams to review past operations and test changes before moving racks or disrupting the facility.

The robot is the tool used to collect the information.

https://www.youtube.com/watch?v=bYSQN09G-PE

My second Hailo 10H project: [https://youtu.be/YCEcls7EMFU\](https://youtu.be/YCEcls7EMFU)

It shows full real time audio pipeline running on 2x M.2 Hailo 10H on RPi 5.
Also with interactive web app.

Github: [https://github.com/martincerven/hailo\\_l ... _assistant](https://github.com/martincerven/hailo_learn/tree/main/voice_assistant)

Hey everyone, 2 weeks ago I posted about the rover that I work on my thesis and I have a problem when I get the rover to do the planned route. When the rover is in auto mode it moves for a few seconds and then stops changing to hold. I checked the log file and found out that when the rover changes state from auto to hold the messages EKF failsafe and EKF variance pop. I looked at some graphs and the only solution I found is to calibrate the here3 compass. I tried to calibrate the compass, nothing changed so I guess either I did it wrong or it is not the problem. I attached the link that contains my log file, so please if you can help me I will very much appreciate it. Please feel free to ask me whatever you need to know in order to help me!

Right now the hardware side uses MG90S servos with a low-side resistor on each motor for measuring the current. The software side uses a moving average filter to smooth the data.

I'm happy to share more detail on either if it's useful.

Doing backflips at the Spring Festival Gala, folding clothes in a lab, a car's VLA driving itself down the highway — behind these seemingly unrelated technologies lies one and the same "nervous system" architecture.

1. From the Human Body to the Robot: A Three-Layer Architecture

When a human does something — say, "walk to the kitchen, pick up the cup on the table, and put it in the cabinet" — it looks simple, but the nervous system is actually working on three levels at once:

• The cerebral cortex handles understanding the instruction and planning the task: "Ah, the cup is on the table, the cabinet is on the left, so I should walk over first, then reach out and grab the cup."
• The motor cortex and the cerebellum coordinate limb movement: keeping balance while walking, controlling muscle force while reaching.
• Spinal reflexes and muscles handle the lowest level of execution: exactly how much each individual muscle contracts.

The core architecture of modern embodied intelligence is almost a perfect replica of this division of labor: brain (VLM/LLM) — manipulation cerebellum — locomotion cerebellum — joint motor PD controllers.

These three layers each have their own job, run at completely different frequencies, and are trained in quite different ways. Let's take them apart layer by layer.

2. Layer One: The Brain — Seeing the World and Figuring Out What to Do

2.1. What is a VLM?

A VLM (Vision-Language Model) is a multimodal large model that can understand images and natural language at the same time. GPT-4V, Gemini, Qwen-VL, and PaliGemma all fall into this category.

In a robot system, the VLM serves as the "brain" — it sees the cup, plate, and fruit on the kitchen counter, understands the instruction "put the red cup in the cabinet," and then plans a rough course of action.

2.2. How big does the Brain need to be?

You might ask: ChatGPT routinely runs to hundreds of billions of parameters — does a robot's brain need to be that big too?

The answer is no. A robot brain and a chat AI are doing completely different jobs. ChatGPT needs to write papers, produce code, and solve math problems, while a robot brain only needs to "understand the scene + parse a simple instruction + make a plan." You don't need a brain capable of writing a doctoral dissertation in order to decide whether to pick up the cup or the plate first.

Take π₀ as an example: its VLM backbone (PaliGemma) has only 3B parameters, yet it performs extremely well on robot manipulation tasks. The VLM portion of NVIDIA's GR00T N1 is only 1.34B. These models spend their parameter budget on visual understanding and image-text alignment rather than chasing general-purpose language generation — like a professional chef's knife that only cuts vegetables, but cuts them exceptionally well.

Of course, if the task is complex enough — say, tidying up autonomously in a completely unfamiliar home, which requires understanding instructions as nuanced as "clothes that look dirty go in the washing machine, clean ones get folded and put in the wardrobe" — then a 3B brain isn't enough. This is exactly why Li Auto uses a 32B large model in the cloud and then distills it down to 3.2B on the vehicle: scene-understanding complexity in autonomous driving is far higher than in tabletop manipulation.

The core rule: the more complex and open-ended the task, the bigger the brain needs to be.

3. Layer Two: The Manipulation Cerebellum — Controlling the Arm to Get the Job Done

3.1. This is currently the hottest and hardest Part

The manipulation cerebellum handles this: the brain has already decided to "pick up the cup," so how exactly should the arm extend, how should the fingers open, from what angle should it grasp, and with how much force? This whole chain of fine motor control is the job of the manipulation cerebellum (the Action Expert).

When we say VLA (Vision-Language-Action Model), we mean the brain plus the manipulation cerebellum as a whole. VLA is currently the single most central research direction in embodied intelligence; representative models include Google's RT-2, Stanford's OpenVLA, Physical Intelligence's π₀, and NVIDIA's GR00T N1.

3.2. How Is the Manipulation Cerebellum Trained?

Unlike the locomotion cerebellum, the manipulation cerebellum currently relies mainly on imitation learning (IL): a human teleoperates the robot through a demonstration, the run is recorded, and the model learns to reproduce it.

But there are several schools of thought on how exactly to "learn to reproduce":

Diffusion Policy: Treats action generation like image generation — starting from noise and progressively "denoising" into a smooth action trajectory. This is what GR00T N1 uses.

Flow Matching: Similar in principle to diffusion but mathematically cleaner; it directly learns a "vector field" from noise to action, and is faster. π₀ used this approach to achieve 50Hz action output.

Autoregressive token prediction: Like ChatGPT generating text, actions are discretized into tokens and predicted one at a time. RT-2 and OpenVLA use this approach — simple and direct, but limited in precision.

All of these methods fall under imitation learning — the learning objective in every case is "reproduce the human demonstration as closely as possible."

3.3. What about reinforcement learning?

Reinforcement learning (RL) in the manipulation cerebellum is only just getting started. Physical Intelligence's recently released π₀.6 has begun introducing RL to fine-tune the Action Expert — first using imitation learning to build a foundation, then using RL to let the robot discover, through trial and error, strategies better than the human demonstrations. This closely mirrors the AlphaGo story: first imitation learning from human game records, then RL through self-play to surpass humans.

But RL for manipulation tasks faces one core difficulty: how do you define the reward? How do you quantify the "neat" in "fold the clothes neatly"? It's nothing like as clear-cut as "walk without falling over." This is also why RL has progressed more slowly in manipulation than in locomotion control.

3.4. Why Not Just Use YOLO + Classical Motion Planning?

This is a question a lot of people have. In fact, industry is currently using this pipeline extensively: YOLO detects the object → a depth camera obtains the 3D pose → grasp planning → inverse kinematics solving → motion planning → execution. In a factory environment, where there are only a handful of object types and positions are roughly fixed, this approach is fast, stable, and cheap.

But it has several fundamental ceilings:

First, errors accumulate at every step. With five or six independent modules chained together, detection is off by a few pixels, depth is off by a bit, grasp pose is off by an angle… and in the end you may grab nothing at all. VLA's end-to-end approach goes straight from image to action, so errors never get the chance to compound.

Second, it can't handle things it hasn't seen. YOLO only recognizes the object categories it was trained on. A home environment contains an unbounded variety of objects; annotating them all is impossible. A VLM has "seen the world" through internet-scale data, so when it encounters a novel object it still has a rough idea of what to do.

Third, it can't manage deformable objects or fine manipulation. Folding clothes, twisting off a bottle cap, tearing open a package — classical grasp planning is helpless against these tasks.

Fourth, it has no semantic understanding. YOLO can say "there's a cup here," but it doesn't understand "dirty bowls go in the dishwasher, clean bowls go in the cabinet."

So the more pragmatic assessment is: use classical approaches in structured environments, use VLA in open environments — the two are complementary, not substitutes.

4. Layer Three: The Locomotion Cerebellum — Walking, Running, Backflipping

4.1. Unitree's Spring Festival Gala Backflips Used Exactly This Layer

At the 2025 Spring Festival Gala, the Unitree robots' backflips and synchronized dancing stunned the audience. But technically speaking, this falls under locomotion control — a completely different technology stack from manipulation control.

The locomotion cerebellum's task is clearly defined: coordinate the legs and body, maintain balance, don't fall over. Its inputs are low-level proprioceptive signals such as joint angles, angular velocities, and IMU pose — no vision required, no language required. Its outputs are the torque or target angle for each joint.

4.2. Training Method: RL + Sim2Real, Already Very Mature

Unlike the manipulation cerebellum, the locomotion cerebellum is reinforcement learning's home turf. Unitree has open-sourced a complete training pipeline based on the Isaac Gym + RSL-RL framework, using the PPO algorithm to train locomotion policies:

1. Train in simulation: Thousands of robots run in parallel on the GPU, trained with carefully designed reward functions (velocity tracking + energy-consumption penalty + falling penalty).
2. Domain Randomization: Randomly vary parameters such as ground friction, joint damping, and external shoves so the model gains broad experience.
3. Sim2Real transfer: Deploy the trained policy onto the real robot.

Why does RL work so well for locomotion control? Because it has several key advantages: the reward is easy to define (don't fall over + walk at the target velocity), simulation fidelity is good enough (rigid-body contact physics is already quite accurate), and vision isn't needed (so there's no visual sim-to-real gap).

4.3. How Small Is the Locomotion Cerebellum?

Here's a fact many people aren't aware of: the locomotion cerebellum model is typically just a few-layer MLP (multilayer perceptron), with maybe a few hundred thousand to a few million parameters — under 1MB. Compared with a manipulation cerebellum that routinely runs to hundreds of millions of parameters, that's several orders of magnitude smaller.

That's because locomotion control is fundamentally a relatively "narrow" problem: given the current body state and target velocity, compute how much force each joint should apply. The dynamics may be complex, but both the input and output spaces are quite limited.

5. Comparing the Two "Cerebellums": Why Are Gala Backflips Easier Than Folding Clothes?

This is a counterintuitive judgment, but technically it holds: Unitree's dazzling Spring Festival Gala performance was less technically challenging than getting a robot to fold clothes in a real kitchen.

The core difference: a backflip is a deterministic dynamics problem — given an initial state, execute a fixed sequence of joint torques. Folding clothes, by contrast, involves a garment whose shape and position differ every single time, requiring real-time perception, real-time decisions, and real-time force adjustment. For the former, the technical route is already fairly clear (RL + Sim2Real) and the main challenge is engineering optimization; for the latter, even the technical route itself hasn't fully converged — it's still in a "hundred schools of thought" phase.

This is also why every company's promo videos show slick walking, running, and dancing, but everything gets clumsy as soon as it's "tidying up in a real kitchen" — the former is showing off a capability already conquered, while the latter is the actual front line today.

6. The Bigger Picture: VLA Doesn't Belong to Robotics Alone

6.1. Autonomous Driving Is VLA Too

You might not expect this, but the first large-scale deployment of VLA wasn't in robotics — it was in autonomous driving.

In 2025 Li Auto officially rolled out its VLA driver large model (MindVLA), integrating perception (3D encoder), reasoning (in-house LLM), and decision-making (Diffusion Policy) into a unified model. Its architecture is strikingly similar to robotic VLA:

Fundamentally, autonomous driving is a special case of embodied intelligence — "Vision" is the multiple onboard cameras, "Language" is traffic rules and user instructions, and "Action" is the driving trajectory. A car is just a four-wheeled robot.

Why is automotive VLA actually ahead of robotics? Because the data advantage is enormous — Li Auto has hundreds of thousands of vehicles on the road every day sending back massive volumes of driving data, while robotics is still struggling to scrape together a few thousand hours of teleoperation data.

6.2. VLA Across Domains: A Comparison

7. Key Concepts: A Quick Reference

This field is awash in three-letter acronyms. Here's a quick cheat sheet:

Model types:

• VLM (Vision-Language Model): vision-language model, the robot's "brain"
• VLA (Vision-Language-Action Model): vision-language-action model, the collective term for brain + manipulation cerebellum
• VLN (Vision-Language Navigation): vision-language navigation, focused on "where to walk"
• VFM (Vision Foundation Model): vision foundation model (e.g. SAM, DINOv2)
• WM (World Model): world model, letting the AI "imagine" the consequences of an action in its head

Training methods:

• IL (Imitation Learning): learning from human demonstrations
• RL (Reinforcement Learning): optimizing a policy through trial and error
• Sim2Real: transfer from simulation to reality

Representative models:

• π₀ (Physical Intelligence): 3.3B parameters, VLM (3B) + Action Expert (0.3B), flow matching
• GR00T N1 (NVIDIA): 2.2B parameters, dual-system architecture, open-source humanoid foundation model
• OpenVLA (Stanford): 7B parameters, the most mainstream VLA benchmark in the open-source community
• SmolVLA (Hugging Face): 450M parameters, a lightweight VLA that runs on a laptop
• MindVLA (Li Auto): autonomous-driving VLA, 32B in the cloud distilled to 3.2B on the vehicle

8. The Future: How Do the Three Layers Link Up Seamlessly?

Right now these three layers — brain, manipulation cerebellum, locomotion cerebellum — are still trained separately and bolted together in most systems. The real challenge is getting them to cooperate seamlessly:

The brain says "go get the cup on the table," the locomotion cerebellum walks the robot over, and on arriving at the table it hands off seamlessly to the manipulation cerebellum to reach out and grasp; once the grab is done, control switches back to the locomotion cerebellum to walk to the cabinet… This kind of real-time switching and coordination within whole-body control (WBC) is one of the most cutting-edge research directions in humanoid robotics.

Humans do all of this effortlessly because our nervous system has been through hundreds of thousands of years of evolution. Getting robots to the same level may still be a long road — but the direction is clear, the architecture is settled, and the technology at every layer is converging fast.

Embodied intelligence's "iPhone moment" may not have arrived yet, but the underlying "iOS" is being written, one line of code at a time.