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.
| Role | CPU | RAM | GPU | OS | Runs |
|---|---|---|---|---|---|
| Simulator and flight program | Xeon E5-2630 v2 × 2 (AVX only, 2013 generation) | 251 GiB | RTX 3060 12 GB | Fedora 45 | Unreal Engine 5.8 + Cosys-AirSim (Blocks map, rendered offscreen), the flight program (Python), ROS 2 Jazzy (container), recording |
| LLM | Core i7-7800X (6 cores, AVX-512) | 125 GiB | RTX 5060 Ti 16 GB (one card for now) | Fedora 45 | Strata 0.2.13 or llama.cpp b12387 (OpenAI-compatible API) |
- The LLM is called over the LAN. On every step, the flight program on the Xeon PC calls the LLM on the i7-7800X PC (an OpenAI-compatible API through an SSH tunnel), with the pictures it took inside the call. The LLM PC never touches the simulator; it only answers.
- “LLM wait” in the tables includes the LAN round trip. It is the time from when the flight program sends a call until it gets the answer. A picture is about 0.3 MB, which takes about 0.01 s at 1 Gb/s, so almost all of the wait is the LLM's computation.
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.”
- Scene: the drone starts at the takeoff point (the origin). The ball's location is not given (it is about 90 m to the north).
- The LLM's job: each call, it answers with exactly one next action in JSON: take off, move, take a picture, take pictures in 4 directions, move to a target it points at in an image, line up, land beside, or done. A program handles the fine movements of lining up and landing. Each action's result and the drone's state go into the next call, with the image when a picture was taken.
- Conditions: at most 30 steps, temperature 0.2, no thinking.
- Success: line up above the ball, land right next to it, and answer “done”.
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.
| Run | Result | Total | LLM calls (with image) | Total LLM wait | Per call |
|---|---|---|---|---|---|
| Strata + Qwen3.8-Flash-Next | Landed, done | 292 s | 19 (4) | 163 s | 8.6 s |
| llama.cpp + Cosmos-Reason2-8B (no thinking) | Did not land (answered “landed” and done) | 483 s | 27 (14) | 64 s | 2.4 s |
| llama.cpp + Cosmos-Reason2-8B (thinking) | Did not land (hit the 30-step limit) | 399 s | 30 (19) | 80 s | 2.7 s |
- Cosmos answered fast, about 2.4 s per call, but never found the ball. Each time it looked at the 4-direction pictures it said the ball was not there, and it wandered about 210 m to the north-east at 15–50 m altitude. The ball is about 90 m to the north; Strata found it in the north picture from 30 m.
- It also did not keep to the answer format. It never used the action that points at a target in an image, and at the end it wrote a move, a line-up and a landing in one answer, then returned done saying it had landed, although it had not.
- With thinking, it still did not find the ball. Its thinking was short, about 100 tokens per call, and all 30 times it concluded the ball was not in view. It stayed within 20 m of the takeoff point, repeating 4-direction pictures and going up and down (10–50 m), until it hit the step limit. It did keep to the answer format this time: exactly one JSON action per answer, and no false “done”.
- Scope. One run each. The thinking run used temperature 0.2 (the official default is 0.6). We have not yet tried other temperatures, or other 8B-class embodied VLMs.
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).
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.
| Run | Result | Total | LLM calls (with image) | Text-only call | Call with image |
|---|---|---|---|---|---|
| Strata 1 | Landed, finished | 287 s | 11 (4) | 7.7 s | 34.0 s |
| Strata 2 | Landed, finished | 437 s | 21 (7) | 8.5 s | 28.0 s |
| Strata 3 | Landed, finished | 190 s | 9 (1) | 7.4 s | 49.1 s |
| llama.cpp 1 | Landed, finished | 325 s | 14 (5) | 11.9 s | 21.8 s |
| llama.cpp 2 | Landed on step 30, hit the step limit before finishing | 617 s | 30 (8) | 12.9 s | 22.6 s |
| llama.cpp 3 | Landed, finished | 341 s | 14 (5) | 11.7 s | 22.6 s |
| Strata average | All 3 finished | 305 s | 13.7 (4.0) | 7.9 s | 33 s |
| llama.cpp average | 2 finished | 428 s | 19.3 (6.0) | 12.3 s | 22.4 s |
Step limit 30, temperature 0.2. Per-call times are averages within each run.
- Text-only calls were faster on Strata: about 8 s against about 12 s. Each call reads about 1,100–1,400 tokens, so the prompt-read and decode gap from the comparison above shows up directly. About 70% of the calls in this task are of this kind.
- Calls with an image were faster on llama.cpp: about 22 s against about 33 s. llama.cpp reads images on the GPU. Our current Strata setup reads them on the CPU, so the first image in each run took about 50 s.
- The number of steps made the biggest difference overall. llama.cpp took more steps, for example climbing from 20 to 30 to 50 m while searching. In its second run it kept re-aligning around the ball; it landed on step 30 but hit the limit before saying it was done.
- Scope. The weights differ (NVFP4 on Strata, UD-Q4_K_XL on llama.cpp), so we cannot tell whether the step-count difference comes from the engine or the weights. Only 3 runs each, and even Strata ranged from 190 to 437 s.
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 runs | Result | Total | LLM calls (with image) | Total LLM wait | Text-only call | Call with image |
|---|---|---|---|---|---|---|
| Strata, images on the CPU (table above) | All 3 finished | 305 s | 13.7 (4.0) | 204 s | 8.0 s | 31.8 s |
| Strata, images on the GPU | All 3 finished | 322 s | 18.7 (5.3) | 166 s | 8.2 s | 10.6 s |
| llama.cpp, images on the GPU (table above) | 2 finished | 428 s | 19.3 (6.0) | 300 s | 12.4 s | 22.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.
- Calls with an image went from 31.8 s to 10.6 s, about half of llama.cpp's. The roughly 50 s for the first image of each run, seen when reading on the CPU, is gone as well.
- Text-only calls barely changed (8.0 s and 8.2 s). The image reader and the LLM do not run at the same time, so what they share is VRAM rather than compute time. The room for experts shrank by 24%, but that hardly mattered for these short calls.
- The LLM wait per flight fell by 19%, but the total time did not. Some runs took many more steps, for example repeating the same move just before landing. In this task the run-to-run spread in step count moves the total more than the speed of each call. Only 3 runs each.
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.
- One run went all the way from search to landing. It found the ball about 100 m to the north, lined up above it and landed right next to it: 492 s and 17 LLM calls (4 with an image), with Strata (images on the CPU) as the LLM. The flow matched the Python API runs. It took longer because, after landing, the LLM lined up and landed once more before reporting done. With a single run, speed cannot be compared.
- By default the ROS 2 bridge does not accept vehicle commands. Without
enable_api_control:=trueat launch, takeoff and velocity commands are ignored. Calling theresetservice also drops that permission, and ROS 2 has no way to grant it again, so we restart the bridge after every reset. - The axes differ between what you send and what you receive. Velocity commands are north-east-down (NED), while the position comes back as north-west-up. Yaw-rate commands are in radians per second, clockwise positive, and the camera angle is in degrees. We checked each with a small test before using it.
- Some things are not available through ROS 2: collision information and stopping the motors. Landing descends until touchdown and then sends zero velocity.