LLMs and agent systems are pushing ROS out of the center of robotics — and why that matters

A shift is gaining strength in robotics: ROS remains the base layer for hardware, while decision-making is increasingly moved into LLMs and agent frameworks. The author argues that this pairing may rewrite the rules of the industry and make building robots cheaper and faster.

Why ROS is stalling

For decades ROS was the standard for academic and industrial robotics, but its logic is built around rigidly defined nodes, messages and scenarios. To teach a machine a new action, a developer has to write a module, connect it to the rest of the system, run a simulation and then verify everything on a real device. In a controlled environment such as a conveyor line, this works well. But at home, on the street or on a construction site, the world is too changeable: the height of steps, lighting, people and obstacles keep shifting, so hand-coding every scenario quickly hits a ceiling.

Against this background, the contrast between ASIMO and today's garage projects is telling. Big corporations spent years polishing individual demonstrations, whereas small teams increasingly build robots that learn in simulation, get back up after falls and adapt faster to new surroundings. The key difference is not only in the hardware but in the approach: the industry is gradually moving away from the idea that every movement and every reaction must be described in code in advance.

The new robot stack

Instead of monolithic logic, the author proposes a layered design in which thinking is separated from execution. The lowest level keeps fast reflexes and protection: stopping the motors, reacting to an obstacle, basic safety control. Above it, sensor models turn the stream from cameras, microphones and sensors into understandable entities. Then the LLM receives a goal, assesses the context and builds a plan, while the agent layer calls specific tools and translates abstract commands into hardware actions.

• The reflex layer handles instant, safe reactions
• The sensor layer recognizes objects, speech and the surrounding scene
• The LLM planner decides what to do next
• The agent layer calls motors, files, APIs and external programs

This design makes the robot less tied to a specific platform. The model does not need to know how each motor or sensor works: it operates on tasks such as "go around the obstacle," "open the config," "tweak the speed" or "check the new trajectory." In the limit, this leads to an even more radical scenario: the LLM notices that the system lacks a tool, generates a new module, tests it in simulation and only then deploys it in the production loop. Such flexibility is atypical for the classic ROS approach.

Benefits and risks

The main gain here is scalability. Adding a new behavior to a robot no longer requires a separate development cycle in C++ or Python each time. It is enough to describe the task in natural language, and the system breaks it into steps itself. This opens the way not only for service and home robots but also for a broader class of "smart" devices: from household assistants to appliances that adjust to the user's habits without rigidly scripted automation scenarios.

"Because now it has not only a head, but also hands."

But as flexibility grows, so do the risks. If an LLM can change configuration, run code and make decisions in the physical world, you need sandboxes, limits on dangerous actions, simulation testing and a clear rollback mechanism. Questions remain about power consumption, reliability and legal liability: who is responsible if a robot makes a mistake after the model's advice. So this is not about the instant death of ROS, but about its role shifting down the stack, closer to drivers and the real-time level.

What it means

The idea of the "end of the ROS era" is not that middleware will disappear tomorrow, but that the center of robotics architecture is gradually moving from rigid rules to a layer of planning and agent-based execution. If this transition takes hold, robots will be easier to train for new tasks, cheaper to adapt to different hardware and faster to move from labs into real-world environments.