We've spent years debating the ethics of autonomous weapons on academic panels and inside sterile UN meeting rooms. Meanwhile, the reality on the ground has already bypassed us. It happened two years ago near Bakhmut. A small, unauthorized team sent ten quadcopters into the front-line area with a simple, terrifying directive: fly to a designated grid, boot up an onboard target-recognition model—what the team called "Terminator mode"—and destroy anything that moves. No human operators. No live video links. Just code running on cheap chips, searching for warm bodies in a ruined landscape.
Ten quadcopters went in. None returned.
When the drones didn't return, human-piloted scout units went in to survey the aftermath. They found a couple of dead Russian soldiers. Statistically, it was a tiny footnote in a massive war. Strategically, it shifted the entire paradigm of modern combat. It was the first recorded instance of machines independently choosing and taking human lives without a human pilot guiding the final blow.
This wasn't a coordinated government program. It was a rogue experiment, a private test conducted outside the official chain of command. The CEO of drone maker Aero Center, Alexander Kokhanovskyy, revealed the incident during a London embassy briefing, though he was careful to clarify that his current firm had no part in it. The test confirms what systems engineers have known for a long time: once you put autonomous target recognition on an edge device, the human in the loop becomes a design choice rather than a technical necessity. We are dealing with an unauthorized fork in the wild, and there's no pulling that code back.
Consider the technical mechanics here. The team didn't use a multi-million-dollar predator drone controlled via satellite. They used commodity quadcopters. They coded a basic object detection algorithm, loaded it onto a low-power processor, and let it loose. There was no real-time telemetry, no fail-safe override, and no way to cancel the command once the drones crossed the line of contact. The systems were completely blind to the outside world except for the camera feeds feeding their local classifier. That is the definition of full autonomy. It is also the definition of an uncontrolled system loop.
Policy Versus the Reality of Front-Line Engineering
Official policy, of course, says this does not happen. Access rules are strict. Officially, the Ukrainian military draws a hard line. Government representatives and commanders insist that Ukraine's rules of engagement require a human operator to confirm any lethal strike. They cite international humanitarian law and emphasize the extreme care taken to prevent civilian casualties. Drones are supposed to be semi-autonomous: they can fly themselves, but the final pull of the trigger requires a finger on a button.
But there's a disconnect between official doctrine and the chaotic reality of front-line engineering. When a unit is losing soldiers because electronic warfare is cutting off their remote links, the temptation to flick the switch to full autonomy isn't just high—it’s inevitable. The Bakhmut test was a symptom of this pressure. It showed that rules written in embassy offices in London or policy briefs in Washington don't survive contact with a jamming-heavy combat environment.
No signal. No safety rules.
The military wants control. Yet, on the battlefield, absolute control is a luxury that bandwidth limitations deny. By officially banning autonomous interception while failing to prevent independent teams from deploying "Terminator mode," we are creating a dangerous delta between policy and practice. It’s an operations problem. If your systems allow an operator to bypass safety guidelines with a simple software flash, your safety policy is nothing but security theater.
This is classic shadow IT, but with explosive payloads. In the enterprise world, developers build undocumented APIs and workaround scripts because the central IT department is too slow. On the battlefield, soldiers do the same because the alternative is getting hit by an artillery shell. They aren't trying to build a dystopian future; they're trying to solve a concrete operational blocker. But when you fork a code repository to bypass security controls in a corporate network, you get a stern talking-to from the CISO. When you do it on a quadcopter, people die.
We have to look at this from a systems engineering perspective. If the control loop can be modified in the field by a soldier with a laptop and a USB cable, then the theoretical policy boundaries do not exist in reality. The code is modular. The hardware is open. When survival is on the line, the operators will always optimize for lethality over compliance. Treating this as a simple policy infraction ignores the structural incentives at play.
The Scale Problem: 64-Drone Autonomous Interceptor Batteries
The next step isn't fewer autonomous systems. It's more of them, deployed at a scale that makes human oversight mathematically impossible. Kokhanovskyy is already planning for this future. He's designing a 64-drone autonomous interceptor battery. Think about the numbers here.
A single human operator cannot monitor 64 separate video feeds, analyze threat profiles, and make split-second firing decisions for an entire swarm. The math doesn't work. The system architecture has to push automation as far down the kill chain as possible. In Kokhanovskyy's design, humans will still nominally sign off on the engagement, but the system does all the heavy lifting—tracking, route planning, and targeting.
This is what I call infrastructure debt in military strategy. We build these massively parallel systems because they are cheap and effective, but we don't have the cognitive bandwidth to manage them. If the human operator is reduced to merely clicking "OK" on a prompt generated by 64 autonomous systems, the human is no longer in the loop. They are just a rubber stamp for a machine's decision. It's a design pattern that gives the illusion of control while delegating the actual moral and tactical choices to the software—a dynamic that echoes the PLA's warnings against AI sycophancy on the battlefield where commanders unthinkingly trust algorithmic suggestions.
As a platform architect, I look at this and see a massive single point of failure in accountability. In load balancing, we talk about graceful degradation. If a server is overwhelmed, it drops non-critical requests to stay alive. In autonomous warfare, what does graceful degradation look like? If the communication link is completely severed and the battery is running low, does the drone crash itself safely, or does it defaults to targeting whatever it finds first? Without a central orchestrator, each node becomes its own sovereign execution environment. That’s a recipe for cascading systemic failure.
To make 64 drones work as a cohesive unit, you need a decentralized coordination protocol. The drones must talk to each other, allocate targets, and avoid collisions without relying on a central server that could be jammed. This requires edge consensus algorithms. As the software matures, the master-slave architecture of traditional drone operations is replaced by a peer-to-peer network. In this paradigm, who is the commander? The human who clicked "launch," or the consensus algorithm that distributed the targets among the swarm?
The Real-World Tech Stack of At-Scale Warfare
Let's look at the actual technical stack powering this shift. It's not science fiction. It's built on low-power, commercial-off-the-shelf chips. A report by Kateryna Bondar for the Center for Strategic and Studies (CSIS) details how Ukrainian engineers are training small machine learning models on highly specific, localized datasets.
These models don't need cloud access. They run locally on cheap, five-dollar microcontrollers. They handle two main tasks: navigation and target recognition.
Why is this necessary? Electronic warfare. Russian jamming is incredibly effective at cutting the GPS and radio links that human pilots need to fly FPV (first-person view) drones. If a drone loses its link, it crashes. But an AI-driven navigation module can take over when the signal cuts out, guiding the drone to its target using optical flow or terrain mapping. According to the CSIS report, this automation raises the success rate of drone strikes from a miserable 10-20% under manual control to an astonishing 70-80% under automated guidance.
The Russians are doing the exact same thing. They've been smuggling NVIDIA Jetson Orin microcomputers—hardware designed for commercial robotics and smart cameras—and mounting them inside their Shahed (Geran-2) strike drones. These chips give the Shahed drones onboard video processing. Instead of just flying blindly to a preprogrammed GPS coordinate, the drone can scan the ground, recognize a military vehicle, and alter its flight path to strike the target.
This is a bottom-up systems evolution. Both sides are building containerized, modular AI components that can be slapped onto any existing platform. It's a messy democratization of autonomous warfare. When you can buy the hardware on AliExpress and download the model templates from GitHub, the barriers to entry drop to zero. The defense industry is no longer about building multi-billion-dollar jets; it's about writing efficient C++ code that runs on low-power silicon.
The Global Regulatory Vacuum
From a regulatory perspective, we are operating in a complete vacuum. There's no treaty. The United Nations has spent years debating lethal autonomous weapons systems (LAWS) without reaching a consensus on how to define them, let alone regulate them.
The US Department of Defense defines LAWS as systems that can select and engage targets without further human intervention once activated. Under that definition, the Bakhmut trial was a clear, unambiguous deployment of a lethal autonomous weapon. But who is responsible when something goes wrong?
Is it the programmer who compiled the object-detection model? Is it the commander who ordered the drones to be launched? Or is it the private contractor who supplied the hardware? In a traditional software stack, a bug leads to a crashed database or a leaked API key. In autonomous warfare, a bug leads to dead civilians or friendly units.
We are building systems without accountability. Without clear, binding international frameworks, we are letting battlefield expediency dictate the rules of the future. The Bakhmut test wasn't just a tactical trial; it was a warning. If we continue to deploy autonomous systems without establishing clear boundaries, we will eventually lose the ability to control them. And by the time we realize we've crossed the line, the code will already be running everywhere.