Gyro-M, the medium-size variant of Qwen3.8-Flash-Next-Gyro, runs on a 16GB graphics card and passes every hands-on coding task in a six-part test suite. It also posts near-perfect scores on long-context retrieval and a Python coding benchmark. Yet the smaller Gyro-S finishes most of the same projects with similar results, so the case for switching rests more on your hardware and on how much tool reliability matters to you than on the quality of the finished code.

The test rig: 16GB of VRAM and 64GB of DDR4

The model file under test is Qwen3.8-Flash-Next-Gyro-M-TQ2_0.gguf, a 9.2 GB quantization. Quantization compresses a model's weights so the model fits in less memory. The file is served locally with Strata, a model-serving framework, with a 128k-token context window.

The inference hardware represents a 16GB-class local setup:

  • Operating system: Ubuntu Server 24.04.4
  • Motherboard: ASUS TUF Gaming X570-PLUS
  • CPU: AMD Ryzen 5700X
  • Inference GPU: NVIDIA RTX 2000 Ada Generation with 16GB of VRAM
  • Secondary GPU: RTX 5090 with 32GB of VRAM, which assists with test automation
  • System memory: 64GB of DDR4 at 3600MHz, in four 16GB DIMMs
  • Storage and power: a 2TB Gen4 SSD and a 1200W ATX power supply

The system memory was raised to 64GB for a specific reason: it lets Strata keep large models in memory without offloading context to the SSD.

Speed: prefill and decode

Two numbers describe how fast a local model feels. Prefill is the rate at which the model reads the prompt. Decode is the rate at which it writes its answer.

Cold prefill, where nothing is cached, climbs as the prompt grows:

Prompt size Cold prefill (tokens per second)
512 tokens 354.4
2k tokens 633.8
8k tokens 941.3
16k tokens 1,002.0
32k tokens 1,025.0

When the prompt has already been processed and stored in the key-value cache, prefill is far faster. Cached prefill starts at 2,645.2 tokens per second on a 512-token prompt and reaches 96,123.8 tokens per second on a 32k prompt.

Decode speed stays steady on the 16GB card. A short 256-token generation runs at 54.9 tokens per second, an 8k generation at 48.2 tokens per second, and the summary scorecard for the full run lists decode at 57.8 tokens per second.

Memory and reasoning

Long-context retrieval

A needle-in-a-haystack test hides a passkey inside a very long document and asks the model to find it. The test here spans 125,536 context tokens and 15 trials, with the passkey placed at depths of 0%, 25%, 50%, 75% and 100% of the document.

Gyro-M passes all 15 trials in 3 minutes 48 seconds. Every depth scores 100%. The 75% depth appears to be the hardest zone, because the model produces noticeably longer internal reasoning traces there before it answers correctly.

Logic and probability

The reasoning benchmark contains 48 logic and probability problems in four tiers. Gyro-M passes 41 of them, or 85.4%, with an average latency of 3,889 ms and a total runtime of 3 minutes 6 seconds.

Tier Passed Rate
Easy 12 of 12 100%
Medium 12 of 12 100%
Hard 11 of 12 91.7%
Expert 6 of 12 50.0%

The pattern points to strong general logic with clear limits at the top tier. A 50% Expert score looks decent for a local model, though not exceptional next to frontier commercial models.

HumanEval Remix: one miss in 100

HumanEval Remix is a set of 100 Python programming tasks. Gyro-M answers all 100 and solves 99 correctly on the first attempt, a 99% pass rate. The run takes 18 minutes 30 seconds, with an average latency of 11,101 ms per task.

Person with a clipboard facing a ten by ten wall of glowing tiles with one dark tile near a corner

▲ A single miss in 100 coding tasks

A single failure is an impressive result. It also suggests the benchmark may be getting too easy for top local models and may need harder problems before the next generation, such as Qwen 4, arrives.

Six hands-on tasks, compared with Gyro-S

Benchmarks only go so far, so the suite also includes six build tasks. Gyro-M passes all six. The useful measure here is how much help each model needs. Two terms matter. A compaction is a point where the session condenses earlier context to free up room. Context usage is the share of the context window in use, which the session logs count as 131k tokens.

Workbench with six miniature models: tables, a sand box, a stone maze, a lantern, platforms and a village

▲ The six hands-on coding challenges

Task Gyro-M Gyro-S
Event seating planner 0 compactions, 57.5% context, no extra prompts 2 compactions, 42% context, same-table guest dragging missing
Sand Physics 2.0 1 compaction, 62.3% context 0 compactions, 84% context, one extra prompt after a test timeout hang
Dungeon Crawler 2.0 2 compactions, 59% context, no extra prompts 2 compactions, 81% context
Blender lantern 2 compactions, 53.5% context, no extra prompts 1 compaction, 49% context, repeated Blender crashes during screenshot capture
Godot 3D platformer 6 compactions, 55.8% context, one corrective prompt 5 compactions, 81% context
Fishing village diorama 3 compactions, 71.7% context Not reported

Event seating planner

The web app lets a user add tables, drag them around, and move guests between seats at the same table or across tables. It includes an inspector sidebar, guest search, filters by party type such as family, VIP or staff, toast notifications, and a dark and light theme switch. All 49 npm tests pass with zero failures. Gyro-M uses about 75.6k tokens and needs no intervention. This is its clearest win: the Gyro-S version could not drag guests within the same table.

Sand Physics 2.0

This browser simulation models falling sand, water, oil that floats on water, walls, fire that burns the oil layer, and lava that boils water into steam. Gyro-M finishes after one compaction, using 82.1k of 131k tokens. Gyro-S needed no compaction but required an extra prompt when a test run hung on a timeout. The two models are roughly tied here.

Dungeon Crawler 2.0

The 2D top-down game features real-time raycasting, dynamic lighting, fog of war and a minimap. As the player loses health, the visible light radius shrinks, and torches restore it. The player must find a key, unlock a door and escape. Gyro-M writes the whole game as a self-contained 1,679-line HTML and JavaScript file without extra prompts. Both models produce games that look and play the same, but Gyro-M does it with lower context overhead.

Blender lantern through MCP

Model Context Protocol (MCP) is a protocol that connects a model to external tools. Through MCP, Gyro-M models an ornate fantasy lantern in Blender, sets up lighting and cameras, and captures multi-angle renders on its own. The result shows clean geometry, golden framing, teal-tinted glass panels, a glowing core and floating pink crystals.

The Gyro-S lantern is valid too, with a stubbier frame and darker lighting. Which one looks better is a matter of taste, though the Gyro-M proportions and glass shading seem more refined. The practical difference is stability: the same MCP tool calls ran without a crash under Gyro-M, while the Gyro-S run repeatedly crashed Blender during screenshot capture. That suggests Gyro-M handles tool sequencing more reliably, at least in this run.

Godot 3D platformer

The most demanding task asks for a complete 3D game in Godot 4.1 with moving platforms, floating keys, hazard pits with respawns, checkpoints and a goal. The Gyro-M build works as specified: keys raise the counter, a shuttle platform and an elevator reach the remaining keys, checkpoints save progress, and the goal unlocks after the third key. Slight Z-fighting artifacts appear where surfaces overlap.

One corrective prompt was needed. The first version blocked mouse-look and bobbed the camera rapidly even when the player stood still. Gyro-M fixed both in GDScript with a low-pass filter on the head-bob offset and a clamp on the speed-based cadence. Gyro-S also produced a complete game, with heavy bloom effects.

Fishing village diorama

An experimental Three.js scene tests unconstrained design. Gyro-M builds colored houses, a wooden pier, small boats, shoreline water shaders and seagulls that circle overhead, all without mid-run steering. The roof geometry is somewhat messy and misaligned, which reflects how hard open-ended architectural tasks remain.

Practical notes for a similar setup

  • Pick the TQ2_0 file when you run Gyro-M on a 16GB GPU in Strata.
  • Consider 64GB of system RAM so Strata does not push large context to the SSD during long sessions.
  • Put an explicit timeout instruction in coding prompts that run automated tests, so a stuck test runner does not hang the session.
  • When you connect a model to Blender through MCP, make sure the tool returns recoverable error messages on timeouts and crashes instead of blocking the pipeline.
  • Judge model sizes on your actual development work, not on reasoning scores alone.

Should you move from Gyro-S to Gyro-M?

Gyro-M earns the higher scores: 15 of 15 on long-context retrieval, 85.4% on reasoning, 99% on HumanEval Remix and six of six on the build tasks. It also used less context on several projects and ran the Blender tool chain without crashes.

On finished code, though, the gap is narrow. Gyro-S completed the dungeon crawler, the sand simulation and the Godot game with comparable results, and its clear shortfalls were limited to one missing drag feature and the Blender crashes.

A reasonable reading is this:

  • If you already have 16GB of VRAM and enough system memory, Gyro-M is worth trying, especially for MCP tool work and long autonomous sessions.
  • If your VRAM or compute is tighter, stay with Gyro-S. It handles nearly the same development tasks, and nothing here suggests you need new hardware.
  • Either way, run both models on one of your own projects before you decide.

A larger Gyro-L variant also exists, but whether this class of hardware can run it remains an open question.