Coordination under fire: multi-agent autonomy for contested environments

Most of the drone world is still racing to build a better airframe. The sharpest teams have already moved on.

A modern drone is a consumable. Cheap, expendable, replaced in minutes. The same shift is happening on the ground and under the water: unmanned platforms are converging on commodity hardware, and anything that converges gets cheap. So the advantage is no longer the platform. The advantage is the ecosystem that connects every unit into one system, and how it behaves when conditions stop being convenient.

That ecosystem wins or loses on three properties: it has to be precise, layered, and scalable. And all three have to hold in a contested environment — denied, degraded, intermittent, and limited (DDIL) comms, jamming, spoofed GPS, stale tracks, and units dropping out mid-mission.

This is the part that doesn't fit on a slide. It's also the part we build.

The airframe is the cheap part

Walk the current market and the trend is obvious. FPV quadcopters, long-range fixed-wing platforms, ground robotic complexes, unmanned surface and underwater vehicles — the hardware is getting cheaper and more interchangeable every quarter. A capable airframe is no longer a moat. It is a line item.

When the hardware commoditizes, value moves up a layer. The question stops being "can this drone fly the mission" and becomes "can a thousand mixed platforms act as one coherent force when half the assumptions break." That is a software and systems problem, not a hardware one.

The hard problem: coordination under DDIL

In a lab, coordination looks like a clean diagram: a few units, a target, a synchronized plan. In the field, the network is the first thing the enemy attacks. No GPS. No reliable link. Video feeds full of noise. Tracks that go stale faster than you would like. A target already moving differently than the system predicted a second ago.

So the real engineering is not "see the target." It is keeping multiple agents acting coherently when:

• some of the data arrives late, or not at all
• the link is intermittent or actively jammed
• positioning is spoofed or unavailable
• units are lost and the picture changes underneath the plan

Everything below is what it actually takes to hold a force together under those conditions.

Precise: one shared picture, down to the target

Precision is not one drone with a good camera. It is every unit acting on the same real-time picture.

That means sensor fusion across platforms — a track started by one unit is handed to others with enough context that each can act on it independently. It means a target lock that survives the worst moment in the engagement: the instant the operator link drops. If autonomy only works while the human is in the loop, it does not work, because the loop is exactly what the adversary severs first.

In practice this is a state-synchronization problem under uncertainty. Each agent has to reason about position, target velocity, latency, data quality, and how much confidence the system actually has in the current track — and keep acting when that confidence drops. The system has to degrade gracefully, not fall apart, when a feed goes dark.

Layered: heterogeneous platforms, one operating layer

No single airframe wins a contested environment. A real force is layered: FPV for the last mile, long-range wings for reach and ISR, ground robotics for terrain the air cannot hold, surface and underwater systems for the maritime fight.

The advantage shows up only when those layers feed one another instead of operating in silos. Recon from one platform sharpens the targeting of another. A ground sensor cues an aerial asset. The intelligence layer has to abstract away the differences between platforms so that a mixed fleet behaves like one system with one operating picture.

This is where most "swarm" demos quietly fail. Homogeneous units flying a scripted pattern is a video. A heterogeneous force holding a shared plan across platform types, vendors, and capabilities is a system.

Scalable: from one unit to ten thousand, with no central uplink

Scale is the property that breaks naive architectures. A design that depends on a central server routing every decision works for ten units and collapses for ten thousand — and it dies instantly the moment that central uplink is jammed.

The answer is mesh networking and edge autonomy. Units relay data and coordinate peer to peer, so the force keeps functioning when there is no central link to lean on. Decisions move to the edge: each unit carries enough onboard intelligence to act locally and still contribute to the collective behavior. Command of one unit and command of ten thousand have to run on the same system, and that system has to stay coherent when the network is partitioned, degraded, or actively attacked.

Scalability here is not "more servers." It is an architecture that assumes the link will fail and is still correct when it does.

The layer underneath: data

None of this works without the part nobody puts on the brochure: data.

The perception that makes any of this real — computer vision that finds a target through smoke, dust, motion, and bad weather — is only as good as the data it trained on. And the threat changes faster than a slow data pipeline can keep up with. New countermeasures, new decoys, new conditions appear in the field, and the models have to follow.

That puts hard requirements on the data layer:

• move and process massive datasets fast, not in weekly batches
• label and retrain in days, not quarters, so perception keeps pace with how the threat is actually evolving
• run inference at the edge, inside the power and compute budget of an expendable platform

A team that can ship a model is common. A team that can keep a perception system current against an adapting adversary, on constrained hardware, is rare. That data flywheel is part of the moat, not an afterthought to it.

Engineering for the moment the link dies

There is a mindset difference between building for a demo and building for a contested environment. In a demo you design the happy path. In the field you design for the second the link dies, the GPS lies, and the feed goes to noise — because that second is not an edge case, it is the mission.

We learned this the hard way. Our engineers build autonomy from Kyiv and Dnipro, sometimes between air-raid alerts. When your operating environment assumes the network is the first thing the enemy takes down, you stop treating resilience as a feature and start treating it as the baseline. You design every layer — perception, coordination, comms, command — for the case where the convenient assumption is gone.

That constraint changes how you build everything above it. It is also very hard to fake. You either internalized it from real conditions or you did not.

The next decade is won on the intelligence layer

The drone is expendable. That is the point. The next decade of autonomous defense will not be won by whoever has the best airframe. It will be won by whoever has the most precise, layered, and scalable ecosystem behind it — and the data pipeline that keeps it sharp.

That is the layer we build: multi-agent coordination, mesh and edge autonomy, perception, and the data infrastructure that feeds it, engineered by senior teams who learned resilience where it actually matters.

If you are building in this space, we would like to compare notes on the coordination problem. It is the one that decides whether a fleet of cheap platforms is a liability or a force.