InstinctFlash: open-source runtime runs 5B world-action models on Jetson Thor and RTX GPUs

General-Instinct has released the full source of InstinctFlash, a serving runtime for robotics models whose Show HN title bills it as running 5-billion-parameter world-action models in real time on NVIDIA's Jetson Thor module. The project reached the Hacker News front page on September 22, linking to a GitHub repository whose changelog dates the full-source release to September 15, 2026, followed by RTX 4090 support on September 16 and RTX 5090 support on September 17.

What it runs

According to the repository, one Runtime API covers eight robotics model families: LingBot-VA (the 5B world-action model), LingBot-VLA-4B, LingBot-VLA-V2-6B, pi0.5 from the LeRobot ecosystem, NVIDIA's GR00T N1.7-3B, NVIDIA's Cosmos3 Edge and Nano DROID policies, and DreamZero. Fine-tuned checkpoints are treated as the expected case: pointing instinctflash serve at a training output lets the tool detect the family, write a small JSON declaration based on what the checkpoint itself proves, and start serving. Anything the checkpoint cannot prove is requested explicitly instead of guessed.

The benchmark numbers

The headline claim is up to 33.78x speedup on Jetson Thor with LingBot-VA, with the maintainers saying they saw no loss of task performance in their real-robot tests. The repository is candid, though, that this figure folds in a cut to the sampling schedule from 25V/50A to 2V/4A. Like-for-like p50 prediction latencies, measured September 15, 2026 on Jetson Thor, show smaller but still large gains across the table:

• pi05 (FP8): 408.58 ms to 51.85 ms, 7.88x
• LingBot-VA (FP8, full 25V/50A schedule): 15,506.32 ms to 2,891.74 ms, 5.36x; at 2V/4A, 2,071.29 ms to 459.10 ms, 4.51x
• Cosmos3 Edge DROID (numerical solver changes): 3,393.78 ms to 1,048.01 ms, 3.24x
• LingBot-VLA-4B (FP8): 624.22 ms to 221.53 ms, 2.82x
• Cosmos3 Nano DROID: 10,184.68 ms to 4,772.38 ms, 2.13x
• DreamZero DROID (FP8, 16 steps, dynamic cache): 23,563.08 ms to 11,899.42 ms, 1.98x
• LingBot-VLA-V2-6B (FP8): 734.56 ms to 394.11 ms, 1.86x
• GR00T N1.7 (bit-exact transformations only): 139.50 ms to 117.30 ms, 1.19x

Precision changes are opt-in

The notable design decision is the precision policy. The Runtime defaults to native precision under a bit-exact transformation ceiling, meaning only changes that do not alter numerics are applied automatically. FP8 quantization, numerical compilation and reduced step schedules are explicit opt-ins via precision and tier-ceiling settings, and DreamZero's dynamic step cache sits behind a separate behavioral tier. Every acceleration that could change outputs is a disclosed choice rather than a silent default.

Serving, validation and reproduction

Network serving uses the msgpack-over-WebSocket protocol that the pi0/openpi ecosystem already speaks, so existing robot-side clients built on openpi-client connect without modification. The operational flags are practical: a dry-run preflight that needs neither weights nor a GPU, a smoke mode that loads a model and emits one action, seeding for paired comparisons (rejected under FP8), and streaming of observations, actions and latency to a Rerun viewer.

A validate verb checks whether a checkpoint is publishable and can certify non-inferiority against teacher and student outcomes with an explicit margin, stamping the certificate into the package. An eval verb produces reports that separate latency, action agreement and simulator task success, with guides for paired LIBERO and RoboTwin experiments. Benchmark reproduction scripts emit checked JSON/CSV reports and full action arrays, and a serving smoke test exercises the actual CLI and WebSocket pipeline.

Installation is layered: a Python 3.10+ core inspects checkpoints and builds plans without PyTorch or a GPU, while inference runs in pinned per-family environments — Python 3.12 for most families and 3.13 for Cosmos3 Edge and Nano — bootstrapped with upstream sources and compatibility patches. Model weights are downloaded separately.

Why it matters

Vision-language-action and world-action models are the current direction in general-purpose robot control, but their size makes edge inference the bottleneck: a policy that needs seconds per prediction cannot close a control loop. A single runtime spanning Jetson Thor and consumer GPUs, covering eight model families with one API, gives labs that fine-tune these checkpoints serving infrastructure they would otherwise have to build per model. Treating quantization as an explicit, auditable choice, and shipping tooling that certifies non-inferiority, pre-empts the standard 'faster but worse?' objection. The caveats are real: all figures are the project's own measurements, and the 33.78x headline includes a sampling-schedule change. But with published raw results and reproduction commands, independent verification is at least possible — more than most serving-framework launches offer.