Everyframe · edge ISR
The drone sees a vehicle.
The uplink sends a track.
A drone follows a vehicle. On the aircraft, a Jetson Orin Nano runs detection and tracking, then sends the command centre a few bytes per frame: a locked track, not a video feed. The boxes and confidence below are the engine's real on-device detection and ByteTrack tracking, measured on the board.
A video link home is the liability. It is heavy, it is jammable, and it paints the aircraft on the spectrum. So the board keeps the pixels and sends only what it understood .
What follows is one clip, read three ways on the aircraft: lock the target, read the ground it is on, fix it to a coordinate. Then the same board's other reads on different footage, and an honest account of every claim.
Perception, not force. Everyframe turns a sensor feed into understanding: what is in the scene, where it is, how it moves, and hands that to an operator. It does not aim, decide, or act. We build situational awareness, not weapons, and a human stays in every decision.
The lock, live
The reticle tracks the vehicle frame by frame. The panel on the right is the command centre: the sparse telemetry the node actually sends, plus a video-versus-uplink bandwidth meter. A solid reticle is a real detection, an amber dashed one is a predicted in-fill across a dropout.
Uplink stream · ~68 bytes/record
The intelligence stream is -- lighter than the video. On a contested link you send the track, not the pixels.
Depth, on the same board
The Jetson runs depth-anything to estimate per-pixel depth. Left is the feed, right is that depth map: the ground plane recedes from the near road (bright) to the far horizon and pylons (dark). Absolute range in metres still needs the platform's altitude and gimbal angle, which is the fusion layer.
On the road, or off it
SAM segments the drivable surface under the target, pixel by pixel. Left is the feed, right is the same frame with the road masked and the vehicle's footprint tested against it: green reads ON ROAD, amber reads OFF ROAD. Section 01 named the surface with SigLIP2; this draws where that road actually is, so a track carries 'on the paved road, not the open sand', not just a position.
From a track to a coordinate
The command centre does not need the video to know where the target is. Feed the tracked footpoint through the platform's camera geometry and it lands on the map: ground range, bearing, and a grid reference. Top is the feed, bottom is that projection. This is the fusion op the live panel marks as roadmap, shown here on the real track with illustrative platform values (altitude, gimbal angle, heading). The geometry and the track are real; the platform numbers are stand-ins until the autopilot feeds them.
What the target is doing
Cue the sensor in tight and the same engine reads what a person is doing, not just where they are: standing, walking, running, prone, crawling. Keypoints come from RTMPose, a model the board already carries; the standing, walking and running call is read from the gait across a short window, not one frame, so a runner coming head-on is not mistaken for standing still. This is a close-look read: it needs pixels on the target, a body filling the frame rather than a speck at altitude, so it is a perch-and-stare or cued-zoom capability, not wide-area search.
A column, not a pixel
Detect and track do not stop at one target. Over a road or a lot the board holds every vehicle with a stable id and a running count, and the record home is still a few bytes per object, not a frame of video. One node can watch a junction and report the traffic as a list.
Movers, no label needed
Some targets have no class. Cancel the aircraft's own motion (ego-motion compensation) and whatever moves against the ground lights up, catching movement a class detector has no name for. The engine now implements this as an operation: classical geometry over the same frames, deterministic run to run. It is new and not yet field-validated, so we do not yet claim it as shipped. It assumes one ground plane, which holds over open terrain like this. Tall structures break that plane, so it wants flat country.
On the aircraft
No frame leaves the board. Detection, tracking, depth and surface run on the Jetson, and only the resulting track is sent home.
Detect 80-class
Every frame runs through an 80-class object detector on the Jetson's GPU. Each object returns a box, a class and a confidence.
Track ByteTrack
Per-frame boxes become a track. The vehicle carries one identity across the clip, so the command centre refers to a target, not a pixel position.
Depth depth-anything
The same GPU estimates per-pixel depth, so each track sits in near and far structure, not just a 2D box. Absolute range in metres still needs the platform's altitude and gimbal angle.
Surface SAM + SigLIP2
SAM segments the drivable surface and SigLIP2 names it, so each track carries the terrain under it, on the road or off it, not just a screen position. Class-agnostic segmentation finds the region; the label comes from the open-vocabulary classifier.
Fix platform fusion · roadmap
Projecting the track to a ground coordinate (section 04) is a typed geometric op. It needs the platform's altitude, gimbal angle and heading from the autopilot, so it is marked roadmap here and run with illustrative values, not a new system to procure.
Uplink jsonl / mqtt
One compact record per frame goes out over a narrow link: id, class, box and confidence. Scene, per-object surface and the coordinate fix join the record as those layers are wired onto the board. The command centre reconstructs the picture from kilobits, with no video ever transmitted.
What is real, and what is next
This is a working measurement, so here is the honest scope.
The boxes and confidence are the engine's real output. The 80-class detector and ByteTrack produced this track; the same models run fully offline on a Jetson Orin Nano Super at roughly 6 fps and 17 W, measured on the board. Confidence averages 0.38 because the vehicle is small at this altitude, a detector tuned to your objects would score higher.
The track is the engine's own, not an offline stitch. The detector drops the small vehicle now and then, and ByteTrack with persistFrames fills those gaps with Kalman-predicted boxes (the amber dashed reticle, 34 of the 250 frames here). The detector also flip-flops the vehicle between car and truck and some dropouts run long, so the engine emits a succession of track ids for the one vehicle; the demo joins them into a single TARGET by nearest-neighbour, since the drone follows one vehicle. Every box is a real detection or an engine Kalman prediction, none interpolated offline.
The coordinate fix uses illustrative platform values. Section 04 projects the real track to a ground coordinate with a real pinhole and flat-ground geometry, but the altitude, gimbal angle and heading are stand-ins. Range, size and ground speed are the same fusion layer. Fed the autopilot's GPS and IMU, these become live values; it is a typed operation the engine is built to add.
The scene label uses SigLIP2. A ground-trained classifier (places365) cannot read top-down aerial and misreads this desert as an 'airport terminal'. SigLIP2 reads the terrain correctly (desert, paved road, open sand), its top labels are shown above, real output on this clip. Wiring it into the engine's classify_scene op is in progress.
Target surface is per-object. 'Scene' is the whole frame; 'Target surface' is the terrain under the tracked vehicle, a crop at its position run through the same model each frame. That is the difference between 'this is a desert' and 'the vehicle is on the road', context per track rather than one tag for the image. Here it reads paved road for every tracked frame.
The road mask is SAM, and it is class-agnostic. SAM draws the drivable surface pixel by pixel but does not name it: the label 'road' comes from SigLIP2. The on-road test reads how much of that surface surrounds the target's footprint. On this clip the vehicle stays on the paved road, so it reads ON ROAD throughout, and a vehicle out on the open sand would fall outside the mask and flip it. The mask runs per frame, with the small SAM2 variant as the on-board weight.
The bandwidth number is measured on this clip. The video bitrate and the per-record uplink size are read straight from the files, not modelled.
The Reach reads run on other public footage. Pose uses RTMPose, a model the board carries, but it needs pixels on the target, so it is a close-look, cued-zoom capability, not wide-area search (footage: U.S. Army training, public domain). Scale is the same detect-and-track shown on aerial traffic (Pexels).
Moving-target indication is implemented, not yet field-validated. The engine now carries an ego-motion compensation op: seeded, deterministic classical geometry over the same frames. Validation on real aerial missions and fleet deployment come before we claim it as running, and the render here demonstrates the technique rather than the op's own output. A single ground plane holds over open terrain and breaks near tall structures. Shown on aerial desert footage (Pexels).
Powered by the Everyframe engine · perception, not force.