NVIDIA Jetson Orin on Satellites: What On-Orbit Edge AI Looks Like Today

Running NVIDIA Jetson Orin modules for AI inference aboard small satellites in low Earth orbit

A 7-year-old RAD750 runs at 200 MHz and pushes maybe 400 MIPS. A Jetson Orin AGX, sitting on a desk at any university lab, does 275 TOPS in a 60W envelope. Roughly 6 orders of magnitude of AI throughput, except the Orin isn’t rad-hard, and the RAD750 is.

That gap is why your downlink queue is full of raw pixels nobody’s looked at, and why a growing number of LEO operators have decided to fly Orin anyway. The question isn’t whether GPU-class inference belongs on orbit. It’s how to keep the silicon alive long enough to be useful, and whether your mission profile can absorb the risk.

Here’s where Orin actually fits in 2025, who’s flying it, and how to decide if it belongs on your bus.

Why Orin, And Why Now

The relevant parts for space:

  • Orin AGX: ~275 TOPS (sparse INT8), configurable 15-60W, 12-core Arm Cortex-A78AE, Ampere GPU with 2048 CUDA cores
  • Orin NX: ~100 TOPS, 10-25W, smaller footprint for tighter power budgets

Compare that to a LEON4 or RAD750 and the case writes itself: you can’t run a YOLO variant, a vision transformer, or a halfway serious cloud-detection CNN on flight-heritage processors without quantizing them into uselessness. EO sensors keep getting fatter (sub-meter multispectral, hyperspectral cubes, SAR), and ground stations didn’t get cheaper. Cloud screening onboard can cut downlink volume 40-70% on a typical optical EO mission, which is the kind of number that pays for the whole exercise.

What changed in the last 5 years: missions got shorter (3-5 year LEO instead of 15-year GEO), cubesats and ESPA-class buses normalized risk acceptance, and the COTS mitigation playbook matured. A 500 km sun-synchronous orbit behind 100 mil of aluminum sees roughly 5-15 krad TID over 5 years. That’s a number Orin can plausibly survive with the right design margin. GEO at 36,000 km isn’t.

Real Missions Flying Orin Today

Be honest about the announcement-to-flight gap, because it’s wide.

Confirmed on orbit:

  • Loft Orbital’s YAM-series buses have flown COTS edge compute payloads with GPU-class accelerators, including Jetson-family hardware on hosted payload slots. Loft’s whole pitch is exactly this: bring your payload, we handle the bus and the mitigation.
  • Several smaller EO and defense smallsats have flown Orin AGX or NX as payload processors, often through Aitech’s productized space computer. Public detail is patchy because some are classified or proprietary.

Manifested or in integration:

  • Lockheed Martin has publicly discussed Orin in tech demonstrator contexts (Pony Express follow-ons, autonomy experiments). Some of this is flown, some is integration-stage. Read the press releases carefully: “selected” and “integrated” aren’t “operational on orbit.”
  • Antaris publishes reference architectures that incorporate Jetson for payload processing in their software-defined satellite stack. Customer missions using these designs are in various stages.

Announced intent:

  • A long list of EO startups have said they’ll use Orin. Treat these as roadmap signals, not flight heritage.

Across every confirmed deployment, Orin sits on the payload side. Flight computers are still rad-tolerant FPGAs or MCUs. Orin handles the inference workload, gets watchdogged by something rad-tolerant, and gets power-cycled when it misbehaves.

Buy vs. Build: The Productized Options

You don’t have to design the mitigation stack yourself.

  • Aitech S-A1760 Venus: Productized Orin AGX-based space computer. Conduction-cooled, screened parts, integrated watchdog, sold as a flight unit. Probably the fastest path to flying Orin without building your own avionics.
  • Unibap iX10: AMD-based, not Orin, but the closest direct competitor in the payload AI tier. Worth a look if you’re shopping.
  • Ramon.Space: Different philosophy entirely. Rad-hard AI accelerators (RC64 and successors) built ground-up for space. Lower TOPS, much higher rad tolerance. The right answer for some missions, wrong answer for transformer-heavy workloads.

If your team isn’t ready to characterize a COTS module, qualify it, and design the supervisor logic, Aitech is doing roughly $10-15M of NRE for you.

The Three Real Concerns

Radiation

Is Jetson Orin radiation hardened? No. It’s an 8nm Samsung-process consumer/automotive part. Public TID test data on Orin specifically is still thin. What we know from related Tegra-family parts and early Orin test campaigns suggests TID survival in the 15-30 krad range with significant part-to-part variance. That’s enough margin for short LEO, nothing you’d bet a flagship on.

SEEs are the bigger operational worry: SEUs in DRAM and cache, SEFI in the GPU pipelines, latch-up risk in the PMIC and rails. The mitigation stack everyone converges on:

   +------------------------+
   | Application (TensorRT) |
   +-----------+------------+
               |
   +-----------v------------+
   |   Checkpoint / retry   |
   +-----------+------------+
               |
   +-----------v------------+      +------------------+
   |   Jetson Orin (COTS)   |<---->| Rad-tol watchdog |
   +-----------+------------+      |   (FPGA / MCU)   |
               |                   +--------+---------+
   +-----------v------------+               |
   |  Power switch / reset  |<--------------+
   +------------------------+

Concrete elements: external watchdog on a rad-tolerant FPGA (Microsemi RTG4, PolarFire) or a Vorago MCU, hard power switch with latch-up current trip, ECC DRAM where the carrier supports it (most Orin modules do), application-level checkpointing every N inferences, and a redundant Orin pair for missions that can afford it. Duty-cycled operation (inference only over targets, GPU off otherwise) cuts effective TID exposure significantly.

Thermal

60W in vacuum with no convection means your conduction path is the entire thermal design. Orin’s junction limit is 105°C; you want margin to 85°C in worst-case hot orbit.

Typical integration: cold plate bonded to the module, thermal straps to a radiator panel, and sometimes a phase-change material slug for burst inference workloads where you’d rather absorb heat than size the radiator for peak. Thermal throttling on Orin is aggressive (it’ll downclock the GPU before it dies), so the failure mode is degraded throughput, not loss of mission. That’s actually useful design slack.

Power

A 100-200 kg ESPA-class bus typically has 100-300W orbit-average. An Orin AGX in MAXN mode can eat 60W of that, sustained, which is rarely the right answer.

The realistic operating profile is bursty: nvpmodel set to 15W or 25W as the default, ramp to MAXN only during inference passes, idle the GPU between targets. Mission ops scripts that match power state to ground-track geometry are doing real work here. Battery sizing follows: you need enough capacity to absorb a few minutes of MAXN per orbit without dragging SOC below your eclipse minimum.

Orin vs. Versal AI Edge vs. PolarFire SoC 

                    | Jetson Orin AGX | Versal AI Edge   | PolarFire SoC
--------------------+-----------------+------------------+------------------
Peak AI perf        | ~275 TOPS       | ~75 TOPS (VE2302)| ~1-2 TOPS (soft)
Power envelope      | 15-60W          | 6-75W            | 2-10W
Radiation posture   | COTS, mitigated | COTS / rad-tol*  | Rad-tolerant variants
Toolchain           | CUDA, TensorRT  | Vitis AI         | HLS, Libero, soft NN
Best fit            | Heavy CNN/      | Sensor fusion,   | Always-on,
                    | transformer     | deterministic    | low-power, platform
                    | inference       | DSP + AI         | critical
* AMD space-grade Versal lineage is still emerging; Microchip ships rad-tol PolarFire today

Orin wins when raw throughput on modern vision and transformer models is the constraint, mission is short, and the role is payload-side.

Versal wins when you need deterministic latency, mixed DSP and AI workloads (SAR processing, RF), or a tighter radiation spec than COTS Orin can meet.

PolarFire wins when you need always-on, low-power, platform-critical compute with rad-tolerant variants already qualified. It won’t run a transformer at any reasonable rate, and that’s not the job.

Is Orin Right For Your Mission?

Run through this before the decision meeting:

  1. Orbit and duration. LEO under 600 km, mission under 5 years: Orin is in scope. MEO, GEO, or 10+ year missions: probably not.
  2. Criticality tier. Payload-side inference where degraded operation is acceptable: yes. Platform-critical control loops: no.
  3. Workload shape. CNN, transformer, or anything that wants CUDA: Orin. Deterministic DSP plus light AI: Versal. Always-on supervisor: PolarFire.
  4. Power headroom. Can your bus absorb 25-60W bursts without compromising the rest of the payload? If not, drop to Orin NX or rethink.
  5. Mitigation engineering appetite. Comfortable building the watchdog, qualification, and ops scripts? Build. Want to skip that work? Aitech S-A1760 Venus.
  6. Schedule. Productized space computers shave 12-18 months off a custom integration. Sometimes that matters more than the BOM cost.

Payload-side CNN or transformer inference, LEO, 3-5 year mission, power headroom, mitigation appetite: Orin is a credible choice. The silicon isn’t the hard part anymore. The mitigation stack is.

Build The Supervisor Before The Inference Pipeline

Orin on orbit is a payload-tier component with a maturing mitigation playbook, productized options for teams that don’t want to build their own, and enough flight history (mostly through Loft Orbital and Aitech-based integrations) to anchor design decisions.

Start with the mission profile. Pin down TID exposure, criticality tier, and workload shape first. Then pick the silicon that fits, accept the mitigation work that comes with it, and build the supervisor logic before you build the inference pipeline. The teams that get this wrong bolt the watchdog on at the end.

Hubble Network provides global Bluetooth connectivity from LEO, enabling low-power telemetry from edge devices without ground infrastructure. See how it works →