PLATFORM

The Kestrelsense Sensing Stack

A three-layer architecture built for platforms where every gram, millisecond, and milliwatt is accounted for. Sensor Layer handles payload diversity through a hardware abstraction layer. Edge Compute Layer runs compressed neural inference on Jetson Orin, Hailo-8, or custom FPGA. Mission Interface Layer publishes structured outputs to ROS 2 nodes, GCS APIs, and HOTL supervisor interfaces — fully on-device, fully air-gapped.

< 50 ms

End-to-end inference latency

< 15 W

Total edge compute envelope

3

Sensor modalities supported

0

Cloud dependencies

SYSTEM ARCHITECTURE

Three layers. No external dependencies.

SENSOR LAYER EO/IR Imaging Payload mmWave Radar FMCW / Doppler Acoustic MEMS Array HAL Hardware Abstraction EDGE COMPUTE LAYER Jetson Orin 275 TOPS / 15W Hailo-8 26 TOPS / 2.5W Custom FPGA Deterministic latency Inference Runtime Engine MISSION INTERFACE LAYER ROS 2 Nodes GCS API MAVROS Bridge HOTL Interface

LAYER 01

Sensor Layer

The sensor layer handles payload diversity without requiring custom integration work per sensor type. A hardware abstraction layer normalizes timing, format, and transport from any combination of EO/IR, mmWave, and acoustic sensors.

EO/IR

  • Electro-optical and infrared imaging
  • Day/night operation profiles
  • Raw frame ingest at up to 120fps
  • MIPI CSI-2 / USB3 / GigE interfaces

mmWave Radar

  • 76–81 GHz FMCW chirp radar
  • Range / Doppler / AoA processing
  • Operates in degraded visibility
  • RF interference mitigation built-in

Acoustic

  • Multi-element MEMS microphone arrays
  • Sound event detection and localization
  • Wind / rotor noise cancellation
  • Passive signature classification

LAYER 02

Edge Compute Layer

Neural model compression, quantization, and runtime selection are made at system integration time — not at inference time. The stack selects the most power-efficient compute substrate for each model's latency requirement.

model_deployment.py — compression pipeline 
# Kestrelsense inference pipeline — edge deployment
from kstr.runtime import InferenceEngine, HardwareTarget
from kstr.compress import quantize_int8, prune_structured

# Compress model for target hardware
model = quantize_int8(base_model, calibration_data)
model = prune_structured(model, sparsity=0.4)

# Deploy to hardware target
engine = InferenceEngine(
    target=HardwareTarget.HAILO8,
    latency_budget_ms=40,
    power_budget_w=12
)
engine.load(model)
# Inference at mission latency
output = engine.run(sensor_frame)
Edge compute hardware board for embedded AI inference

LAYER 03

Mission Interface Layer

Structured detection and tracking outputs are published to operator displays and autonomous decision loops via standard protocols. The human-on-the-loop interface ensures override capability is always present.

ROS 2 Interface

  • Publishes detection/track messages
  • Compatible with Nav2 / behavior trees
  • DDS-based zero-copy transport
  • Lifecycle node architecture

GCS API

  • MAVLink telemetry integration
  • Operator display data feed
  • Alert and event notification
  • Bandwidth-adaptive streaming

Human Override

  • Real-time interrupt interface
  • Decision confidence threshold alerts
  • Operator review queue
  • Audit log for post-mission review

ENGAGE

Evaluating an edge-AI sensing stack for your program?

Technical briefings cover integration architecture, hardware target selection, latency budget analysis, and SWaP characterization for your specific platform and operational profile. Available to DoD program offices, prime systems integrators, and defense R&D labs. NDA execution precedes detailed disclosure.

Request Technical Briefing