The shop floor is a very complex environment, involving a whole range of different actors with different perspectives and knowledge domains. One of the biggest hurdles for achieving results lies in bridging the gap between business and production requirements and the ability to deconstruct them into software requirements.
Typically, this is a morose process, with different owners managing different parts of the process. The result often resembles a ‘‘telephone game’’, where the information and motivation behind a certain feature gets lost through the decision-making process. In a fast-moving world, such hurdles can lead to features that are outdated by the time they are implemented, while truly urgent needs remain stuck in a decision pipeline bottleneck.
Bringing the requirements and their implementation closer is absolutely key in breaking down silos and speeding up value delivery across the organization. Low-Code plays a central role in making that a reality. Let’s see how.
Low-Code
Low-code is a key element in the effort to bring the person who is creating the need and the person who is implementing the solution closer together. It allows us to move past a reality where the software engineer delivers a ‘‘black box’’ to the shop floor, where only an expert can decrypt and operate. Instead, we move to a more transparent system, where the process engineer or shop floor staff can understand and visualize, even if they are not directly implementing them. Low-code enables greater cooperation and a tighter feedback loop between the team that delivers requirements and the team that creates and validates them. Instead of relying solely on traditional programming languages, it introduces a visual abstraction of code and code flows through blocks and diagrams. These diagrams act as a universal language, making it easier to distill complex problems.
However, low-code does not replace programming; it complements it. Code is expressed through reusable functional blocks, each with atomic capabilities, which can be combined to build scalable and maintainable solutions.
Figure 1: Low-code Connect IoT
Legos offer a useful way to visualize this. They come in many sizes and shapes, each serving a distinct purpose. On their own, they are very simple, but when combined, they can create structures ranging from the most basic to highly complex. Low-code is a bit like Legos. It provides small and simple blocks with specific features, which users can combine to build complex MES features. The added advantage is clarity: each component is visible and understandable in its role within the system. Low-code also enables code universality. It offers a generic, reusable framework that can address diverse needs — from ERP integrations and machine integrations to building operator dashboards and custom business logic. This not only promotes transparency across all tools but also fosters collaboration among experts from different domains, encouraging synergy, code reuse, and transition of system integrators between fields.
Figure 2: Low-code Custom Business Logic
Generative AI
Generative AI and the use of Large Language Models (LLM) have quickly taken the market by storm, evolving from niche applications to a mainstream tool in just a few years. They represent a different way in which we interact with information, moving away from the old search engine queries to dynamic, conversational experiences. Instead of static results, we can now engage in an iterative dialogue with an LLM, refining and adjusting responses until the outcome truly meets our needs.
We already see this technology being widely applied to language-based tasks, for example, drafting an email (“type me an email asking for x y or z”), or generating code (“create a function that receives x multiplied by y”). It enables faster iteration loops and solution exploration, representing a step toward democratizing access to knowledge and lowering the barriers between different roles.
The person who is able to create business requirements is now able to process them in an LLM and try to generate a possible solution.
Generative AI & Low-Code
The shop floor is highly complex, and its requirements can be equally demanding.
A conversation with an LLM may provide an approximate solution, but it typically expresses it in a programming language. Without a shared framework for interpreting the response, the user may be left guessing whether the solution is correct.
Low-code is the missing link in turning requirements into features with Gen AI. It allows users to have detailed conversations with an LLM about their needs and then generate a low-code solution. This solution is transparent and provides a clear visual representation of everything that will be implemented.
Safety
Low-code is a sandboxed solution where all components are predefined and validated in advance. This reduces the risk of creating low-code features that have a catastrophic impact on the system. Since the number of available low-code blocks is limited, this is where LLMs really excel: working within a strict, well-defined domain, they can apply semantic inference to determine the best way to create solutions with the available tools.
Agentic AI
The introduction of agents was a big leap for Gen AI. In the case of LLMs, they evolved from being a search engine-like tool, capable of having discussions and making suggestions, into systems that can actively interact with the world. This shift immediately addressed one of the biggest limitations: the staleness of training data. But more importantly, it unlocked an entirely new set of opportunities.
Now, LLMs can retrieve information from live systems with real-time data, providing a much richer context for inference and even interacting directly with those systems. For example, they can query databases to understand their schemas and extract valuable information.
With agents, iteration in low-code workflows becomes far more dynamic. A requirement can be defined, translated into a low-code workflow, and then continuously refined until it meets expectations. Once the workflow is validated, it can seamlessly move through the approval cycle and into production.
Figure 3: Agentic AI and Low-code
These agents provide real-time task information, perform validations, and add additional context. They also offer safe mechanisms for the LLMs to persist this information within an MES instance, ensuring full integration into the system development lifecycle.
Figure 4: Agentic AI and Low-code Dynamic Conversation
Responsibility
A human element is always essential in ensuring the quality of what is delivered, what becomes part of the process, and what directly impacts the shop floor. A robust change management system, supported by a structured approval workflow, positions humans as reliable gatekeepers and quality controllers. This step is fundamental when working with non-deterministic systems, which can create a false sense of security or generate misleading information. Ultimately, it is he responsibility of the systems integrator to properly leverage these systems and apply them effectively in daily operations.
Bringing Natural Language to the Shop Floor
We can now have a clearer understanding of how two different tools can be combined to create a user experience that bridges knowledge domains and brings solution design closer to the problem itself.
New technologies do not magically solve problems and are not panaceas, but when combined and applied effectively, they can make us ever more productive and efficient. Every step on the technological ladder matters: LLMs without a structured system are imprecise and prone to hallucinations, while Low-code platforms without LLMs fall short in bridging the gap between requirements and implementation.
Together, LLMs and Agentic AI are not stand-alone solutions but strategic enablers. However, if we skip or rush through the necessary steps in this progression, the result is not acceleration; it is failure. Progress requires climbing carefully, step by step, to achieve flight rather than a fall.
