Hyperautomation: When AI Stops Improvising

From artificial intelligence to industrial intelligence.

Written by Jose Racionero

At three in the morning, a camera looks at a part that has just reached the end of a production line. The connector is seated. The label is correct. The screws appear to be in place. But one of them protrudes by barely a few millimeters.

It could be a defect. It could also be a shadow, a vibration, or a drop of oil on the lens. To a person the difference may look insignificant; to a factory producing thousands of units a day, it is not.

This is where one of the great problems of industrial AI appears. The most advanced models we have built are extraordinarily good at interpreting images, language, and ambiguous situations. But a factory needs something harder than an intelligent answer: it needs an answer that can be repeated, measured, and — months later — explained.

That small detail changes entirely how we should think about hyperautomation.

For years, automating meant teaching machines to repeat. RPA (Robotic Process Automation) systems could open programs, copy data, register orders, or move information between applications. They worked extraordinarily well as long as the world stayed exactly as it had been programmed.

But the world rarely cooperates. A window moves, a new product appears, or a camera sees something nobody had anticipated. In those moments, traditional automation turns brittle.

Very smart models. Very precise models.

Large language models and vision-language models seem to offer the solution. They can look at an image and describe it, interpret documents, write code, or understand instructions they had never seen in exactly that form.

The problem is that the very flexibility that makes them fascinating can be uncomfortable inside a factory.

In 1926, Albert Einstein wrote to Max Born that he was convinced “He does not play dice.” Almost a century later, artificial intelligence does play with them. Every answer emerges from a landscape of probabilities, and that uncertainty is part of what lets a large model move comfortably between different situations. In a factory, however, it is not enough to roll the dice and accept the most likely result. You have to decide where chance can be tolerated, when a second look should be requested, and which rules will turn a probability into a repeatable action. The task is not to pretend uncertainty has disappeared, but to enclose it within known limits and keep the evidence of every roll.

We have grown used to very smart models, but all that intelligence has a price: they are large, slow, and hard to turn into measuring instruments. A factory usually needs the opposite — models that are far less smart, but extraordinarily fast and precise at a single task. They may not know what a bicycle is, but they can find a misplaced washer thousands of times an hour.

That is why one of the most interesting ideas now emerging is, paradoxically, to use giant models to build much smaller ones.

Picture thousands of photographs from an assembly line. Labeling them by hand can take specialists weeks. A vision-language model can make a first pass over those images: locating components, describing anomalies, and proposing labels. Other models can segment each object or cross-check those answers.

The goal is not to trust them blindly. It is to use them as teachers. Where several models agree, part of the labeling can be automated. Where they disagree, you have found exactly the example that deserves a human expert’s review.

The work changes. The specialist stops drawing thousands of boxes around screws and starts answering far more important questions: what does it actually mean for that screw to be misplaced? When is a deformation acceptable? What conditions make any judgment impossible?

With that knowledge you can train a specific model — a detector built on architectures such as DETR, for example — designed only to understand that small industrial universe. It cannot talk about any image imaginable; it only tells apart five components and three types of defect, and that is precisely why it can be far more useful.

It can run next to the camera, have its accuracy measured over thousands of real examples, be frozen at a specific version, and be compared against the next one. General intelligence has become an instrument.

Learning from what we don’t know

But even that instrument will be wrong sometimes. The difference between a reliable industrial system and a dangerous one is not eliminating error completely, but knowing what to do when it appears.

Back to the screw at three in the morning.

Instead of forcing an answer, the system can recognize that the image is ambiguous. It requests a second capture under different lighting. If the uncertainty persists, it sets the part aside for human inspection.

But the story does not end there. When a person resolves the doubt, their answer can return to the system as a new training example. Today’s exception becomes tomorrow’s knowledge. The human does not appear only when the AI fails: they step in precisely on the cases that can teach it most, widening the boundaries of what it will be able to resolve in the future.

Not knowing can also be a decision. This idea turns out to be surprisingly important. Much of today’s artificial intelligence is designed to answer. Industry needs systems that also know how to abstain.

Rehearsing before acting

World models take this logic one step further. Rather than just recognizing what is happening, they try to learn how a process changes. They can simulate what would happen if a temperature rose, a speed changed, or a camera shifted by a few millimeters.

They become a kind of digital wind tunnel: places to cause failures without breaking anything.

While these models observe and simulate, large language models can help write the software that connects the whole system. They can generate adapters, tests, interfaces, and much of the code needed to turn an experiment into an industrial application.

But here too they should not have the last word: the model can write; another system must verify.

A factory with memory

Finally, RPA, APIs, and industrial controllers carry out the actions: stopping a part, logging an anomaly, updating the production system, or alerting an operator.

Each technology does what it is most reliable at. And every decision leaves a trace.

Which image was analyzed. Which exact model version intervened. What it detected, with what confidence, and under what conditions. Which rule turned that observation into an action. If a person overrode the decision, that is recorded too.

The factory does not only keep what it decided: it keeps why it was able to decide it. That difference is fundamental. Asking a large model to explain after the fact why it did something can produce a convincing story. Designing the system to keep the evidence that actually caused the decision produces something far more valuable: traceability.

That may be the truly important transformation in hyperautomation.

The first generation of automation taught machines to repeat. Large models are teaching them to understand, and specialized models to do it with the speed and precision a factory demands. The next frontier will perhaps be less spectacular, but far more important: building systems that know when to doubt, that learn from whoever resolves that doubt, and that keep the evidence behind every decision. Because in industry it is not enough for an artificial intelligence to be right. We have to be able to prove why it was.