Inspiration
The seed for SkyWall came from a simple asymmetry: a single $500 quadcopter can threaten a multi-million-dollar asset, and the defender usually has one operator, one joystick, and one pair of eyes. That math gets worse the moment the threat is a swarm — you can't out-click a coordinated inbound wave.
We noticed that almost every C-UAS demo we'd seen was either (a) a single interceptor chasing a single drone, or (b) a policy that only existed in simulation. What's missing in the middle is a decision layer: something that looks at many threats, many defenders, and makes a coordinated assignment under a hard deadline. That's fundamentally a multi-agent problem, which made it a perfect fit for Isaac Lab and PPO. The question we wanted to answer over 36 hours was blunt: can a learned multi-agent policy beat a greedy nearest-interceptor rule when the swarm arrives at the same time from multiple vectors?
We also wanted the hackathon's hardware window to be a real constraint, not a footnote. So we designed from day one around the Tello fleet — limited onboard compute, offboard control, and a policy that had to survive the sim-to-real jump with whatever state estimate we could actually get
What it does
SkyWall is a layered counter-swarm defense stack that protects a high-value mock commercial target against incoming hostile drones. It runs the same three-stage loop in simulation and on hardware:
Detect. Hostile drones are perceived as position/velocity tracks. In Isaac Lab this comes from the simulator's ground truth plus injected sensor noise and dropout; on hardware it comes from the Tello's state stream and our perception bridge. Each track gets a covariance, so downstream stages know how much to trust it.
Track and prioritize. Tracks are filtered and scored for threat. Our threat score for track i i blends time-to-target, heading alignment, and corridor breach
Defeat. A defender swarm is allocated to threats by solving an assignment problem on a cost matrix that encodes intercept feasibility i. Infeasible pairs are priced out with a large penalty, so the solver naturally avoids suicide assignments. The allocator is the learned part — PPO shapes the defender policies that realize the assignment, while the assignment itself provides a structured, interpretable backbone that keeps the swarm from collapsing onto one target.
Defeat mechanisms are modular and selectable per run:
Net-capture tag-alongs — interceptors that close to a standoff distance and deploy a net volume to catch the threat physically.
Defender swarm screening — multiple defenders hold a protective shell and force the threat off its approach corridor.
Policy-loop — pure learned engagement behavior with no explicit assignment, used as an ablation.
Everything is config-driven, so a judge can switch from net-capture to screening in a single config change.
How we built it
Simulation (Day 1). The environment is an Isaac Lab task registration with a configurable scene: a protected target at the origin, an approach corridor, N N hostile drones spawned on a threat arc, and M M defenders with constrained kinematics. We exposed observations as a fixed-size tensor per agent — own state, target state, and a padded, masked set of the K K nearest tracks — so the policy generalizes to varying swarm sizes without retraining. We kept a shared-policy, centralized-training / decentralized-execution setup: one policy conditioned on per-agent observations, trained with a centralized critic, which made it far easier to deploy to the Tello fleet than per-agent policies would have been.
Assignment layer. The allocator is a small, fast Hungarian solver over C i j C ij , recomputed at a fixed cadence and warm-started from the previous solution to avoid assignment thrash between frames.
Hardware (Day 2). Flight control runs offboard: a Python control loop sends velocity setpoints through the Tello SDK, with a safety supervisor that clamps setpoints to a geofence and triggers a hover-and-land on link loss or battery threshold. The learned policy outputs the same action abstraction in sim and on hardware — a body-frame velocity command plus a discrete "deploy net" flag — which is the single biggest reason the transfer worked at all. We built a hardware abstraction layer so the exact same decision stack could run against Isaac Lab or the physical fleet by swapping the backend.
Tooling. Git for everything, configs as versioned YAML, a logging shim that wrote rollout metrics and episode outcomes to a common format so sim and hardware runs could be compared side by side, and a plotting script for the demo video.
Challenges we ran into
The sim-to-real gap was mostly about latency, not physics. Our first hardware runs had defenders oscillating because the policy assumed fresh observations. Adding an explicit action-delay and observation-staleness model to the sim environment during training fixed more of the transfer problem than any amount of reward tuning.
Sparse rewards stalled early training. With a pure intercept reward, agents learned to hover. Reward shaping got them moving, but then they learned to chase rather than intercept — a classic pursuit trap that we fixed by rewarding predicted intercept geometry instead of raw proximity.
Assignment thrash. Recomputing the optimal assignment every frame produced chattering between two near-equal-cost targets and, on hardware, visibly jittery flight. The fix was hysteresis: a small switching cost in C i j C ij plus a minimum re-assignment interval.
Swarm size generalization. A policy trained on 3v3 fell apart at 5v3. Padding observations and masking out invalid tracks got us most of the way, but the policy still needed curriculum over swarm size during training to stay stable at the upper end.
Hardware access was the real bottleneck. Live windows were short and shared. We had to make every flight minute count, which meant building a rehearsal mode that replayed recorded sim episodes through the hardware abstraction layer so we could catch integration bugs without burning flight time.
Time. Thirty-six hours is not long enough for everything on the wishlist. We cut scope aggressively — dropping a vision-based detector in favor of a state-stream perception bridge — and kept the interfaces clean so the cut piece could be plugged back in.
Accomplishments that we're proud of
One decision stack, two backends. The same code path ran in Isaac Lab and on the Tello fleet, with only the perception and actuation backends swapped. No forked "hardware version."
A measurable win over the greedy baseline. The learned allocator + PPO policy neutralized more threats per engagement window than a nearest-interceptor heuristic under simultaneous multi-vector attack, which was the specific hypothesis we set out to test.
A modular defeat layer. Net-capture, screening, and pure policy-loop all run from config, so the same repo demonstrates three distinct C-UAS strategies.
Flight safety that held. The supervisor's geofence and failsafe hover triggered correctly in testing, which meant we could iterate on aggressive policies without risking the fleet.
A demo we could actually show. A 60-second video and a table-to-table pitch that walk a judge from "inbound swarm" to "target defended" without hand-waving.
What we learned
Structure beats raw learning for allocation. The Hungarian layer did in microseconds what PPO struggled to learn in hours. The lesson: learn the parts that are hard to specify, and specify the parts that are easy to optimize.
Model your own latency in sim. The single highest-leverage change to our environment wasn't physics fidelity — it was adding observation delay and action lag. Real deployment is a timing problem before it's a dynamics problem.
Reward hacking is a design signal. Every degenerate behavior we saw (hovering, chasing, orbiting) pointed at a missing term in the objective, not a broken optimizer.
Interfaces are the real deliverable under time pressure. Every hour spent on the hardware abstraction layer paid back double when we had twenty minutes of flight time left.
Prize money aside, hardware deadlines teach discipline. A sim-only project lets you defer integration forever. A shared Tello fleet does not.
What's next for SkyWall
Real perception. Replace the state-stream bridge with onboard/edge vision — a lightweight detector plus a tracking filter — so SkyWall doesn't depend on a cooperative state feed.
Scalable allocation. Move from the Hungarian solver to an auction- or consensus-based allocator so assignment stays tractable as swarm sizes grow beyond what a single centralized solver handles comfortably.
Adversarial robustness. Train against an adversarial or self-play swarm that actively tries to defeat our defense, instead of scripted threat trajectories.
Net-capture maturity. Move net deployment from a discrete flag into a learned timing policy with a physical deployment model, and characterize capture probability as a function of closing speed and geometry.
Field packaging. A single-command deployable bundle — config, policy checkpoint, and safety supervisor — that can be pointed at a real perimeter with a documented checklist.
Benchmark release. Publish the Isaac Lab environment and a small set of evaluation scenarios so other teams can compare C-UAS approaches on a common foot
Log in or sign up for Devpost to join the conversation.