Qwen 3.8 Flash Next on a gaming PC: Strata's 94 tokens per second, measured

The most interesting number of this week does not sit in a corporate model report. It sits in a GitHub repository with more than eleven thousand stars. The project is called Strata, it was created on 24 September 2026, and it moved at a pace infrastructure projects almost never reach: 11,535 stars as of 05 October 2026, over a thousand forks. The promise sounds almost naive: Qwen 3.8 Flash Next, a 125 billion parameter model, running entirely on your gaming PC, behind an installer that skips the terminal battle. My thesis: local AI is tipping over from a tinkerer hobby into ordinary software, and the agent operation on my 45 euro deck already shows what the division of labor under such a setup looks like. I walk through the numbers that matter and say plainly what runs on my deck and what does not.

Strata is an inference engine written in C++ under the MIT license, plus an installer for Windows and Linux. Per the documentation you need a graphics card with 12 GB of video memory or more, an NVIDIA GeForce of the 20 to 50 series or an AMD Radeon from the RX 7900 line up, 32 GB of system memory as a base (64 GB lets you run every size), roughly 80 GB of disk and a current driver. The installer downloads about 70 GB of model, asks for a quantization level, a context length and image input, then starts a local server on 127.0.0.1:8080 speaking OpenAI and Anthropic formats. Two or three cards can share one model. For agents there is an MCP server, and anyone running a coding agent such as Claude Code, Codex or pi hands it one line of text and receives a configured Strata. That last point deserves the pause: agents installing agent infrastructure. It fits the core and shell track this blog follows in October, because more and more tools attack precisely where the division of labor gets decided.

The speed tables are the real core of the project. Three lines stand out. On an NVIDIA RTX 5070 with 12 GB, the largest tested quantization level Q2_0 writes 94 tokens per second and reads a 32,000 token prompt at 2,650 tokens per second. The finer levels from IQ3_S up to IQ2_XS write between 53 and 79 tokens per second. On an AMD RX 9070 XT with 16 GB, Q2_0 writes 60 tokens per second and reads at 1,160; the Coder variant of the model family manages 44. Reading help from the documentation: one token is roughly three quarters of a word, and 60 tokens per second count as faster than a human reads. Two footnotes: Q2_0 was measured with engine 0.1.36, the other levels with 0.1.26, always with 4,000 tokens of answer length and 32,000 tokens of context. An RTX 3090 with 24 GB should reach 100 to 140 tokens per second; that is a project statement, not an independent measurement.

The discussion under the Hacker News thread adds the one thing tables cannot give: field feedback. User snehesht documented 124 tokens per second on an RTX 4090 with 128 GB of DDR5 and found it surprisingly good. The replies show patterns I know from my own operation: models feel different depending on the harness even though the parameters stay the same, one user runs it with pi and notices no difference against pricier alternatives, another gets more out of the 27B variant in a different harness. That is not a controlled evaluation and I do not treat it as one. It is still the best live field test for this setup right now, and it circles the question I care about: does the small level hold up for real agent work?

My deck is the counterpoint to this setup. It is a used Google Pixel 6a for 45 euros, it has no dedicated GPU, and the snapshot from 05 October 2026, 07:00 stood at 854 MiB of free memory. I do not compute 125 billion parameter models locally; I orchestrate: Hermes plans the work, pi executes it through herdr, and the gateway survives Android kills because it was built to survive kills, not to prevent them. This week says: gateway lifetime over the last seven days at 99 percent, 305 of 306 checks, five OOM kills in seven days. The contrast is the picture: Alibaba served the compute factories, I hold a 45 euro phone. Between the ends sits the layer Strata normalizes: an ordinary desktop with a gaming card, fully local, no data center in between.

My deck shows what the division of labor with a model of this size can look like. Orchestration is small and runs locally, the thinking model sits behind it. Until now that model was almost always a server computation, in my case cloud quota with a fixed weekly window. In September I replicated the speed route through Cerebras at 1,459 main words, where Qwen 3.8 runs at up to 1,500 tokens per second per the provider. The other end of my scale was the on-device track from the Desert Ant post. Strata pushes a layer into the middle: 6 billion activated parameters per token, fully offline, fast enough for agent loops. The middle of a scale gets underestimated.

Three things are new, and none of them is the model itself. First the packaging: an installer that chooses between quantization levels and context lengths is the difference between a tutorial post and software. Second the agent interface: MCP server and the ready made setup for coding agents turn compute infrastructure into a target the agent itself can approach. Third the pace: 11,535 stars in just under twelve days is a speed that infrastructure projects rarely see. What is not new: physics and economics. Startup locks 35 to 55 GB of memory and the machine stalls for one to three minutes; the 70 GB download remains a hurdle. The 12 GB line excludes the majority of common graphics cards. Anyone expecting this route to replace cloud thinking entirely is reading the wrong lines.

The model itself has carried its numbers since late August. On Hugging Face, Qwen/Qwen3.8-Flash-Next shows 1,480,842 downloads and 5,901 likes as of 05 October 2026. Derived GGUF versions push further: one lab's GSQ-RCO build stands at 1,886,975 downloads, the Coder variant at 351,230, plus uncensored and abliterated variants with six digit values. The open channel cuts both ways: quantization spreads models faster than any central block could stop, and security relevance grows with every branch. The blog covered the supply chain side in September with the git config post; there the attack vector sat with the agents, here it sits with distribution.

Honesty here means naming three limits. First the AMD gap: 60 against 94 tokens per second at the same level shows the engine extracts more from NVIDIA hardware, and only some levels are measured on AMD. Second the license: Strata stands under MIT, the model behind it is an open weight release by Alibaba, and I have not fully audited its license terms; the download leaders show why that matters. Third: every speed value comes from the project or from community posts. I ran no measurement on a GPU myself and say that explicitly. The evidence standard stands: project measurement, community measurement, my own operation, and none of it gets mixed.

The cost view completes the picture. The engine is free under MIT, the model is an open weight release, and the MIT license covers code, not your electricity meter. A used setup with a 12 GB card costs a few hundred euros. Against that: no billing per run, no quota, no weekly window; my Ollama contract on the deck is built on exactly such limits. Pay hardware once, then pay electricity for tokens.

For agent operation the middle is the interesting part. A local API on 127.0.0.1 speaking OpenAI and Anthropic formats lets every harness enter it as a target without a server bill. The pattern is layered: local carries the constant load, the cheap judgments and the logging, the cloud receives escalations, long contexts and tasks that need real compute. The same contract I run on the deck, extended in both directions. Whether such layers stay stable is a test question, not a belief, and that is why this layer is on the radar now.

About the author: I am Marcel, a graphic designer, and I run the HUNTER cyberdeck on a used Google Pixel 6a. I orchestrate my agent family with Hermes, pi and herdr and write these posts from live operation. This post is based on the Strata project documentation, API measurements from 05 October 2026 and my own operation in September and October 2026. Last fact-checked on 05 October 2026.

Sources: Niko1221/Strata on GitHub, project documentation with speed tables, system requirements and install paths, retrieved 05 October 2026. Hacker News thread on Qwen 3.8 Flash Next on consumer hardware from 04 October 2026, community measurements, retrieved through the Algolia API on 05 October 2026. Hacker News thread on the model announcement from 25 August 2026 with the archived ModelScope description (125B parameters, 6B activated per token, 51B n-gram embeddings), retrieved 05 October 2026. Qwen/Qwen3.8-Flash-Next on Hugging Face, download and like counts through the Hugging Face API, retrieved 05 October 2026. Cerebras model overview with speed data, retrieved 07 September 2026. Own measurements: star measurement via GitHub API from 05 October 2026 (pi 112,486, Hermes Agent 251,268, openclaw 391,331, Codex 127,873, OpenCode 211,783) plus operation of the Pixel cyberdeck from daily notes and stability snapshots, as of 05 October 2026, 07:00.