Making Robot Programming More Accessible with Low-Code Development

Oct 12, 2026 | Blog

Imagine an autonomous robot transporting objects across a warehouse. While navigating towards its destination, the robot continuously monitors its battery level. If the battery becomes too low, it should interrupt the ongoing task, move towards a charging station, and recharge.

But what happens if the robot cannot interrupt its current operation? What if two activities attempt to send the robot to two different locations simultaneously? Or what if an error occurs and the robot has no recovery procedure?

These are examples of problems that can emerge when developing autonomous robotic systems. Even seemingly simple applications require several software components to cooperate, each with different interfaces, programming requirements, and communication mechanisms. Detecting errors during execution can be expensive and, depending on the application, potentially dangerous.

At Eindhoven University of Technology (TU/e), as part of the Cynergy4MIE project, we are investigating how to make robotic software easier to develop without compromising its reliability. What if users could focus on what their robots need to accomplish, while development tools handle much of the implementation and verification complexity?

Bringing low-code development to robotics

Low-code development allows users to build software applications through visual models and reusable components, reducing the amount of code that must be written manually.

We are exploring how the same principles can be applied to autonomous robots. To this end, we developed MAKI, a low-code platform that allows users to describe robotic applications through three connected aspects:

  • Structure: What capabilities does the robot need? For example, navigation, object detection, or manipulation.
  • Behavior: How should these capabilities cooperate? Should actions execute sequentially, in parallel, or react to unexpected events?
  • Data: What information do the capabilities require, and how is it exchanged between them?

These aspects are connected through a reference architecture that provides reusable knowledge about robotic capabilities and their interactions. By separating the different concerns while keeping their relationships explicit, users can focus on composing their applications without needing to understand every implementation detail.

Overview of a delivery behavior modelled in MAKI.

From visual models to executable robots

Creating a visual model is only part of the challenge. Ultimately, the model must be transformed into software that can run on a robot.

To achieve this, MAKI uses KODA, a domain-specific language that represents robotic capabilities, behavior, and data independently of the underlying technology. From these high-level models, our generation pipeline can automatically produce both formal models for verification and executable robotic software.

For example, consider a robot that must navigate towards an object, detect its location, pick it up, and transport it elsewhere. Using MAKI, users can compose these activities without manually implementing their coordination.

However, making robot programming easier is not enough if the resulting software is unreliable. Therefore, MAKI also uses the knowledge captured in the models to identify potential problems before execution.

Some inconsistencies, such as using information before it becomes available or connecting semantically incompatible data, can be detected directly during modelling. Other problems, such as invalid interactions between concurrently executing capabilities, can be identified through formal verification, which systematically analyzes the possible behaviors of the system.

Importantly, users do not need to create these verification models themselves. They are automatically generated from the same application description used to produce the executable software.

Towards more accessible and reliable robotics

Going back to our warehouse robot, to evaluate our approach, we developed simulated mobile robot scenarios involving capabilities such as navigation, object manipulation, and battery monitoring.

The experiments demonstrated that the platform could identify several inconsistencies introduced deliberately into the application models, illustrating how architectural constraints and formal verification can complement each other.

Within Cynergy4MIE, this work contributes towards reducing the complexity of developing autonomous robotic applications while supporting their reliability and reuse.

The longer-term goal is to allow users to focus on their robotic applications, leaving more of the implementation and verification complexity to the development tools.

Blog signed by: TUe team