Strata · Physical AI · 2026-11

Strata for physical AI: flying a drone with an LLM

An attempt to use Strata, which runs large MoE models on an ordinary PC and which we have been measuring in Strata research, for a robot's decisions. For now it is a drone simulator: the LLM looks at pictures and decides where to look, which object is the target and what to do next, while a program handles the fine movements.

LLM PC
Core i7-7800X + RTX 5060 Ti 16 GB
Simulator PC
Xeon E5-2630 v2 × 2 + RTX 3060 12 GB
Connection
Same wired LAN, no cloud
Vehicle control
AirSim Python API, ROS 2 Jazzy
LLM
Strata 0.2.13 (Qwen3.8-Flash-Next) and others
Setup

Setup: two PCs connected over the LAN

The simulator and the LLM run on separate PCs. The two are wired to the same LAN (1 Gb/s on both); no internet cloud is used. Both are the machines on which Strata research measured LLM speed.

RoleCPURAMGPUOSRuns
Simulator and flight programXeon E5-2630 v2 × 2 (AVX only, 2013 generation)251 GiBRTX 3060 12 GBFedora 45Unreal Engine 5.8 + Cosys-AirSim (Blocks map, rendered offscreen), the flight program (Python), ROS 2 Jazzy (container), recording
LLMCore i7-7800X (6 cores, AVX-512)125 GiBRTX 5060 Ti 16 GB (one card for now)Fedora 45Strata 0.2.13 or llama.cpp b12387 (OpenAI-compatible API)
Mission

The mission: find the orange ball, line up directly above it, and land right next to it

Every test on this page uses the same mission. The first instruction given to the LLM was this (the original is in Japanese):

近くにあるオレンジ色の球を探してください。見つけたらその真上・高度15mまで移動し、カメラを真下に向けて撮影して、球が画像の中央に来るよう位置を合わせてください。最後に球のすぐ横に着陸してください。

“Find the orange ball nearby. Once found, move directly above it at 15 m altitude, point the camera straight down and take a picture, and adjust the position so the ball is in the center of the image. Finally, land right next to the ball.”

News · 2026-11-15

An 8B embodied VLM (Cosmos-Reason2-8B) did not complete this mission, with or without thinking; Strata with Qwen3.8-Flash-Next landed in 292 s

Cosmos-Reason2-8B (Qwen3-VL based, 8B), released by NVIDIA for embodied reasoning in robots and driving, flew the same mission on llama.cpp b12387 (Q8_0, images on the GPU) once without and once with thinking, next to one run of Strata 0.2.13 (Qwen3.8-Flash-Next NVFP4, images on the GPU, no thinking). All on one RTX 5060 Ti. The 8B model fits entirely on the GPU, so each answer is quick. For the thinking run, as in the official inference tool, every prompt ended with the instruction to reason inside <think>…</think> before answering (up to 4096 output tokens, temperature 0.2 as in the other runs). The flight program received only the answer, with the thinking removed.

RunResultTotalLLM calls (with image)Total LLM waitPer call
Strata + Qwen3.8-Flash-NextLanded, done292 s19 (4)163 s8.6 s
llama.cpp + Cosmos-Reason2-8B (no thinking)Did not land (answered “landed” and done)483 s27 (14)64 s2.4 s
llama.cpp + Cosmos-Reason2-8B (thinking)Did not land (hit the 30-step limit)399 s30 (19)80 s2.7 s

Side-by-side page of the three runs: the mission given at the start, the chase and onboard-camera videos, and for each step the prompt sent, the image shown, the LLM's answer and the drone's response, for any two runs side by side. For the thinking run, each step's thinking can be read too (in Japanese).

Strata vs llama.cpp · 2026-11-15

Flying a simulated drone with an LLM, Strata was also faster and steadier: 305 s on average with all 3 runs finished (llama.cpp: 428 s, 2 finished)

A second PC on the LAN (RTX 3060) ran a drone simulator, Unreal Engine 5.8 with Cosys-AirSim, and the LLM on this PC made the flight decisions. The task: find the orange ball nearby, line up directly above it at 15 m, and land right next to it. The LLM picks where to look, which object is the target and what to do next; a program handles checking the color, lining up and landing. With the same instruction, we flew it 3 times each on Strata 0.2.13 (our everyday NVFP4 setup, images read on the CPU) and llama.cpp b12387 (UD-Q4_K_XL, -ub 2048, images read on the GPU). Both used a single RTX 5060 Ti, with thinking off.

RunResultTotalLLM calls (with image)Text-only callCall with image
Strata 1Landed, finished287 s11 (4)7.7 s34.0 s
Strata 2Landed, finished437 s21 (7)8.5 s28.0 s
Strata 3Landed, finished190 s9 (1)7.4 s49.1 s
llama.cpp 1Landed, finished325 s14 (5)11.9 s21.8 s
llama.cpp 2Landed on step 30, hit the step limit before finishing617 s30 (8)12.9 s22.6 s
llama.cpp 3Landed, finished341 s14 (5)11.7 s22.6 s
Strata averageAll 3 finished305 s13.7 (4.0)7.9 s33 s
llama.cpp average2 finished428 s19.3 (6.0)12.3 s22.4 s

Step limit 30, temperature 0.2. Per-call times are averages within each run.

Update: with Strata also reading images on the GPU, calls with an image take about a third of the time

We built Strata's image reader with CUDA and flew the same task 3 more times with images read on the GPU, everything else as in our everyday setup. On a single GPU the reader starts with the first image (about 2 s) and stops after 120 s without one. For that, 2 GB of VRAM is set aside, so the room for experts went from 5.6 GB to 4.2 GB.

Average of 3 runsResultTotalLLM calls (with image)Total LLM waitText-only callCall with image
Strata, images on the CPU (table above)All 3 finished305 s13.7 (4.0)204 s8.0 s31.8 s
Strata, images on the GPUAll 3 finished322 s18.7 (5.3)166 s8.2 s10.6 s
llama.cpp, images on the GPU (table above)2 finished428 s19.3 (6.0)300 s12.4 s22.4 s

Per-call times are averages over every call in the 3 runs. The three GPU-image runs took 175, 416 and 374 s.

Update 2: through ROS 2 as well, the task was completed end to end

So far the drone was flown through AirSim's Python API. We also built a version that flies the same task only through ROS 2 Jazzy (Cosys-AirSim's ROS 2 bridge, airsim_node). The LLM's instructions and decisions, and the tools that check the color, line up and land, are unchanged; only the vehicle state, camera angle, image capture, movement, takeoff and landing were moved onto ROS 2 topics and services.