PrivateAgent: Mobility-Aware AI Agents for Safe Private Networks

In the modern industrial world, a new kind of nervous system is taking root. It is not made of nerves, but of private cellular networks that operate inside factories, warehouses, and large campuses, separate from the public internet. These networks connect everything from fixed security cameras to workers wearing smart glasses and autonomous robots that move freely across the floor. The challenge for engineers is that these devices do not all behave the same way. A camera sitting on a wall has a stable connection and can wait a moment for instructions. A robot driving down an aisle, however, must make split-second decisions to avoid crashing, and a delay of even a fraction of a second can lead to a physical collision or a halted production line. For years, the assumption was that a single, powerful artificial intelligence could manage all these different tasks from a central location. This paper argues that such a one-size-fits-all approach is not only inefficient but potentially dangerous.

The researchers behind this study, working with institutions in Italy, the United States, and China, propose a new way to organize these smart systems. They call it PrivateAgent. Instead of relying on one central brain, they suggest dividing the work based on how fast the device moves and how quickly it needs to react. The core idea is that safety-critical tasks, like stopping a robot before it hits a person, must happen instantly on the device itself. Tasks that require more thinking, like planning a route for a whole fleet of robots, can happen at a local computer nearby, known as the edge. Only the slowest tasks, like long-term learning or updating software, need to go to the distant cloud. This separation ensures that the system remains safe even if the connection to the cloud is lost.

To test this idea, the team created a rigorous set of tests using real-world data from four different private networks. They did not just simulate a perfect world; they used actual records of how signals behave when a worker walks past a rack of shelves or when a robot moves through a doorway. They fed this data into an artificial intelligence model and asked it to decide what network action to take. The model had to choose between three options: act immediately, ask for more information because the situation was unclear, or refuse to act because it was unsafe. The results were striking. In every single one of the fifty test scenarios, the model correctly identified whether it should act, clarify, or reject a request. When it chose to act, it picked a safe and acceptable action ninety percent of the time, and it selected the single best possible action eighty-six percent of the time.

Crucially, the paper also highlights a second layer of safety that operates independently of the artificial intelligence. Even if the AI makes a good decision, the system must verify that the decision is valid before it is executed. The researchers built a strict digital gatekeeper that checks every proposed change. This gatekeeper looks for missing information, impossible requests, or signs that the AI is making things up. In their tests, they deliberately injected four hundred errors into the system to see if the gatekeeper would catch them. A standard check, which only looks at the basic format of the request, caught only one hundred and fifty of these errors. The new, more thorough gatekeeper caught all four hundred. This proves that having a separate, independent check is essential for preventing the system from making dangerous mistakes.

The study also breaks down the different types of devices found in these private networks into three clear categories. The first group is stationary, like fixed cameras watching a perimeter. These devices do not move, so their connection is stable. For them, the system can afford to be slower and can rely on the cloud for heavy analysis. The second group is low-mobility, such as workers carrying handheld scanners or forklifts moving at walking speed. These devices move enough to cause brief interruptions in the signal, so the system needs to be smart about switching connections and keeping instructions ready. The third group is high-mobility, which includes autonomous robots and drones that move quickly and unpredictably. For these, the system must be extremely fast. The researchers found that for high-mobility devices, the most critical safety decisions must stay on the device itself. If the network connection fails, the robot must still be able to stop safely without waiting for a signal from a distant server.

One of the most important findings is that the type of artificial intelligence used should match the task. The paper argues against using a single, large language model to control everything. A language model is excellent at understanding complex instructions or summarizing a situation, but it is too slow and unpredictable for controlling a robot's brakes. Instead, the system uses a hierarchy. Small, fast programs handle the immediate safety loops on the device. More complex reasoning happens at the local edge. The large language models are reserved for high-level planning or explaining what happened after an event. This division of labor prevents the system from getting bogged down by slow processing when speed is needed.

The researchers also addressed the issue of trust. In a system where artificial intelligence makes decisions about network traffic, there is a risk that the AI might suggest a change that looks correct but is actually harmful. For example, an AI might suggest rerouting a video stream to a different path, not realizing that the new path is blocked or that it violates a security rule. The PrivateAgent framework treats every suggestion from the AI as a draft that must be signed off by an independent verifier. This verifier checks the evidence, the scope of the request, and whether a rollback plan exists if things go wrong. In the tests, this independent check was able to detect subtle errors that a simple format check missed, such as fabricated data or requests that exceeded the AI's authority.

The study concludes that the future of private networks lies in this mobility-aware approach. By recognizing that a stationary camera, a walking worker, and a speeding robot have fundamentally different needs, engineers can build systems that are both smarter and safer. The framework does not require every device to be connected to the cloud at all times. Instead, it allows the system to degrade gracefully. If the connection to the edge is lost, a stationary camera continues to record locally. If the connection to the cloud is lost, a robot continues to navigate using its onboard sensors. The goal is not to create a perfect, unbreakable system, but to create one that knows its limits and has a clear plan for when things go wrong.

This work represents a significant step toward making industrial automation more reliable. It moves the conversation away from simply asking how powerful an artificial intelligence can be, to asking where that intelligence should live and how it should be checked. The results show that with the right structure, artificial intelligence can manage complex networks without compromising safety. The researchers have made their test data and methods available to others, inviting the community to build on this foundation. The path forward involves expanding these tests to include more complex robot movements and longer periods of operation, but the core principle remains clear: safety depends on matching the speed of the decision to the speed of the machine.