The Agentic Layer Architecture

Traditional robotics relies on pre-programmed, fixed-task policies. By introducing an agentic layer—specifically using the open-source Strands framework—you can decouple the what from the how. The agent acts as the brain, interpreting natural language commands and orchestrating which pre-trained hardware policy to execute. This allows a robot to perform tasks it was never explicitly trained for, such as answering questions about its surroundings or navigating to specific objects based on conversational prompts.

Implementation and Hybrid Execution

The system operates across four distinct layers: the agentic layer (the brain), the policy provider (the trained models), the backend (simulation or hardware interface), and the physical hardware. This setup utilizes a hybrid model where heavy training of Vision-Language-Action (VLA) models occurs in the cloud, while runtime execution happens on the edge (e.g., a Raspberry Pi).

Key technical components include:

• Multi-Agent Coordination: A single robot can run multiple agents simultaneously—one for environmental reasoning, one for communication (e.g., Telegram), and one for voice interaction.
• Tool Integration: Just as software agents call APIs, robot agents call hardware tools. These tools are essentially wrappers around existing robot policies, allowing the agent to invoke specific behaviors like "spin," "move," or "speak."
• Data Collection: The robot serves as a data-collection rig. By manually guiding the robot or observing its agentic reasoning, developers can generate new training episodes to improve future VLA models.

Practical Trade-offs

While this approach enables flexible, natural language interaction, it remains dependent on the underlying pre-trained policies. The agent cannot invent new physical movements; it can only select from the library of policies provided to it. The demo highlights the reality of edge robotics: hardware is prone to failure (e.g., falling over), and agentic reasoning can be unpredictable. However, this framework provides a scalable path to move beyond hard-coded automation, treating robot policies as modular components that can be orchestrated by large language models.