Outcast Virus: Autonomous Swarm Intelligence for Contested Environments

The Problem

Modern battlefields move faster than human decision-making. Operators are overloaded, communications are jammed, and GPS is the first thing an adversary kills. The cost of a wrong call, such as engaging a friendly, missing a threat is irreversible. We built Outcast Virus because we believe the answer isn't replacing the soldier. It's giving them a swarm that can think, navigate, and coordinate without any of the infrastructure they can't count on.

What We Built

Outcast Virus is a GPS-denied autonomy operating system for unmanned platforms — drones, ground rovers, or any combination. It runs on edge hardware (Jetson Nano), requires no cloud connectivity during deployment, and exposes a unified real-time dashboard so operators can monitor, confirm, and override anything the system does.

The architecture is built around four integrated verticals that feed into a single WebSocket control bus:

Navigation — Stereo Visual SLAM

Without GPS, you need to know where you are. We run ORB-SLAM3 in stereo mode on an OAK-D Lite camera, giving us full 6-DoF pose estimation (position + quaternion) at ~15 Hz using only onboard cameras. No satellite dependency, no spoofing surface.

The pipeline is: depthai_ros_driver → image_proc rectification → ORB-SLAM3 stereo node → outcast_virus_slam_bridge — all as composable ROS2 nodes. The bridge converts ROS2 poses into JSON and streams them over WebSocket to the dashboard, where they're rendered as a live 3D trajectory using Three.js. Optionally, the system fuses IMU data for stereo-inertial mode when the OAK-D's IMU is available.

Perception — Edge AI Targeting with Human Confirmation

The perception stack runs YOLO11n (5.7 MB, TensorRT-exported for Jetson) for object detection, Norfair for multi-object tracking, and OSNet-x0.25 (via torchreid) for person re-identification across occlusions and camera cuts.

The pipeline per frame:

YOLO11n inference at FP16 (640px input, 0.4 confidence threshold)
Norfair tracker assigns stable track IDs using euclidean distance
OSNet extracts 512-D L2-normalized feature vectors from person crops
A candidate buffer scores detections by confidence × recency
Detections broadcast over WebSocket as normalized bounding boxes with class, confidence, track ID, and face flag

Face detection runs OpenCV Haar Cascade on any cropped person bounding box, flagging detections that contain a visible face. This feeds into our IFF pipeline.

Swarm Coordination — Decentralized Multi-Agent RL

The swarm runs a MAPPO (Multi-Agent PPO) policy trained with Centralized Training, Decentralized Execution (CTDE). During training, a centralized critic sees global state; during deployment, each agent acts only on its own 48-dimensional local observation. Zero inter-agent communication is required at inference time.

Observation space (per agent, 48D):

Own position + velocity (4D)
K=3 nearest-neighbor relative positions (6D)
Local 5×5 coverage patch (25D)
M=3 nearest obstacle positions (12D)
Role/goal flag (1D)

Reward: shared team reward combining new cell coverage, crowd penalty, boundary gradient penalty, scenario-specific objective shaping, and collision penalty.

The environment runs five hard-coded scenarios: drone-vs-drone, moving-target-track, search-and-interdict, defend-asset, and swarm-vs-swarm-race. Each has configurable battlefield parameters such aswind speed, GPS denial noise level, jamming duty cycle, attrition rate, battery envelope, so policies train under degraded conditions, not clean-room assumptions.

Trained policies export to ONNX and run either in-browser via onnxruntime-web (WASM/WebGPU) or on Jetson via TensorRT. The swarm simulation itself also runs in TypeScript in the browser (sim.ts + policy.ts), so the dashboard can visualize a live policy rollout without any Python backend.

The Integration Spine

Every vertical plugs into outcast_virus/ — a Python orchestrator that runs a WebSocket server on port 8000 (control messages) and port 8001 (JPEG video streams). Modules publish JSON messages tagged by topic; the router broadcasts to all subscribed dashboard clients.

Bus topics:

pose — 6-DoF VSLAM camera pose at 15 Hz
detections — YOLO + tracker output (bbox, class, track ID, face flag)
swarm — RL agent positions, roles, alive status at 10 Hz
train — live training metrics (reward, coverage, losses) at 1–2 Hz
slam_path, slam_point_cloud — dense mapping data for 3D rendering

The schema is validated via Pydantic on the server side. Modules that aren't available (e.g., ROS2 nodes not running) are gracefully degraded and nav falls back to a mock pose publisher, keeping the dashboard live.

The Dashboard

Built in React 19 + TypeScript + Vite, rendered with Three.js for all 3D views.

Outcast Virus panel (live hardware):

Camera feed from drone with YOLO detections overlaid in real time
Target lock state machine UI (proposed → followed → confirmed)
ReID gallery showing confirmed identities
3D VSLAM trajectory with point cloud overlay

Swarm panel (simulation):

3D drone models with trajectory tails, rendered from the RL policy rollout
Kill-agent button to test degraded-swarm behavior live
Scenario selector and battlefield parameter sliders

Training dashboard:

Scenario selection, swarm size, timestep budget
Live reward / coverage curves (Recharts) streaming from the training backend
Export button to push trained ONNX policy into frontend/public/policies/

What's Next

The hardest problems are still ahead. Edge inference on more constrained hardware. Swarm behavior under active jamming, not just simulated noise. Robust IFF in low-light and occluded conditions. And the question every autonomous weapons system eventually has to answer: how do you keep a human meaningfully in the loop when decisions happen faster than human reaction time?

Tech Stack

Component	Technology
Navigation	ORB-SLAM3 (stereo / stereo-inertial), OAK-D Lite, ROS2
Perception	YOLO11n, Norfair MOT, OSNet-x0.25 ReID, OpenCV Haar Cascade
Swarm RL	MAPPO/CTDE, PyTorch, Gymnasium, PettingZoo, ONNX
Edge Runtime	Jetson Nano, TensorRT FP16, onnxruntime-web
Integration Bus	Python WebSockets, Pydantic, FastAPI
Frontend	React 19, TypeScript, Vite, Three.js, Recharts
Package Management	Bun (frontend), uv (Python)

Renames applied: | Was | Now | |-----|-----| | CombatOS | Outcast Virus | | combatos/ | outcast_virus/ | | combatos_slam_bridge | outcast_virus_slam_bridge | | CombatOS panel | Outcast Virus panel |

Want this saved as a file in the repo (e.g. ARCHITECTURE.md or Devpost copy)?