Strata Models and Memory Requirements: Which to Pick on a 12GB or 16GB VRAM GPU

Update, October 26, 2026: Strata 0.2.5 and 0.2.6 were released on October 25. Starting with 0.2.5, DeepSeek V4.1-Flash also runs in the desktop app, and 0.2.6 updated the DeepSeek engine to version 0.1.51. According to the 0.2.5 release notes, on PCs with 16GB of VRAM or less, a speed-first setting that cuts the experts used per token from six to five became the default. The other change is that on PCs where all experts fit in free system RAM, the area of system RAM that holds experts no longer stops at 48GB and now holds all of them (the release notes do not say how that area is sized on PCs where not all of them fit). The October 24, 25 and 29 DeepSeek measurements in this article were all taken with Strata 0.2.4.1 and DeepSeek engine 0.1.49, and do not represent the speed or memory use of 0.2.5 or later (the values we measured on 0.2.10 are in Update, November 5, 2026).

Update, October 29, 2026: We added values measured on one RTX 4070 SUPER with 12GB of VRAM, for Qwen3.8-Flash-Next IQ3_S and Gyro-S (Strata 0.2.3.1) and DeepSeek V4.1-Flash 2.00bit (0.2.4.1), to the section "What changes between 12GB and 16GB of VRAM" and to the DeepSeek section. According to the release notes for Strata 0.2.7, released on October 27, on NVIDIA graphics cards with 13GiB of VRAM or less (12GB cards are included, 16GB cards are not), a setting that makes it more likely to select experts already placed on the card became the default in the Qwen engines. In the official comparison on an RTX 3060 12GB with Qwen3.8-Flash-Next IQ3_XXS, paired five times each against the same build with only this setting turned off, generation speed rose 15% for story answers and 37% for code answers (these are values for the RTX 3060 and IQ3_XXS; we do not know whether the gain is the same on the RTX 4070 SUPER or with IQ3_S and Gyro-S). Because the selected experts change slightly, the wording of answers changes, and the number of agent tasks completed may drop slightly (the official docs say this is within the range of variation). The 12GB values in this article are from before 0.2.7 for Qwen and from before 0.2.5, where the speed-first setting became the default, for DeepSeek; neither was measured on 0.2.7. Note that this setting was later removed from the defaults for RTX cards with 12GB of VRAM or less in 0.2.8, released on October 30 (Update, November 1, 2026).

Update, November 1, 2026: According to the release notes for Strata 0.2.8, released on October 30, on RTX cards with 12GB of VRAM or less, the setting that became the default in 0.2.7, which makes it more likely to select experts already placed on the card, is no longer the default. The official docs say that answers did get faster, but user reports and the developers' own checks tied the setting to an issue where text repeats in long sessions. If you set nothing, experts are selected the same way as in 0.2.6. To get the speed back, the official docs give two ways: turn on "Faster answers on 12 GB NVIDIA cards" under Speed in Native engine settings in Models in the desktop app, or launch with strata launch --set STRATA_ROUTE_PRIOR=1.5. We have not tried these steps and have not measured how much faster it gets with the setting restored. In 0.2.9, released on October 31, Unsloth 1bit sets for DeepSeek V4.1-Flash (UD-IQ1_S and UD-IQ1_M, 241GB and 258GB to download) became selectable in setup and strata launch (the default set does not change). The official docs say these two have not been tested on Windows (NVIDIA and AMD) or Strix Halo, and that UD-IQ1_M has not been run on a Mac either. We did not measure 0.2.8 or 0.2.9 for this article, nor the Unsloth 1bit sets.

Update, November 4, 2026 (official changes): According to the release notes for Strata 0.2.10, released on November 3, for Qwen3.8 (including the Unsloth files and Gyro) with the drafting setting on Auto, the draft model changed from the MTP draft layers to DFlash2 on cards the engine supports. DFlash2, added in 0.2.3, could be used only when selected in Terminal, and Auto used MTP. The cards on which the official docs say Auto uses DFlash2 are CUDA architectures 8.6, 8.9, 12.0, 12.1 and others; among GeForce cards, these are the RTX 30, 40 and 50 series (this mapping is ours; the RTX 20 series is not in this list). DFlash2 is small, about 0.7GB (the official docs say the card memory usage shown by the engine is 625MiB). On first launch it downloads about 1.2GB of files and builds the draft model file on the PC. When it runs with DFlash2, it does not fetch or load the MTP draft layers (the release notes give 5.2GB). This 5.2GB is the download size, not a difference in card memory usage. Because DFlash2 handles only one request at a time, the desktop app loads the model to accept one request at a time unless you have chosen a number. The official docs say that with layer split (assigning layers to each card), the same split as in our two-card measurements, Auto runs on DFlash2 alone (the values in this article's two-card section are from 0.2.3.1 and 0.2.4.1; the results we measured on 0.2.10 are in the "our measurement" update below). If you pass 2 or more to --parallel or --batch in Terminal, Auto picks MTP. To accept several requests at once in the desktop app, the official docs say to choose MTP or set the number of concurrent requests in Expert mode. For models other than Qwen3.8, such as DeepSeek, Auto in the drafting setting does not switch to DFlash2 either; the official docs say it picks MTP (DSpark in this article's DeepSeek section is a different setting and has nothing to do with this).

The official comparison ran Qwen3.8 on one card, alternating DFlash2 and MTP with the same engine and files; it is not a comparison between versions. On the RTX PRO 5000 (a professional card of the same generation as the RTX 50 series), IQ3_S generation speed rose about 6% for what the official docs call short answers (sampling with the app's normal settings; the length is not given) and about 1% for what they call long answers (given as 2K tokens; the settings are not given) (the "short answers" and "long answers" in our measurements follow the definitions in the method below and are not the official conditions). At temperature 0 (what the official docs call greedy; our measurements also use this condition) it rose about 8%, and the official docs say the gain is larger with greedy. On other cards, results ranged from a gain of about 12% on Strix Halo (UD-Q4_K_XL, short answers) to 2.6% slower on an Intel Arc A750, and the change was close to zero on a long agent task on DGX Spark. The release notes give neither comparison values on GeForce nor the amount of VRAM on the RTX PRO 5000, so we do not know whether the gain is the same on 12GB and 16GB cards. To go back to the previous draft model, launch with strata launch --drafting mtp in Terminal, or choose MTP on the Models page in the desktop app. The official docs note, however, that even with MTP selected, it runs on DFlash2 if the MTP draft layers are not on disk, and says so.

The 0.2.10 release notes also include the following changes. On a discrete graphics card (unified memory as on a Mac or Strix Halo is excluded), a launch without enough VRAM now moves work off the card in stages instead of shrinking the context and the number of concurrent requests. In order, it shrinks the conversation memory kept on the card, drops the MTP draft layers, reduces the buffer used for prompt processing, and finally puts the output part in system RAM. It is this last stage that the official docs say makes generation about 3 times slower. The tests the release notes cite are on one card, and behavior with multiple cards is not described. In the item about 8GB cards now launching with a 128K context, the official docs say "12GB cards are unchanged", and the same item says a 128K launch on an RTX 5070 (12GB) limited to about 8GB was 17–27% slower than without the limit. They do not say how far this process goes on a 12GB card that is not limited. For Qwen3.8 files, splitting each layer across all cards was also added. With the card split setting (a separate setting from drafting Auto) on Auto, the official docs use this split only when conditions such as these are all met: Terminal on Linux; exactly two NVIDIA cards with CUDA architecture 8.6 or 12.0 (the RTX 30 or 50 series for GeForce) or four Radeon AI PRO R9700 cards; all experts fit in card memory; there is free system RAM for the part kept there (about 43GiB in the official notation); and the context is 131,072 tokens or less. With this split, drafting Auto picks MTP and fetches the MTP draft layers. The developers have not tested it on Windows or with two GeForce cards. ISTA-DAS Coder for DeepSeek V4.1-Flash, aimed at code (a different model from the Qwen3.8 Coder in this article), was also added (the model file is 72.1GB, and on a PC without the DeepSeek files the download totals 191GB). The developers have not yet run ISTA-DAS Coder on NVIDIA cards on Windows. We measured ISTA-DAS Coder on November 5 (Update, November 5, 2026). We did not measure the behavior of moving work off the card in stages when VRAM is short, or splitting each layer across all cards, for this article.

Update, November 4, 2026 (our measurement): Because the official comparison has no GeForce values, on November 4 we compared launches with the drafting setting on Auto and launches with --drafting mtp, alternating them repeatedly, on this article's test machine (RTX 5080 16GB and an RTX 5060 Ti 16GB connected over OCuLink, 96GB of system RAM, Windows 11), using Terminal from 0.2.10 (Control 0.1.56, Qwen engine 0.1.56).

• Configurations measured: Qwen3.8-Flash-Next IQ3_S on one RTX 5080, on one RTX 5060 Ti, and with layers split across two cards; Gyro-S on one RTX 5080 and on two cards (we did not measure Gyro-S on one RTX 5060 Ti).
• Method: we measured with other processes that use the cards or system RAM stopped. Launch options were the same as on October 24 (--context 64k --vision off --tune skip and others), and the only difference between the Auto and MTP runs was the drafting setting.
• Draft model: in every configuration, Auto picked DFlash2 and did not load the MTP draft layers. In the --drafting mtp runs, the MTP draft layers were present locally, and we confirmed that it ran on MTP (because it switches to DFlash2 if the MTP layers are missing; both were checked in the engine log).
• Long answers: one Japanese and two English long-form prompts, run with a 2,048-token limit, temperature 0 and thinking off, repeated 2–3 times with a relaunch each time; the value is the median.
• Short answers: code-reading prompts (which differ from the long-answer prompts in content as well as in answer length), with a 256-token limit, temperature 0 and thinking off, three each at inputs of about 1,000, about 4,000 and about 32,000 tokens, repeated 3 times with a relaunch each time. The value is the median of the per-launch medians.
• Generation speed: for both long and short answers, the value reported by the Strata engine.

Long-answer generation speed (median) was as shown in the following table.

Configuration	Auto (DFlash2)	MTP
IQ3_S, one RTX 5080	107.8 tok/s	102.9 tok/s
IQ3_S, one RTX 5060 Ti	66.5 tok/s	66.3 tok/s
Gyro-S, one RTX 5080	100.0 tok/s	99.2 tok/s
IQ3_S, two cards	79.8 tok/s	77.5 tok/s
Gyro-S, two cards	37.8 tok/s	91.4 tok/s

In all three configurations measured on one card, generation speed was almost the same with DFlash2 and MTP. On two cards IQ3_S was also almost the same, but for Gyro-S, DFlash2 was half of MTP or less.

Compared with one RTX 5080 on the same day, IQ3_S on two cards ran in the 70% range with either draft model (DFlash2 from 107.8 to 79.8 tok/s, MTP from 102.9 to 77.5 tok/s). Gyro-S on two cards was close to one card with MTP (from 99.2 to 91.4 tok/s) and just under 40% with DFlash2 (from 100.0 to 37.8 tok/s).

With short answers, Gyro-S on the RTX 5080 had a median generation speed about 10% higher with DFlash2 at every input size, about 1,000, about 4,000 and about 32,000 tokens (at about 1,000 and about 4,000 tokens the per-launch values overlap). For IQ3_S, on both one RTX 5080 and one RTX 5060 Ti, which option was faster switched with input length (by median, DFlash2 was faster at about 1,000 tokens and MTP at about 4,000 and about 32,000 tokens), but with these prompts IQ3_S gave short answers with large variation from one request to the next, so we do not read this as a trend. Gyro-S on two cards was 20–30% slower with DFlash2 for short answers too (we did not measure short answers with MTP for IQ3_S on two cards).

This measurement does not tell us why only Gyro-S on two cards gets slower. The draft acceptance rate dropped with DFlash2 on two cards (46–62%, against 75–92% on one card), but it was about the same for IQ3_S and Gyro-S. In every two-card launch, the engine reported 0–73MiB of free VRAM on the last card in the chain (the RTX 5080) and warned that on a full card Windows may page memory and requests may stay stalled (the measurements ran to the end). We do not know whether the same happens with two cards that have VRAM to spare. The MTP runs carried the same warning and were still fast, so we cannot say the warning alone is the reason either. For Gyro-S on two cards on this test machine, launching with --drafting mtp was faster. IQ3_S on two cards ran to the end of the measurement with both DFlash2 and MTP.

Available commit after launch for IQ3_S on two cards was 0.59–1.35GiB over seven launches (DFlash2 for three short-answer and two long-answer launches, MTP for two long-answer launches) (Windows grew the page file during launch; for Gyro-S on two cards it was 14–15GiB). The available commit after launch depends on the available commit before launch and on how the page file grows, so we did not compare it with the October 25 values, and we cannot say that 0.2.10 left more available commit.

When we launched IQ3_S on one RTX 5080 with --parallel 2, it ran on MTP even with Auto (the plan shown before launch still said DFlash2). The VRAM used for experts dropped from 7.83GiB in an MTP launch with one concurrent request to 6.60GiB (as written in the engine log), and long answers sent one at a time ran at 41.6 tok/s, about 40% of an MTP launch without --parallel (102.9 tok/s) (also about 40% of Auto's DFlash2 at 107.8 tok/s; one launch). Since it is this much slower than the same MTP launch, we do not read it as an effect of the draft model switch. We have not separated whether this is because the slots for concurrent requests took away VRAM used for experts, or because handling multiple slots is itself slow.

When we ran the official quick sanity check (the 12 items in standard-v1 covering instruction following, finding information in documents and tool calling) on our test machine, all 12 passed in all seven configurations run on the first launch (IQ3_S with Auto and MTP on the RTX 5080 and on the RTX 5060 Ti, and with Auto on two cards; Gyro-S with Auto and MTP on two cards). We did not compare answer quality, 12GB cards or the desktop app.

Update, November 5, 2026 (our measurement): We measured ISTA-DAS Coder, the set for code for DeepSeek V4.1-Flash added in Strata 0.2.10, on one RTX 5080 in our test machine, on the same day and in the same way as the 2.00bit set. The speeds are in "Comparing ISTA-DAS Coder and 2.00bit on Strata 0.2.10" in the section "What you need to run DeepSeek V4.1-Flash"; system RAM use and DSpark are in "How it uses system RAM" and "DSpark" in the same section; and commit at launch is in "Commit when launching DeepSeek on one card with Strata 0.2.10", at the end of the section "Available commit after launch". We also connected Claude Code and OpenCode to ISTA-DAS Coder and had them solve code-fix tasks.

Quick reference: the size you get for your amount of system RAM

The 0.2.4 MODELS.md we retrieved on October 24, 2026 described the size Strata picks first for Qwen3.8-Flash-Next as the size recommended for that PC (other sizes can also be chosen). The 0.2.10 MODELS.md we read on November 4 describes these separately: it gives the recommended order as ISTA-DASLab, Unsloth, then Gyro (whichever fits that model and PC comes first), and says setup may pick a Swift or Gyro size first in low-memory tiers. The quick reference table in this section shows the size Strata picks first, not the order the 0.2.10 documentation recommends (the tier calculation is the same in the 0.2.10 setup.py). A "size" here means one of the files the official docs list as candidates to choose from; most of them are the same model made smaller by quantization (storing the weights with fewer bits so that the file and the memory footprint shrink). Besides files quantized by other makers, the list also includes Swift 1.5, a fine-tune, and Coder, which has half the experts removed. Of these, Q2_0, IQ2_XS, IQ3_XXS and IQ3_S are reduced versions of Qwen3.8-Flash-Next itself. The size Strata picks first depends on which tier the total of system RAM (RAM) and VRAM minus 5GB falls into, among the tiers by amount of memory in the official tier table (the 0.2.4 MODELS.md retrieved on October 24, 2026; the 0.2.10 MODELS.md does not have this table). In Strata's setup.py, if the result is 62 or more you get IQ3_S (64GB tier), if it is 46 or more IQ3_XXS (48GB tier), and if it is 38 or more Swift 1.5 IQ2_XS (40GB tier) (Macs follow a different rule). Below 38, the official tier table lists Gyro-S (Coder for code) in the 32GB tier, but what actually comes up first is decided by a separate check, not by the tier boundaries (see the section "How Strata picks a size first: memory tiers and low-RAM mode"). For example, 32GB of system RAM with a 12GB card gives 32 + 12 − 5 = 39, which is the 40GB tier. For the amounts of system RAM in the quick reference table, a GPU (graphics card) with 12GB or 16GB of VRAM lands in the same tier, and the size picked first is also the same (our calculation). Find the row for your amount of system RAM to see the tier with 12GB and with 16GB of VRAM, and the sizes under two ways of counting (the size picked first by tier, and the sizes that fit under the system-RAM-only rule of thumb).

System RAM	With 12GB of VRAM (after −5GB)	With 16GB of VRAM (after −5GB)	Size picked first by tier (0.2.4 tier table and setup.py)	Sizes that fit under the system-RAM-only rule of thumb (official formula)
32GB	32 + 12 − 5 = 39 → 40GB tier	32 + 16 − 5 = 43 → 40GB tier	Swift 1.5 IQ2_XS (39.2GB). The other candidate is Gyro-M (35GB)	No size fits (even Coder needs 23 + about 10 = 33GB). The official docs say Coder runs in low-RAM mode on this PC
48GB	48 + 12 − 5 = 55 → 48GB tier	48 + 16 − 5 = 59 → 48GB tier	IQ3_XXS (47.0GB)	Q2_0, IQ2_XS and Coder (IQ3_XXS needs 43 + about 10 = 53GB and does not fit)
64GB	64 + 12 − 5 = 71 → 64GB tier	64 + 16 − 5 = 75 → 64GB tier	IQ3_S (54.8GB). Swift 1.5 IQ3_S is treated the same	The four sizes and Coder (IQ3_S needs 50 + about 10 = 60GB, if almost no other apps are open). The Unsloth files and NVFP4 do not fit
96GB	96 + 12 − 5 = 103 → 96GB-or-more tier	96 + 16 − 5 = 107 → 96GB-or-more tier	setup picks IQ3_S first. The official table also lists Unsloth's UD-IQ4_XS to Q8_0 for this tier	The four sizes and Coder. Unsloth fits up to UD-IQ4_XS (about 72GB) and UD-Q4_K_XL (about 88GB), and NVFP4 (about 80GB) also fits

The quick reference table combines official values with our calculation and is not our measurement. The "Size picked first by tier" column is the first suggestion Strata makes. The GB figure after each size is the value the official tier table gives with it; what it measures is covered in the section "How Strata picks a size first: memory tiers and low-RAM mode". The "Sizes that fit under the system-RAM-only rule of thumb" column is a rule of thumb for whether all experts (the parts of the model of which only some are used for each token; a token is the unit the model splits text into, and is not necessarily one word) can be kept in system RAM, and the official docs say a size fits if system RAM is "the size of the experts + about 10GB (for Windows and other apps)". The expert sizes are 34GB for Q2_0, 35.5GB for IQ2_XS, 43GB for IQ3_XXS, 50GB for IQ3_S and 23GB for Coder; for the Unsloth files alone we used the values from the official Unsloth table (expert size converted to GiB + 16), and for NVFP4 the official figure of about 80GB. In the official explanation, the experts in the first file loaded at launch go to system RAM, the weights other than the experts go to the card, and the second file (the 29GB table) stays on the SSD. The four Qwen3.8-Flash-Next sizes and Coder run in low-RAM mode when they do not meet this rule of thumb (setup.py also chooses low-RAM mode when system RAM does not reach the experts + 10GB). Low-RAM mode has a mode that copies the experts into system RAM and a mode that reads them through the OS file cache, and how much slower it gets depends on the mode and the size of the card (see the section "When it runs in low-RAM mode"). In the 0.2.10 setup.py, the Unsloth files are handled separately from low-RAM mode. On a PC where the experts plus another 16GB do not fit in system RAM, the most-used experts are kept in system RAM up to the amount of system RAM minus about 24GB, and the rest is read from the SSD while answering. This mode is called RAM budget. The 0.2.10 DETAILS.md lists it in its low-RAM mode table (see the end of the section "When it runs in low-RAM mode"). For Gyro, the official docs give the amount of memory as the total of system RAM + VRAM (the amount of weights loaded), so it is not included in the formula for this column.

Among the names in the quick reference table, Q2_0, IQ2_XS, IQ3_XXS and IQ3_S are the four sizes that are reduced versions of Qwen3.8-Flash-Next itself, and the memory they need increases in that order. According to the official documentation, Swift 1.5 is a fine-tune by UkisAI that shortens the time spent thinking before answering, Gyro-S and Gyro-M are quantizations by agentionai for PCs with little memory, Coder is a version by ISTA-DASLab with half the experts removed for code, and the Unsloth files are large sizes of about 4 to 8 bits.

For the four amounts in the quick reference table, the tier does not change between 12GB and 16GB of VRAM. Counted with the same formula, the 4GB difference in VRAM crosses a tier boundary (38, 46, 62) on PCs with 27GB or more but less than 31GB, 35GB or more but less than 39GB, and 51GB or more but less than 55GB of system RAM (our calculation; VRAM was counted at the nominal 12GB and 16GB, and what the separate check picks on PCs below 38 is not included in this calculation). The system RAM that goes into the formula is the amount the OS reports, which is slightly less than the amount installed. For a PC with an amount not in the table, put your own numbers into the same formula and compare the result with the boundaries.

In the 32GB and 48GB rows, the two columns point to different sizes. Swift 1.5 IQ2_XS and IQ3_XXS, the sizes picked first by tier, do not meet the system-RAM-only rule of thumb, because the IQ2_XS experts are 35.5GB, which is more than 32GB, and IQ3_XXS needs 43GB + about 10GB, which is more than 48GB (our calculation). According to the official docs, a size that does not meet the rule of thumb runs in low-RAM mode. Applying the setup.py formula, IQ2_XS with 32GB of system RAM would use the mode that reads the part not kept on the card through the OS file cache (mmap), and IQ3_XXS with 48GB of system RAM could use the mode that copies that part into system RAM (resident) (our calculation; with 12GB of VRAM it is close to the boundary; the two modes are described in the section "When it runs in low-RAM mode"). On a PC with 48GB of system RAM, the choice is between using IQ3_XXS, the size picked first, as it is in low-RAM mode, and choosing Q2_0 or IQ2_XS, which fit under the system-RAM-only rule of thumb (Coder also fits if you only use it for code) (with 32GB of system RAM, no size fits the rule of thumb). We have not measured which is faster.

For PCs with less or more system RAM than in the quick reference table, the official values also give a rough idea (our calculation). A PC with 16GB of system RAM only just reaches the minimum requirement in the 0.2.4 README (32GB in total) with a 16GB card, and does not reach it with 12GB of VRAM (the 0.2.10 documentation has no such total requirement). A PC with 24GB of system RAM comes out below 38 after subtracting 5GB with either 12GB or 16GB of VRAM, which is the 32GB tier (Gyro-S, or Coder for code) in the tier table of the 0.2.4 MODELS.md. Applying the formula the desktop app and strata launch use for their suggestion, Coder comes up first on this PC (with 12GB of VRAM it is close to the boundary, and depending on the amount of system RAM the OS reports, it can be Gyro-S; our calculation). A PC with 128GB of system RAM has enough to keep all the experts of every file in the official Unsloth table in system RAM except Q8_0 (about 136GB). Our test machine has 96GB of system RAM, and we did not measure PCs with 32GB, 48GB or 64GB. We have not checked on real hardware how much the speed changes depending on which of the two columns in the quick reference table you follow, nor how PCs with less or more system RAM than in the quick reference table behave.

According to the official MODELS.md, for the Qwen3.8-Flash-Next sizes that keep their experts in system RAM, a bigger card makes generation faster but does not lower the system RAM needed (except in low-RAM mode). DeepSeek V4.1-Flash and Qwen3.6-35B-A3B are designed to put as many experts on the card as will fit and leave the rest to the CPU, so they are considered separately from this rule.

Speed also changes a lot from one model to another. Measured on our test machine (96GB of system RAM, one RTX 5080) on October 24, 2026, generation speed (output tok/s) with an input of about 4,000 tokens was 101.3 tok/s for Qwen3.8-Flash-Next IQ3_S (Strata 0.2.3.1) and 8.0 tok/s for the DeepSeek V4.1-Flash 2.00bit (IQ2_XXS) set (Strata 0.2.4.1). The two differ in tokenization and in launch settings, however, and the generated lengths were not matched either (with the input of about 4,000 tokens, the number of tokens generated was a median of 90 for IQ3_S, and the 256-token limit in every run for DeepSeek), so this is not a comparison of the time needed to generate the same amount of output.

How Strata picks a size first: memory tiers and low-RAM mode

The README describes Strata as software that runs Qwen3.8-Flash-Next, a 125B (125 billion parameter) model that would normally need a server, on an ordinary PC. From 0.2.4, DeepSeek V4.1-Flash also runs in Terminal (the command-line edition of Strata). According to the README, it is MIT-licensed and needs no account and no cloud (the models and some components have separate licenses).

The README (0.2.4) we retrieved on October 24, 2026 gave the minimum requirement as 32GB or more of system RAM and VRAM combined (the amount of unified memory on Macs and Ryzen AI Max). The 0.2.10 README and INSTALL.md we read on November 4 have no such total requirement; they say that the memory and disk needed vary with the model, quantization, context and features used, so you should check which models fit in MODELS.md and in the --plan output. The 0.2.4 README says that a PC with 32GB of system RAM and a 12–16GB card runs the smaller sizes, and that with 64GB of system RAM every size runs (in the same explanation in MODELS.md, what fits in 64GB is the four sizes of Qwen3.8-Flash-Next itself and Coder, with IQ3_S only if almost no other apps are open).

The 0.2.4 MODELS.md we retrieved on October 24, 2026 says the tier is counted from the total of system RAM and VRAM minus 5GB for Windows and the system (the rule of subtracting 5GB dates from 0.2.2; the 0.2.10 MODELS.md we read on November 4 does not have this explanation, but the 0.2.10 setup.py also subtracts 5GB). In the examples given in the 0.2.4 MODELS.md, a PC with 12GB of VRAM and 32GB of system RAM is in the 40GB tier (32 + 12 − 5 = 39), and a PC with a 16GB card and 32GB of system RAM is also in the 40GB tier, not the 48GB tier. A comment in setup.py says the boundaries are 2GB lower than the tier names because the OS reports slightly less memory than is installed, and says the MCP server (used by the desktop app and strata launch) has the same boundaries. According to MODELS.md, strata launch and setup in Terminal and the install function of the MCP server pick the size first by these tiers, and the desktop app has also picked by tier since 0.2.1. Every entry point uses the same tier boundaries, and other sizes can also be chosen. However, on PCs that already have a size installed, on Macs and Strix Halo, and on PCs that come out below 38 after subtracting 5GB, the first suggestion may differ from the tier table.

The order in which Swift 1.5 IQ2_XS is picked first in the 40GB tier and IQ3_XXS in the 48GB tier is the same as in the quick reference table, and the official tier table also contains things the quick reference table does not. For the 32GB tier, where the result is below 38 after subtracting 5GB, the tier table lists Gyro-S and Coder for code. The implementation, however, does not count PCs below 38 by tier boundaries: the suggestion from the desktop app and strata launch (the MCP server) puts Coder first if there is 28GB or more of system RAM or if Coder fits in low-RAM mode together with the card, and otherwise offers Gyro (we checked this in tools/strata_mcp.py on October 25, 2026). In the 64GB tier, Swift 1.5 IQ3_S is also an option treated the same as IQ3_S. The 96GB-or-more tier lists Unsloth's UD-IQ4_XS to Q8_0, but even in this tier setup picks IQ3_S first (except on Strix Halo). Q2_0 appears in the tier table only in a note on the 32GB row, saying "the 2bit Q2_0 is faster at writing answers".

The GB figure next to each size (from 37.6GB for Q2_0 to 54.8GB for IQ3_S) is the value the official tier table gives with it, and on the model cards of ISTA-DASLab, which distributes the quantized files, it corresponds to the size of the first file. The distributor writes that running the model also needs room for the KV cache and other things, so these GB figures alone are not enough to run it. The 39.2GB for Swift 1.5 IQ2_XS is also a tier table value; the first Swift 1.5 file that setup.py knows of is about 39.8GB. The size Strata picks first is decided by the tier boundaries, not by these GB figures, and the 0.2.4 MODELS.md gives a PC with 12GB of VRAM and 32GB of system RAM, which comes out at 39 in the quick reference table, as its example of the 40GB tier with IQ2_XS (39.2GB).

The tier table in the 0.2.4 MODELS.md says that with less memory than in the table, Strata switches to low-RAM mode automatically and gets slower, and that it gets much slower on a small card. Whether it actually enters low-RAM mode depends on whether system RAM reaches that size's experts + about 10GB (setup.py). As in the 32GB and 48GB rows of the quick reference table, a size can run in low-RAM mode even when the PC is in its tier. For Unsloth files, the memory mode is determined differently (see the end of the section "When it runs in low-RAM mode").

Running it on a PC with 32GB of system RAM: Gyro, Coder and low-RAM mode

Adding a card with 12GB or 16GB of VRAM to a PC with 32GB of system RAM puts it in the 40GB tier in Strata. If you choose by the official documentation, what to pick depends on your use and your memory situation.

• What Strata picks first is Swift 1.5 IQ2_XS in the 40GB tier (a fine-tune by UkisAI that shortens the time spent thinking before answering). It does not meet the system-RAM-only rule of thumb, so it runs in low-RAM mode, and by the setup.py formula it uses the mode that reads the part not kept on the card through the OS file cache (mmap) (our calculation; according to the official docs, this mode gets much slower on a small card).
• By the selection guide in the official GYRO.md, choose Gyro-S if nothing larger fits on your PC, and Gyro-M if you want to use about 20% less VRAM than IQ3_XXS.
• If you only use it for code, choose Coder. The official docs say, however, that it is weak outside code and in languages other than English.
• As examples of the low-RAM mode that copies the experts into system RAM (resident), the only one the official DETAILS.md gives for a PC with 32GB of system RAM and a 12–16GB GPU is Coder. IQ2_XS appears only in the example for a 24GB GPU.

All the choices and behaviors listed here come from the official documentation, and we have not measured them (our test machine has 96GB of system RAM).

For Swift 1.5, the official docs say the time spent thinking before answering is much shorter, the quality is about the same, the speed per token is the same, and the system RAM needed is about the same as for the same size of the original model. The license on the Swift 1.5 page applies.

Gyro-S and Gyro-M

Gyro is a quantization of Qwen3.8-Flash-Next by agentionai. GYRO.md says that neither Gyro-S nor Gyro-M is a default size, and that setup and the MCP server offer them only on PCs where no other size fits (they warn but do not block). On the other hand, in the tier table of the 0.2.4 MODELS.md we retrieved on October 24, 2026 (the 0.2.10 MODELS.md does not have this table), Gyro-S is picked first in the 32GB tier and Gyro-M is the other candidate in the 40GB tier, and the 0.2.4 README advised "start with Gyro if you have little memory". The 0.2.10 MODELS.md we read on November 4 says that if you have little memory and use the model for general purposes, you should compare Unsloth first, and then Gyro, which uses the least memory and is slow. The Unsloth files, however, need about 72GB or more to keep all experts in system RAM, so a PC with 32GB of system RAM cannot hold them all. According to the 0.2.10 UNSLOTH_Q4.md and setup.py, UD-IQ4_XS and UD-Q4_K_XL need 48GB or more of system RAM even when the part that does not fit is read from the SSD. On a PC with less than 48GB of system RAM, according to the same sources, setup shows that it "does not fit", asks whether to install it anyway, and the default answer is "no".

The memory needed (the total of system RAM + VRAM, that is, the amount of weights loaded) and the download size given in the official docs are 27.6GB and 58.5GB for Gyro-S, and 35GB and 92.0GB for Gyro-M. An n-gram table accounts for about half of the total file size (the table stays on the SSD and is looked up for every token), and the official docs say to put it on a fast drive. It runs on NVIDIA, AMD (experimental) and Intel Arc (Linux only) cards, and on Macs since 0.2.2.

On quality, in the GYRO.md evaluation (October 2026), Gyro-S is lower in quality than the 2–3bit sizes, and its divergence from the original model (KL) is 13% larger than that of IQ2_XS. Gyro-M is about the same as IQ3_XXS in divergence, but its generation speed is 16–21% slower than Q2_0 (values on an RTX 3060 12GB and an R9700), and on reasoning problems it scored 49/60 against 57/60 for Q2_0.

Coder

Coder is ISTA-DASLab's version for code: of the 512 experts in each layer, it keeps the 256 chosen with code data and drops the rest. The first file is 29.6GB, and the official docs say it "fits on a PC with 32GB of system RAM". By the system-RAM-only rule of thumb (23GB of experts + about 10GB = 33GB), though, it slightly exceeds 32GB, and the low-RAM mode section of MODELS.md also gives Coder as an example that runs in low-RAM mode on such a PC.

Because it has half the experts, it is weak outside code and in languages other than English (including Chinese and others), and there is a report (#438) of Chinese answers breaking down or repeating. For general use, the official docs recommend a size that keeps all the experts if system RAM allows. We have not checked the quality of its answers in Japanese.

When it runs in low-RAM mode

Low-RAM mode has a mode that copies the experts not kept on the card into system RAM (resident) and a mode that reads them through the OS file cache (mmap). Which one is used is explained below. Separately from this, the file the experts are read from differs by pack. According to the official DETAILS.md, packs that have a file called experts.bin read the experts from that file in the model folder, and use 23–50GB more disk space for it. Packs without experts.bin (what the official docs call a native pack) read them directly from the model's GGUF file (0.2.10 DETAILS.md). If a PC has enough system RAM for the experts not kept on the card plus about 10GB, the engine copies those experts from the file into system RAM once at launch and does not read them from the SSD while answering. On a PC that cannot hold them, it uses the mode that reads the experts through the OS file cache: if the card can hold most of the experts, it runs at close to normal speed, but with a small card it has to read most of the experts from the SSD and gets much slower (setup also shows this). RAM budget, which the 0.2.10 DETAILS.md lists in its low-RAM mode table, is covered at the end of this section.

As examples of the mode that copies the experts into system RAM, the official docs give Q2_0, IQ2_XS and Coder for 32GB of system RAM with a 24GB GPU, and Coder for 32GB of system RAM with a 12–16GB GPU. They say IQ3_XXS with 32GB of system RAM stays in the mode that reads through the file cache. The low-RAM mode section of MODELS.md gives the same examples without separating the two modes. What setup shows is the mode setup chose; the mode that actually ran can be seen in the engine log. According to the official DETAILS.md, at launch the engine checks whether the experts not kept on the card fit in free system RAM minus 4GB, and if they do not, it says so and runs in the mode that reads through the file cache.

If you get the Strata source and run it, you can override whether low-RAM mode is used with --low-ram on or off; the Windows command examples are START-HERE.bat --setup --low-ram on to use it and START-HERE.bat --setup --low-ram off not to (in PowerShell, add .\ at the start). To explicitly select a mode, pass --low-ram resident (the mode that copies into system RAM) or --low-ram mmap (the mode that reads through the file cache) to the same setup. The official docs say START-HERE.bat is not used if you installed the desktop app or Terminal (this command is for installs from source). We have not measured the speed of the two modes.

The 0.2.10 DETAILS.md lists RAM budget (--resident-budget-gib N) in its low-RAM mode table alongside the two modes above. The 0.2.10 setup.py, however, handles the Unsloth files separately from the two low-RAM modes above. This mode is chosen for the Unsloth files, for example on a PC where the experts plus another 16GB do not fit in system RAM. RAM budget copies N GiB of the experts not kept on the card into system RAM, starting from those ranked as most used, and reads the rest from the file; the official docs say this is the mode used to run Unsloth's UD-Q4_K_XL on a PC with 64GB of system RAM. They also say that on Windows the free commit also caps N, and that Strata says so when it lowers N. According to the 0.2.10 UNSLOTH_Q4.md, a guide for N is the amount of system RAM minus 24GB (40 on a PC with 64GB). We have not measured this mode.

Models Strata can run, and the ones we measured

The model table lets you compare, for each model, the memory figure given in the official docs with the download size, and check whether we have measured it.

Model	Memory figure in the official docs	Download (official; includes figures for the files on our test machine)	Our measurement
Qwen3.8-Flash-Next Q2_0	First file 37.6GB (from the official tier table)	66–76GB (Q2_0, IQ2_XS, IQ3_XXS)	October 2026 (Strata 0.1.31–0.1.41)
Qwen3.8-Flash-Next IQ2_XS	First file 39.2GB (from the official tier table)	66–76GB (Q2_0, IQ2_XS, IQ3_XXS)	Not measured
Qwen3.8-Flash-Next IQ3_XXS	First file 47.0GB (from the official tier table)	66–76GB (Q2_0, IQ2_XS, IQ3_XXS)	October 2026 (Strata 0.1.31–0.1.41)
Qwen3.8-Flash-Next IQ3_S	First file 54.8GB (from the official tier table)	83.6GB (total of the two files on our test machine)	October 2026 (Strata 0.1.31–0.1.41), October 24, 25 and 29, 2026 (0.2.3.1), and November 4, 2026 (0.2.10, DFlash2 vs. MTP comparison only)
Swift 1.5 (UkisAI)	About the same as the same size of the original model (in the official tier table IQ2_XS is 39.2GB; the first file is about 39.8GB)	—	Not measured
Coder (ISTA-DASLab)	Fits on a PC with 32GB of system RAM (first file 29.6GB)	—	October 2026 (Strata 0.1.31–0.1.41)
Gyro-S (agentionai)	Loaded weights 27.6GB (counted as system RAM + VRAM)	58.5GB	October 24 and 29, 2026 (0.2.3.1), and November 4, 2026 (0.2.10, DFlash2 vs. MTP comparison only)
Gyro-M (agentionai)	Loaded weights 35GB (counted as system RAM + VRAM)	92.0GB	October 24, 2026 (0.2.3.1)
Unsloth UD-IQ4_XS to Q8_0	About 72–136GB of system RAM to keep all experts in system RAM (for UD-IQ4_XS, places such as the setup screen description say about 80GB)	94–188GB	UD-Q4_K_XL only, October 2026 (Strata 0.1.31–0.1.41)
NVFP4 (three variants)	About 80GB of system RAM to keep all experts in system RAM	102–128GB	Not measured
Qwen3.6-35B-A3B (Unsloth)	32–52GB of system RAM expected by setup	Files 22.9–37.8GB	Not measured
DeepSeek V4.1-Flash (three ISTA-DASLab sets)	One card with 12GB of VRAM or more (on a PC with a discrete graphics card). For system RAM, 46GB is the amount it has been shown to run on, and 64GB the amount found comfortable in testing	239–274GB	2.00bit (IQ2_XXS) on October 24, 25 and 29, 2026 (0.2.4.1) and November 5 (0.2.10)
DeepSeek V4.1-Flash ISTA-DAS Coder (ISTA-DASLab, from 0.2.10)	—	191GB (if you have the Engram from another ISTA-DAS set, the additional download is 80GB including DSpark; if you have both the Engram and DSpark, the model itself at 72.1GB)	November 5, 2026 (0.2.10)

The figures in the model table come from the README, docs/MODELS.md, docs/GYRO.md and the v0.2.4 release notes, retrieved on October 24, 2026 (only the ISTA-DAS Coder row is based on the 0.2.10 release notes, checked on November 5). Depending on the document, the memory figure is the size of the first file, the amount of loaded weights (counted as system RAM + VRAM), or the system-RAM-only rule of thumb, and each cell says which. The first-file size and the loaded-weight amount are not the whole amount needed to run a model; the KV cache and other things need memory on top of them. — marks cells where we did not take a value from the official docs. The IQ3_S download alone is the total of the two files on our test machine, 83,617,662,656 bytes (about 83.6GB), and does not include the MTP draft layers (the two IQ3_S files, 54,817,524,224 + 28,800,138,432 bytes, downloaded on October 3, 2026 from ISTA-DASLab's Qwen3.8-Flash-Next-GSQ-RCO-GGUF repository). Cells reading "October 2026 (Strata 0.1.31–0.1.41)" refer to our earlier Qwen3.8-Flash-Next measurements, and cells with dates from "October 24, 2026" onward are measurements for this article (on the 29th, one RTX 4070 SUPER with 12GB of VRAM; on the 24th and 25th, the RTX 5080 and the RTX 5060 Ti; on November 4, version 0.2.10 on one RTX 5080, one RTX 5060 Ti, and two cards; on November 5, version 0.2.10 on one RTX 5080).

On a PC with 64GB of system RAM or less and 12–16GB of VRAM, the candidates to compare are the 2–3bit sizes of Qwen3.8-Flash-Next, Swift 1.5, Gyro and Unsloth, plus Coder if you only use it for code (the official docs say it is weak on non-coding tasks and in languages other than English). The 0.2.10 MODELS.md we checked on November 4 says that with little memory and general use you should compare Unsloth first, and then Gyro, which uses the least memory and is slow. The official GYRO.md says to choose Gyro-S if nothing larger fits on the PC, and Gyro-M if you want to use about 20% less VRAM than IQ3_XXS. However, the Unsloth files need about 72GB or more to keep all experts in system RAM, so on a PC with 64GB of system RAM or less they do not fit entirely. According to the official docs, the part that does not fit is read from the SSD while answering (much slower). On a PC with less than 48GB of system RAM, setup does not install UD-IQ4_XS or UD-Q4_K_XL by default. The 2–3bit sizes can also run in low-RAM mode and slow down when system RAM is short (see the "When it runs in low-RAM mode" section), and we have not measured which of them is fastest on such a PC.

Among the four Qwen3.8-Flash-Next sizes, the official docs say IQ3_S, the one with the largest first file (54.8GB), matches the original model in published tests. The download for the three smaller sizes (Q2_0, IQ2_XS, IQ3_XXS) is 66–76GB. Up to 0.2.9, the first launch also downloaded the MTP draft layers (a component that guesses ahead of the answer to speed it up). The official wording does not limit this to particular sizes. Their size is given as about 6GB (+1GB with image support) in docs/MODELS.md and as 5.2GB in the 0.2.10 release notes (both are download sizes), so the figures differ between documents. From 0.2.10, on RTX 30, 40 and 50 series cards and others, when the drafting setting is Auto and the number of concurrent requests is one (except when it ends up splitting each layer across all cards), Strata downloads DFlash2 (about 1.2GB on first download) instead of the MTP draft layers (Update, November 4, 2026; official changes).

The Unsloth files (UD-IQ4_XS to Q8_0, about 4–8bit) use more system RAM than the 2–3bit sizes because their experts have more bits. According to the official docs, when the experts plus another 16GB fit in system RAM, setup keeps all of them in system RAM. When they do not, it keeps the most-used experts up to system RAM minus about 24GB and reads the rest from the SSD while answering (much slower). This mode is called RAM budget and is covered at the end of the section "When it runs in low-RAM mode". In the official Unsloth table, the amount needed to keep everything in system RAM is about 72GB for UD-IQ4_XS, about 88GB for UD-Q4_K_XL and about 136GB for Q8_0 (the expert size converted to GiB, plus 16; setup.py compares this with the amount of system RAM counted in GiB). The tier table in the 0.2.4 MODELS.md, the description on setup's size-selection screen and the MCP server's description put UD-IQ4_XS at about 80GB and up, but on a PC whose GPU has its own VRAM, the threshold at which setup.py chooses the mode that keeps everything in system RAM is the about 72GB figure. According to docs/UNSLOTH_Q4.md and a note in setup.py, the about 80GB figure is the amount at which everything fits under the mode that places as much as fits when memory is short, with system RAM minus 24GB used as the space for experts. The two figures come from counting by subtracting from system RAM versus counting by adding to the expert size.

NVFP4 comes as Strata's conversion, NVIDIA's conversion, and a version NVIDIA retrained for FP4, and according to the official docs all of them need about 80GB to keep every expert in system RAM. The downloads are 128GB, 128GB and 102GB, and the third uses an extra 110GB of disk during preparation.

Qwen3.6-35B-A3B is a smaller model from the same maker (35B, using 3B per token, Apache 2.0), and Strata runs Unsloth's GGUF with MTP included. It reads images and can process multiple requests at the same time. The file size and the system RAM setup expects are 22.9GB and 32GB for UD-Q4_K_XL, 32.6GB and 44GB for UD-Q6_K_XL, and 37.8GB and 52GB for Q8_0, plus a separate 0.9GB file for reading images. The engine puts as many experts on the card as fit and computes the rest on the CPU.

Card requirements differ between documents. In the official docs, NVFP4 runs only on NVIDIA cards, and according to setup.py's description it uses the FP4 units on RTX 50 cards and computes at 8-bit precision on older NVIDIA cards. Qwen3.6-35B-A3B runs on NVIDIA and AMD cards (the Intel Arc and Mac engines do not run it). For the Unsloth 4-bit models, the AMD section of docs/INSTALL.md says an NVIDIA card is required, while docs/UNSLOTH_Q4.md and setup.py say UD-Q4_K_XL also ran on AMD's Radeon AI PRO R9700, and setup.py has dropped the NVIDIA-only restriction on that basis. They do not say it was verified on any other AMD card.

What changes between 12GB and 16GB of VRAM

In an earlier Qwen3.8-Flash-Next test, we measured Q2_0 on October 3, 2026 with Strata 0.1.31 and 0.1.35. With an RTX 4070 SUPER (12GB of VRAM) connected to the same OCuLink port (PCIe 4.0 x4) after removing the RTX 5060 Ti, generation speed (output tok/s) was about the same as on the 16GB RTX 5060 Ti, and prompt processing (how fast the input text is read) was 10–20% slower. Both are with all experts kept in system RAM (96GB). The experts Strata put on the GPU came to about 5.2GiB on the RTX 4070 SUPER, less than 60% of the about 9.2GiB on the RTX 5060 Ti. The two cards also differ in compute speed and memory bandwidth, so we have not isolated whether the difference comes from the amount of experts that fit. We did not measure the difference between cards on a PC that falls into low-RAM mode because system RAM is short.

For the Strata 0.2 series, on October 29, 2026, we replaced the RTX 5060 Ti on the same OCuLink port (an external PCIe 4.0 x4 connection) with an RTX 4070 SUPER 12GB and measured. Qwen3.8-Flash-Next IQ3_S and Gyro-S ran on Strata 0.2.3.1 (engine 0.1.48), and the launch options passed to the engine were the same as in the October 24 run on one RTX 5060 Ti (DeepSeek is covered in the DeepSeek section). Each value is the median of the medians of the three launches.

Item	IQ3_S RTX 4070 SUPER 12GB (October 29)	IQ3_S RTX 5060 Ti 16GB (October 24)	Gyro-S RTX 4070 SUPER 12GB (October 29)	Gyro-S RTX 5060 Ti 16GB (October 24)
Generation speed (input about 1,000 tokens)	60.4 tok/s	59.6 tok/s	48.7 tok/s	70.0 tok/s
Generation speed (input about 4,000 tokens)	54.9 tok/s	60.2 tok/s	52.2 tok/s	68.7 tok/s
Generation speed (input about 32,000 tokens)	55.7 tok/s	62.8 tok/s	43.2 tok/s	59.7 tok/s
Prompt processing (input about 1,000 tokens)	141.2 tok/s	166.7 tok/s	284.4 tok/s	380.5 tok/s
Prompt processing (input about 4,000 tokens)	501.5 tok/s	584.9 tok/s	950.2 tok/s	1,230.7 tok/s
Prompt processing (input about 32,000 tokens)	773.1 tok/s	1,114.5 tok/s	1,774.1 tok/s	1,575.2 tok/s
Time to first character (input about 32,000 tokens)	40.9 s	28.4 s	17.9 s	20.1 s

Relative to the RTX 5060 Ti, generation speed on the RTX 4070 SUPER was about the same for IQ3_S at about 1,000 input tokens and about 90% at about 4,000 and about 32,000 tokens, and around 70% for Gyro-S at every length. Prompt processing was slower on the RTX 4070 SUPER except for Gyro-S at about 32,000 tokens (about 70–85% for IQ3_S, about 75% for Gyro-S). At about 32,000 input tokens, time to the first character was longer on the RTX 4070 SUPER for IQ3_S, and shorter on the RTX 4070 SUPER for Gyro-S. The transfer speed to the card measured by the engine was 6.4GB/s on the RTX 4070 SUPER and 7.0GB/s on the RTX 5060 Ti, even on the same port, and the expert space on the GPU was about 4.3GiB on the RTX 4070 SUPER and about 8.3GiB on the RTX 5060 Ti, roughly half (2,236 and 4,356 experts for IQ3_S, 4,427 and 8,530 for Gyro-S; all as written in the engine logs). The two cards were measured on different days, and the October 24 IQ3_S run overlapped in time with a download of another model. With IQ3_S, answer length also differed from request to request (for about 4,000 input tokens, the median answer was 81 tokens on the RTX 4070 SUPER and 256 tokens on the RTX 5060 Ti). We have not isolated how much of the difference comes from the cards. These figures predate Strata 0.2.7 and do not include the setting that became the default for NVIDIA cards with 13GiB of VRAM or less in 0.2.7 (in 0.2.8 it was taken out of the default for RTX cards with 12GB of VRAM or less). In 0.2.8, with nothing configured, expert selection is the same as in 0.2.6, but we have not measured speed on 0.2.8, so we cannot say these figures are the current default speed as they stand. In 0.2.10, both the RTX 4070 SUPER and the RTX 5060 Ti in this table are on the list of cards for which the official docs say Auto uses DFlash2 (our mapping), so with the drafting setting on Auto and one concurrent request, drafting switches to DFlash2. When we compared DFlash2 and MTP on 0.2.10 with IQ3_S on one RTX 5060 Ti and Gyro-S on one RTX 5080 (we did not measure Gyro-S on the RTX 5060 Ti), there was no large difference in generation speed for long answers. For short answers with the same 256-token cap as this table, Gyro-S on the RTX 5080 was about 10% faster with DFlash2 at the median, but the per-launch values partly overlapped, and for IQ3_S on one RTX 5060 Ti the faster option switched depending on input length (our measurement, November 4, 2026). Because the version is different, none of these are in this table. We did not measure the RTX 4070 SUPER on 0.2.10, and the official release notes have no DFlash2 vs. MTP figures for RTX 40 series cards either.

In the engines for the Qwen3.8-Flash-Next family (including Gyro), the main thing the amount of VRAM changes is how many experts can sit on the card. According to the official GYRO.md, the expert space (cache) is sized by default to the card's free VRAM, so a smaller card holds fewer experts and the rest are read from system RAM. In the Qwen engines, where the image-reading part runs and the number of concurrent requests also depend on VRAM. The DeepSeek engine is built differently: on Strata 0.2.4 it supports neither images nor concurrent processing, and what the amount of VRAM changes is things such as the number of experts placed on the GPU and whether DSpark is loaded (off by default on 12GB cards).

In this article, official figures are written as the official docs write them (mostly GB), nvidia-smi and available-commit figures in GiB and MiB (1GiB = 1,024MiB), and engine log figures as the logs write them (GB for the DeepSeek engine, GiB and MiB for the Qwen engines). Note, however, that setup.py reads the amount of system RAM in GiB and compares it directly with the official rules of thumb. The official docs also write values counted in GiB as GB in some places (for example, the amounts needed to keep all experts in system RAM in the Unsloth table).

VRAM usage on our test machine

On our test machine, Strata nearly filled the 16GB cards to match their free space, so the usage figures are no basis for how many GB is enough. When choosing a size, what to look at is how the two columns of the quick-reference table are counted: the tier Strata picks first is counted as system RAM + VRAM − 5GB, and whether all experts fit in system RAM is counted from system RAM alone. VRAM usage (nvidia-smi) was read on October 24, 2026 (Strata 0.2.3.1 and 0.2.4.1) right after launch, once the server started responding. On the card Strata ran on, it was 15,449–15,709MiB (about 15.1–15.3GiB) on the RTX 5080 and 14,794–14,900MiB (about 14.4–14.6GiB) on the RTX 5060 Ti. Both use most of their 16GB.

The engine (0.1.48) log from launching Qwen3.8-Flash-Next contained the line "LOW: requests may stall". It is a warning that little VRAM is left free after everything has loaded, and it suggests adding --vram-reserve-mib or lowering the maximum context. The log combines several launches; we have not determined which launch the line came from, and we have not checked whether requests actually stall as warned. The DeepSeek engine log did not contain the same warning.

On the RTX 4070 SUPER 12GB on October 29, 2026, every one of the three launches of Qwen3.8-Flash-Next IQ3_S and Gyro-S produced a warning that free VRAM was below 1,024MiB when a request was received (a different warning from the "LOW" line above), but within what we measured, no request saw generation speed fall to a few tok/s (the lowest per-request values were 46.3 tok/s for IQ3_S and 31.7 tok/s for Gyro-S). The warning says that when the card is this full, the driver may move GPU memory out to system RAM and generation speed can drop to a few tok/s, and it suggests adding --vram-reserve-mib or lowering the maximum context. We have not tried a launch that frees up VRAM as the warning suggests.

On this card too, Strata sized its expert space to the free VRAM. The free VRAM after everything had loaded, as reported by the engine (0.1.48), was 439MiB for IQ3_S and 461MiB for Gyro-S, and the free VRAM when requests were received was 307–461MiB (all as written in the engine logs). The post-load lines did not carry the "LOW: requests may stall" mentioned above. For the October 24 run on one RTX 5060 Ti 16GB, splitting the log by launch time shows post-load free VRAM of 402MiB for IQ3_S and 424MiB for Gyro-S, no "LOW" line, and the same request-time warning. The warning was not specific to the 12GB card. The "LOW" line above was absent from the launches used for the single-card measurements on these two cards, and we have not confirmed which launch it came from. The DeepSeek engine log did not contain the same warning on the RTX 4070 SUPER either, but this engine also reported 571MiB free after loading (as written in the engine log), so the absence of the warning does not show that there is VRAM to spare.

What stays the same and what differs at 12GB and 16GB

According to the official docs, the image-reading part of the Qwen engines runs on the CPU when the card has less than 24GB (a few seconds per image, using no card memory) and on the card at 24GB or more (about 1–1.4GB of VRAM). On cards with 12GB and 16GB of VRAM, it runs on the CPU in both cases. The rule is the same for NVIDIA and AMD, and you can turn it off with --vision off.

The number of concurrent requests is one by default. According to the official docs, the "fit to card" suggestion in strata launch is 1 at 12GB, 2 at 20GB, 3 at 24GB and 4 at 32GB or more, and setting more than one on a 12GB card makes each individual answer slower.

For Qwen3.6-35B-A3B, according to the official QWEN36.md, each additional concurrent-processing slot uses 1.5GB of VRAM at 32K context and reduces the space available for experts. Setup bases its suggestion on the chosen context: on a 12GB card, up to 4 slots at 8K (at 32K it does not suggest more slots and stays at one), and on a 16GB card, up to 2 slots at 32K.

The 0.2.4 README and INSTALL.md said NVIDIA cards had to be GeForce RTX 20, 30, 40 or 50 series with 12GB of VRAM or more, and that 8GB works but is slow. The 0.2.10 README and INSTALL.md list RTX 20 to 50 series as supported cards and do not give an amount of VRAM as a requirement (they say the memory needed depends on the model, quantization, context and the features used).

Within what we could measure (Strata 0.1 series, Q2_0, all experts in system RAM, RTX 4070 SUPER 12GB versus RTX 5060 Ti 16GB), generation speed was about the same and prompt processing was 10–20% slower on the 12GB card. The two are also different card models, so we have not isolated whether this difference comes from the amount of VRAM. According to the official docs, when a PC ends up in low-RAM mode using the mode that reads experts through the OS file cache (mmap), the smaller the card, the greater the slowdown. With the RTX 4070 SUPER 12GB measured on Strata 0.2.3.1 (October 29, 2026, on our test machine with 96GB of system RAM, not in low-RAM mode), generation speed relative to the RTX 5060 Ti 16GB on October 24 ranged from about the same to about 90% for IQ3_S, and was around 70% for Gyro-S. This comparison also differs in card model and measurement date, and the October 24 IQ3_S run overlapped with a download of another model, so we cannot say for certain that the gap is due to the amount of VRAM. The post-load free VRAM reported by the Qwen engine did not reach 500MiB on either the RTX 4070 SUPER or the RTX 5060 Ti (402–461MiB for IQ3_S and Gyro-S, as written in the engine logs).

What you need to run DeepSeek V4.1-Flash

For DeepSeek V4.1-Flash, the official assumption on a PC with a discrete graphics card is one card with 12GB of VRAM or more and 46–64GB of system RAM (46GB is the amount it has been shown to run on, and 64GB the amount found comfortable in testing; the 0.2.10 MODELS.md we checked on November 4 also says a 12GB card and 46–64GB of system RAM), so the first things to check are free disk space and system RAM. For disk, on top of the set's 239GB, 257GB or 274GB, setup allows a 6GB margin for the pack folder and working space (it stops if free space is less than the download amount, and if the 6GB margin is not there it warns and continues). The speeds in the official docs fall between 4 and 10 tok/s on a 12GB card, and the known-limitations section of the release notes says it is usable for chat but slow for long agent runs.

According to the release notes and docs/DEEPSEEK41.md, more system RAM gives a larger cache and faster answers (46GB worked on an RTX 3060 PC, and 64GB was the amount found comfortable in testing). Below about 40GB is untested and slow, and setup says so and installs anyway. The official setup does not stop you from installing on a small PC; it shows what will happen first. Disk use is 239GB for 1.75bit (IQ1_M), 257GB for 2.00bit and 274GB for 2.25bit (IQ2_XS), and the official docs say to put it on an NVMe SSD (on a slow disk, the time per output token goes up). These disk figures are the sum of the model itself, the 111GB Engram table shared by all three sets (a large table from which the model reads a few rows per token, read while it stays on the SSD), and the 8GB DSpark draft model (a small model that guesses the answer ahead and has the guess checked).

Where it runs is limited. As of October 24, 2026, DeepSeek V4.1-Flash ran in the Strata 0.2.4 Terminal (strata launch and strata setup), while the desktop app was still at 0.2.3 and did not include DeepSeek. With 0.2.5, released on October 25, it runs in the desktop app as well. According to the 0.2.4 release notes, it runs on NVIDIA RTX 30–50 cards (Windows and Linux) and on AMD's Radeon AI PRO R9700 under Linux, and does not yet run on Mac or Strix Halo. 0.2.7, released on October 27, added Windows PCs with Ryzen AI Max (Strix Halo), and the later 0.2.7.1 added Apple silicon Macs (used from the Terminal, text only). The developers verified it on one Strix Halo machine, a Ryzen AI Max+ 395 (128GB of shared memory), and on one Mac, an M5 Max (128GB of memory). For Macs they recommend 64GB of memory or more, and on a Mac with less, setup says it will be much slower and asks whether to continue (the developers have not run it on a Mac with less than 128GB either). The DeepSeek engine distributed with 0.2.4 was a single file for NVIDIA CUDA 13 on Windows (the release assets have no separate file for PCs with older drivers), and a Windows build for RTX 30 exists but the developers have not run it. DeepSeek runs on a separate engine from Qwen (strata-dsv41), which was ported from Project Maya's maya-ds4.

When we checked the GitHub releases page on October 24, 2026, Strata 0.2.4.2 was out (Terminal Control 0.1.49.2, DeepSeek engine 0.1.49.2), while the desktop app was 0.2.3 and the Qwen engine was unchanged. According to the release notes, 0.2.4.2 fixed DeepSeek answers being up to 3 times slower on CPUs such as AMD's Ryzen 3000 series, and the DeepSeek engine now updates itself at the next strata launch (an engine passed with --dsv41-package or STRATA_DSV41_EXE is not replaced; the measurements in this article used an engine passed with --dsv41-package). From 0.2.4 or 0.2.4.1, you upgrade with strata update. Our test machine's CPU is Intel, and we did not measure 0.2.4.2.

Disk use differs by set, so you can narrow the candidates first by what fits in your free space. The quality yardstick and the recommended set differ between documents. The Strata release notes measure perplexity (a value expressing how hard it is for the model to predict the continuation of a given text; lower means its predictions are better) on fixed test data (4,995 items; the release notes describe this as a number of sentences, docs/DEEPSEEK41.md as a number of evaluated positions). The increase over the original model is +15.5% for 2.00bit, +7.3% for 2.25bit and +21% for 1.75bit; the release notes say 1.75bit is weak on English prose and recommend 2.25bit for code and agent use if you have the disk space. The ISTA-DASLab model card (Hugging Face, checked October 24, 2026) uses a different yardstick (the average of AIME25, GPQA-Diamond and LiveCodeBench v6, measured at reasoning effort 50). It reports 2.00bit at 100.0%, the same as the original model, and 1.75bit at 98.7%, lists no figure for 2.25bit, and recommends 2.00bit. The two measure different things, so the numbers cannot be set side by side and compared. We have not compared answer quality.

The official speeds (2.00bit set) in the release notes table are about 5 tok/s (code) for an RTX 5070 12GB with 64GB of system RAM, and about 8–10 tok/s for an RTX 3060 12GB with 46GB of system RAM (the RTX 3060 figure reflects the correction in the 0.2.4.1 update). The known-limitations section of the same release notes gives 4–8 tok/s output on 12GB cards. On our test machine, 0.2.4.1's strata launch --plan (an option that only shows what it would do, without launching) displayed about 7.2 tok/s as a reference figure for the RTX 3060. The official docs say that on a 12GB card most of each token's time is spent waiting on the SSD and CPU, and that every figure goes down on a slow NVMe SSD.

On Strata 0.2.4, DeepSeek supports neither concurrent processing of multiple requests nor images (if you specify them, it warns and ignores them). The default context is 8,192 tokens (when we displayed the launch plan on 0.2.10 on November 5, the default was 128K). According to the 0.2.7 release notes, from 0.2.7 DeepSeek also reads images by default. There is an extra download of about 1GB the first time, and the card memory used by the image-reading part is taken from the expert cache (you can remove it with --vision off). The 0.2.4.1 DeepSeek figures in this article do not include this behavior, and the November 5 figures on 0.2.10 were measured with --vision off. The developers verified this on Linux PCs (a Radeon AI PRO R9700, and a PC with two RTX A6000 cards), not on Windows or Strix Halo. DeepSeek on Mac in 0.2.7.1 is text only and refuses images that are sent to it.

Comparing ISTA-DAS Coder and 2.00bit on Strata 0.2.10

ISTA-DAS Coder is a coding-focused set for DeepSeek V4.1-Flash, added in Strata 0.2.10. According to the 0.2.10 release notes, it keeps 192 of the 384 experts in each layer, the ones ISTA-DASLab chose for code and agent work. The distributor's model card says that halving the experts always reduces capability. The same model card describes it as an approach that accepts the loss outside the target tasks and as an experimental release, and recommends the unreduced GSQ-RCO sets for general use. The Coder in the section "Running it on a PC with 32GB of system RAM" is a file made by reducing Qwen3.8-Flash-Next in the same way, and is a different model. On a PC without the DeepSeek files, the download totals 191GB: the model itself at 72.1GB, the Engram shared with the other ISTA-DAS sets at 110.6GB, and DSpark at 8.0GB. If the Engram is already on hand, it is 80GB (including the 8.0GB of DSpark). On our test machine, Strata found the Engram and DSpark files in the 2.00bit set's folder and did not fetch them (the engine did not load DSpark; see the section "DSpark"), so the only files it fetched were the five files of the model itself (72.1GB). In the release notes' ISTA-DAS Coder table, the row for NVIDIA cards on Windows with DeepSeek engine 0.1.56 says "not yet run" (in the same table, on one Radeon AI PRO R9700 on Linux with engine 0.1.55, ISTA-DAS Coder's generation speed is 22.8 tok/s).

On November 5, 2026, with Strata 0.2.10 (Terminal's Control 0.1.56) and DeepSeek engine 0.1.56, we launched ISTA-DAS Coder and the 2.00bit set in turn on one RTX 5080 (--gpu-roles 0=main) and compared them. The context was 0.2.10's default of 128K (131,072 tokens), the experts used per token were five of six, the default for PCs with 16GB of VRAM or less, --vision off was added, and everything else was left at the defaults. We launched each set three times, and in each launch sent three inputs each of about 1,000 and about 4,000 tokens (answers of 256 tokens, thinking off). On this day, other work was running on and off on the same PC, and we measured without stopping it (the median CPU usage during measurement was 62–89%, depending on the launch).

Set	Generation speed (input of about 1,000 tokens)	Generation speed (about 4,000 tokens)	Time to first token (about 1,000 tokens)	Time to first token (about 4,000 tokens)
ISTA-DAS Coder	8.3 tok/s (6.4–11.0)	8.8 tok/s (6.2–10.7)	4.8 s (4.3–6.7)	6.4 s (5.9–10.2)
2.00bit	7.1 tok/s (5.6–8.1)	7.9 tok/s (7.1–8.5)	17.2 s (16.8–20.0)	21.9 s (21.5–23.6)

Values are medians of nine runs (3 launches × 3 inputs), with the minimum–maximum in parentheses. Generation speed is the value reported by the engine. Time to first token for ISTA-DAS Coder was about one quarter to one third of that for 2.00bit. In Strata's official test run on the first launch (standard-v1 of strata bench run), prompt processing of about 3,000 tokens was also 456.8 tok/s for ISTA-DAS Coder and 191.8 tok/s for 2.00bit (medians of three runs each, as output by strata bench). This test has the model write answers, with thinking, of up to 512 tokens, so its conditions differ from the table above. In both runs the verdict was nonconforming (the run did not meet the test's requirements), because the prompt length fell outside the target set by the test's rules and the hash of the model files could not be taken. In the table above, ISTA-DAS Coder's generation speed was a little over 10% faster by median, but the ranges of the nine individual values (in parentheses in the table) overlapped. ISTA-DAS Coder's third launch (9.9–11.0 tok/s) was the one with the least CPU use by other work, and we have not isolated the relationship between load and speed (with 2.00bit, the launches with less CPU use were not faster). The functional check in the official test (the 12 items covering instruction following, finding information in documents and tool calling) passed all 12 items for both sets. We did not compare answer quality.

The values in this section are not placed in the same table as the 0.2.4.1 values in the next subsection, "Speed on a single card", because the versions of Strata and the DeepSeek engine, the context length, the number of experts used per token and the load from other work all differ. We did not measure DeepSeek on 0.2.10 on the RTX 5060 Ti, on a card with 12GB of VRAM, or on two cards.

Speed on a single card

On October 24, 2026, on our test machine (96GB of system RAM), running the 2.00bit set on one card with Strata 0.2.4.1 and DeepSeek engine 0.1.49 (with the context at the then-default 8K) gave a generation speed of 7.7 tok/s (about 1,000 input tokens) and 8.0 tok/s (about 4,000 tokens) on the RTX 5080, and 6.8 tok/s and 7.3 tok/s on the RTX 5060 Ti. Prompt processing at about 4,000 tokens was 143.5 tok/s on the RTX 5080 and 125.4 tok/s on the RTX 5060 Ti. The model was on the NVMe SSD at C:, and the RTX 5060 Ti was connected over OCuLink. These are all 16GB-card figures.

On October 29, 2026, with one RTX 4070 SUPER 12GB swapped into the same OCuLink port, running the 2.00bit set on the same Strata 0.2.4.1 and DeepSeek engine 0.1.49 gave a generation speed of 6.0 tok/s (about 1,000 input tokens) and 6.6 tok/s (about 4,000 tokens), about 90% of the RTX 5060 Ti. Of the official figures given above, this is within the 4–8 tok/s range for 12GB cards in the known-limitations section, but below the about 8–10 tok/s for the RTX 3060 12GB (the amount of system RAM also differs, and we have not checked the reason). Prompt processing at about 4,000 tokens was 127.4 tok/s, about the same as the RTX 5060 Ti. Time to the first character was 25–31 seconds per request at about 1,000 input tokens and 33–35 seconds at about 4,000 tokens, and the per-launch medians were about the same as on the RTX 5060 Ti. The launch options passed to the engine were the same string as in the RTX 5060 Ti run, but whether we added the setting that skips the test response at launch is not in the records for this run (we added it for the RTX 5060 Ti run). The GPU held 183 of the 15,360 experts in total, less than 30% of the 16GB cards (659 on the RTX 5080 and 684 on the RTX 5060 Ti in single-card launches), and DSpark was not loaded on this card either. The card model and measurement date differ, and we do not know whether the setting that skips the test response at launch matched, so we have not isolated the relationship between the number of experts placed and speed. These figures predate both the speed-first setting that became the default in 0.2.5 for PCs with 16GB of VRAM or less (reducing the experts used per token from 6 to 5) and the 0.2.7 change that speeds up prompt processing. The 0.2.7 release notes also say that RTX 40 (sm_89) support was added to the CUDA package for DeepSeek. The logs do not tell us which card generation's code the engine 0.1.49 ran in this run.

How it uses system RAM

According to the official docs, the DeepSeek engine puts as many experts on the card as fit and computes the rest on the CPU. Frequently used experts go into a cache in free system RAM, the others are read directly from the model files, and the cache size is set automatically at launch. On our test machine (96GB of system RAM), the engine set the cache to a maximum of 48.0GB and loaded 34.3GB of frequently used experts at launch (both in GB as written in the engine log). The 48.0GB on our test machine is the value that hit the 0.2.4.1 cap, and on a PC with less free system RAM it can be smaller. From 0.2.5, if all the experts fit in free system RAM, it keeps all of them instead of stopping at 48GB (see Update, October 26, 2026).

In the November 5 launches on one RTX 5080 with 0.2.10, the engine sized the cache from the system RAM free after placing the weights on the card (72.6–74.6GB as written in the log) and set it to 60.6–62.6GB. The frequently used experts it loaded were 45.8–47.1GB for ISTA-DAS Coder and 47.2–47.3GB for 2.00bit (all are ranges over three launches, in GB as written in the log). The experts computed off the card were logged on the first launch as 63.5GB for ISTA-DAS Coder and 129.7GB for 2.00bit. On our test machine with 96GB of system RAM, not all of the experts off the card (63.5GB on the first launch) fit in the cache (60.6–62.6GB) even with ISTA-DAS Coder, and what was loaded at launch was the 45.8–47.1GB of frequently used experts. The rest is read directly from the model files (we have not isolated the gap between the cache size and the amount loaded). The experts placed on the card were 320–338 of 7,680 for ISTA-DAS Coder and 313–321 of 15,360 for 2.00bit; for 2.00bit, that is about half of the 659 on one RTX 5080 with 0.2.4.1 on October 24 (8K context). Other work was also running on this day, and free system RAM before launch was not matched.

DSpark

DSpark was not loaded automatically even on 16GB cards (single-card launches on the RTX 5080 and RTX 5060 Ti, with --dspark at its default of auto). The engine logged as the reason that it would have no effect because the experts (132GB) far exceed what can be placed on the GPU (15GB) (both in GB as written in the log). On one RTX 5080 with 0.2.10 on November 5, too, neither ISTA-DAS Coder nor 2.00bit loaded it automatically, and the engine logged the same reason (for ISTA-DAS Coder it showed the experts as 66GB). The official docs say DSpark is off by default on 12GB cards, and that setting --dspark on on an RTX 3060 PC makes it 2–13% faster. We have not tried --dspark on.

Reading the gap between the RTX 5080 and the RTX 5060 Ti

With DeepSeek, the gap between the RTX 5080 and the RTX 5060 Ti was small: generation speed at about 4,000 input tokens was 8.0 and 7.3 tok/s (about 1.1x). On the same two cards, Qwen3.8-Flash-Next IQ3_S (Strata 0.2.3.1, launched with different settings from DeepSeek) gave 101.3 and 60.2 tok/s (about 1.7x). The single-card IQ3_S runs overlapped in time with a download of another model (writing to a different drive); the RTX 5080 still gave 102.9 tok/s in a separate set of three relaunches, but we did not redo the RTX 5060 Ti run.

The RTX 5080 and the RTX 5060 Ti, whose gap was small with DeepSeek, both have 16GB of VRAM, and the number of experts placed on the GPU was also nearly the same (659 and 684 in the launch logs on Strata 0.2.4.1 with an 8K context; on the RTX 5080 with 0.2.10, the number placed on the card was about half). It is possible that what sets the speed is not the card's compute performance but either the amount of experts that fit on the GPU or the CPU, system RAM and SSD, and the latter also fits the official explanation that "on a 12GB card, most of each token's time is spent waiting on the SSD and CPU". This comparison cannot tell which of the two it is.

However, we did not measure the time breakdown and have not isolated where the time goes. In the October 25 run launched on two cards, where more experts were placed on the GPU, generation speed was higher than in the single-card runs (see the "What changes when you add a second GPU" section), but the conditions were not matched, and we have not isolated the relationship between the number of experts and speed either.

Available commit after launch: values measured on a PC with 96GB of system RAM

On October 24, on our test machine with 96GB of system RAM, available commit after launch was highest with Gyro-S and lowest with the Qwen3.8-Flash-Next IQ3_S. However, we did not check that the commit limit was the same across launches, so this difference cannot be read directly as a difference in how each model uses memory. In the October 24 table, launching on two GPUs reduced available commit further. In the values re-measured on October 25, the page file grew and raised the commit limit, and available commit after launch differed from one card by less than 1GiB. What was larger on two cards was the increase in commit charge from the launch (the last table in this section). All of these are values from the 96GB PC; we did not measure how many GiB remain on PCs with other amounts of RAM.

Available commit is how much more memory Windows can still promise to allocate to programs. Its limit is the sum of system RAM and the page file, which makes it a different quantity from free system RAM. The Qwen-family engines (including Gyro) also write this limit and the remaining amount to their log at launch. The less available commit there is, the less room you have for apps running alongside Strata, and the closer the system gets to Windows growing the page file to raise the limit. Growing the page file and writing memory contents out to disk are separate things, and the available commit value tells you neither how much was written out nor whether anything slows down. On October 24, 2026, with other apps closed, available commit on our test machine with nothing launched was 78–79GiB.

The available commit table (values measured on October 24, 2026) lets you compare, for each combination of model and GPU, how much available commit remained right after launch and how much VRAM was used.

Model	GPU	Available commit after launch	VRAM usage
Qwen3.8-Flash-Next IQ3_S	One RTX 5080	10.7–13.3GiB	15,552–15,598MiB
Qwen3.8-Flash-Next IQ3_S	One RTX 5060 Ti	10.7–13.0GiB	14,900MiB
Qwen3.8-Flash-Next IQ3_S	Two cards (RTX 5080 as Main, RTX 5060 Ti as Helper)	1.2GiB (measurement stopped here)	15,666MiB + 14,888MiB
Gyro-S	One RTX 5080	36GiB	15,533MiB
Gyro-S	One RTX 5060 Ti	36GiB	14,882MiB
Gyro-S	Two cards (RTX 5080 as Main, RTX 5060 Ti as Helper)	20GiB	15,645MiB + 14,872MiB
Gyro-M	One RTX 5080	30GiB	15,537MiB
Gyro-M	One RTX 5060 Ti	30GiB	14,884MiB
Gyro-M	Two cards (RTX 5080 as Main, RTX 5060 Ti as Helper)	14GiB	15,690–15,709MiB + 14,876MiB
DeepSeek V4.1-Flash 2.00bit	One RTX 5080	14GiB	15,449MiB
DeepSeek V4.1-Flash 2.00bit	One RTX 5060 Ti	14GiB	14,794MiB
DeepSeek V4.1-Flash 2.00bit	Two cards (RTX 5080 as Main, RTX 5060 Ti as Helper)	Fell from 44GiB to 1GiB in the last few seconds of launch (measurement stopped here)	15,347MiB + 14,692MiB (just before stopping)

The values in the available commit table were recorded once per launch, right after the server started responding. The single-card rows and the Gyro two-card rows show the range over three launches under the same conditions. However, the IQ3_S row for one RTX 5080 combines two launches from the series in which we measured speed (13.2 and 13.3GiB; the first launch was not recorded) and three launches from a separate series that ran on one RTX 5080 (10.7–12.1GiB). The two-card IQ3_S and DeepSeek rows are the single value from the one run we stopped (DeepSeek was stopped before it responded, so the value was read from the per-second log).

Available commit is Windows' FreeVirtualMemory (the value you can read through Win32_OperatingSystem in PowerShell), converted to GiB. On October 25, 2026, on the same PC with Strata not running, we read it back to back against the performance counters' commit limit (Commit Limit) minus commit charge (Committed Bytes); in all three readings the difference was under 0.04GiB, so the two refer to the same quantity. Gyro and DeepSeek were recorded as integers with the decimals truncated, and IQ3_S was rounded to one decimal place, so comparisons between integer rows can be off by just under 1GiB.

VRAM usage is from nvidia-smi, and the two-card rows list the RTX 5080 + RTX 5060 Ti in that order. The RTX 5080 also drives the display and was using 726MiB even with Strata not running.

For the two-card IQ3_S and DeepSeek runs, we stopped the measurement under our own criterion because available commit fell below 4GiB; the engine itself did not stop (according to the engine log, DeepSeek had finished loading). The two-card VRAM figure for DeepSeek is the value just before stopping. The single-card IQ3_S launches overlapped in time with the download of another model.

Available commit right after a single-card launch was nearly the same on the RTX 5080 and the RTX 5060 Ti, and the gap between Gyro-S's 36GiB and IQ3_S did not narrow when we changed cards. Launching on two cards, with the RTX 5080 as Main and the RTX 5060 Ti as Helper, left Gyro-S and Gyro-M with about 16GiB less available commit than one card. For IQ3_S and DeepSeek, available commit fell below our criterion on the two-card launches on October 24 and we stopped the measurement, so this table does not fully capture the difference from one card (the values re-measured on October 25 are at the end of this section). We have not isolated why available commit drops with two cards.

When available commit is low, engine 0.1.48 in Strata 0.2.3.1 warned in the launch log that it "may exit without a message when the limit is reached (exit code 0xC0000409)", and told us to either make the page file larger (system managed, or the same size as system RAM) or reduce the conversation cache, the maximum context, or the prompt chunk size. We did not check whether it actually exits as warned.

The page file on our test machine is set to an initial size of 16,384MB and a maximum of 128,000MB, so when it runs short Windows can grow it up to the 128,000MB maximum (we read the setting on October 24, 2026 and did not change it; how far it actually grows also depends on free disk space and other factors, which we did not check here). When the page file grows, the commit limit rises too. The limit in the engine log was 111.8GiB in every Gyro run. In the IQ3_S engine logs, one launch showed 137.4GiB, and since we cannot tell which launch that was, the IQ3_S rows' available commit may include a difference in the limit. The DeepSeek engine log has no line for the limit. The two-card measurements on October 24 were stopped under a criterion we set ourselves (available commit below 4GiB), before it became clear whether the page file would grow. We did not observe whether the engine stops when the limit is fully used up, and we did not measure with different page file sizes.

Commit when launched on two cards: values re-measured on October 25, 2026

On October 25, 2026, we re-measured the two-card IQ3_S and DeepSeek runs that had been stopped on October 24, using a looser stop criterion (stop only when available commit stays below 1GiB for about 50 seconds). That day other work was running in parallel on the same PC, and available commit with nothing launched was 66–68GiB, about 10–12GiB less than on October 24, so on the same day we also launched each model once on one RTX 5080 for comparison. That day available commit after launch dropped to 1–2GiB even on one card, so we compare one and two cards using the "Increase in commit charge from launch" column at the right end of the October 25 commit table.

Model	GPU	Available before launch	Available after launch	Commit limit after launch	Increase in commit charge from launch
Qwen3.8-Flash-Next IQ3_S	One RTX 5080	66.60GiB	1.17GiB	111.8GiB	65.43GiB
Qwen3.8-Flash-Next IQ3_S	Two cards (RTX 5080 as Main, RTX 5060 Ti as Helper)	67.68–68.28GiB	0.26–1.15GiB	126.0–127.1GiB	81.71–82.03GiB
DeepSeek V4.1-Flash 2.00bit	One RTX 5080	67.05GiB	1.97GiB	111.8GiB	65.08GiB
DeepSeek V4.1-Flash 2.00bit	Two cards (RTX 5080 as Main, RTX 5060 Ti as Helper)	68.24–68.42GiB	1.18–1.36GiB	123.6–123.8GiB	78.86–78.97GiB

The increase in commit charge from launch was about 16GiB larger than on one card for IQ3_S and about 14GiB larger for DeepSeek. On the two-card launches, available commit fell below 1GiB within a few seconds partway through launch; Windows then grew the page file, and the commit limit after launch was 126.0–127.1GiB for IQ3_S and 123.6–123.8GiB for DeepSeek. Even after the limit grew, only 0.26–1.36GiB of available commit remained after launch. Apart from the third two-card IQ3_S run, every run was measured to the end, and in none of them did the engine crash or restart.

The values in the October 25 commit table were recorded once just before launch and once right after the server started responding. Available commit here is the performance counters' commit limit (Commit Limit) minus commit charge (Committed Bytes). The increase in commit charge from launch is "limit − available" after launch minus "limit − available" before launch, and the limit before launch was 111.8GiB in every run. This charge is a whole-PC figure and includes what the other work running at the same time used (the spread across the three two-card runs was 0.1–0.3GiB). For DeepSeek, the October 25 two-card runs used the setting that skips the test response at launch, and the single-card run on the same day did not. We did not check whether this setting affects the commit charge. The two-card rows are the range over three launches, and the single-card rows are from one launch each. The single-card available commit after launch on October 25 (1.17–1.97GiB) also cannot be compared with the values in the October 24 available commit table, because available commit before launch was different.

For Gyro on October 24, the limit in the engine log (the value at launch) was 111.8GiB in every run, and 14GiB or more of available commit remained after launch, so we took it that the limit had not grown and treated the difference in available commit between one and two cards (about 16GiB) as the difference in commit charge (we did not read the limit after launch). This is close in size to the commit charge differences for IQ3_S (about 16GiB) and DeepSeek (about 14GiB) on October 25, but they were measured on different days under different conditions, and they are not values compared under the same conditions.

The roughly 82GiB added by two-card IQ3_S and the roughly 79GiB added by two-card DeepSeek are equal to or larger than the available commit before launch on October 24 (78–79GiB). We did not check whether the page file grows when launching from the October 24 level of available commit.

In the third two-card IQ3_S run, available commit stayed below 1GiB for about 50 seconds partway through the measurement with an input of about 32,000 tokens (the limit did not grow beyond 127.0GiB), and we stopped it under the looser criterion.

Commit when launching DeepSeek on one card with Strata 0.2.10: November 5, 2026

On November 5, 2026, we launched DeepSeek V4.1-Flash on one RTX 5080 with Strata 0.2.10, ISTA-DAS Coder four times (three launches for the speed measurement and one for the measurement with Claude Code and OpenCode connected) and 2.00bit three times. In every launch, available commit dropped to 0.27–0.79GiB partway through and Windows grew the page file; after launch, the commit limit was 121.1–122.6GiB and available commit was 0.62–1.59GiB. The increase in commit charge from launch was 71.50–76.74GiB for ISTA-DAS Coder and 77.04–77.50GiB for 2.00bit, more than for 2.00bit launched on one RTX 5080 with 0.2.4.1 on October 25 (65.08GiB). On 0.2.10 the engine places more experts in system RAM ("How it uses system RAM"), and other work was also running on this day (available commit before launch was 62.62–69.61GiB), so we have not broken down what the increase consists of. How available commit was read and how the charge was calculated are the same as on October 25. In every launch the engine kept running, and the measurement ran to the end.

What changes when you add a second GPU

According to the official MULTI_GPU.md, when there are two or more cards, each is assigned a Main, Helper or Off role. Main is the single card that handles the last part of the split (the output part, the MTP draft layers and their verification), and the faster card is normally chosen (a card with clearly more VRAM is chosen instead if it is at least half as fast as the faster one). Helper holds part of the layers and part of the experts. The 0.2.4 MULTI_GPU.md said "prompt processing gets about 20% faster", but the same document in 0.2.10 says the effect on speed depends on the cards and the workload (the document's section of older measurements has an example with Coder, 32K context, a Ryzen 9 9950X3D, an RTX 5080 and an RTX 3090, where prompt processing of about 28,000 tokens went from 1,970 to 2,357 tok/s; these are figures from around engine 0.1.20). Cards with 8GB or less start as Off when a larger card is present. Splitting happens only between cards from the same vendor and does not span NVIDIA and AMD. In the example in the 0.2.4 INSTALL.md, two cards, an RTX 5080 and an RTX 3090, gave 18–20% faster prompt processing than one RTX 5080, while generation speed (output tok/s) was about the same.

Roles are given as --gpu-roles 0=main,1=helper. On our test machine (October 24, 2026, Terminal in Strata 0.2.3.1 and 0.2.4.1), these numbers referred to the nvidia-smi numbering (the RTX 5080 is 0, the RTX 5060 Ti is 1), while Strata's screen counted from 1 and showed the RTX 5080 as "GPU 1" and the RTX 5060 Ti as "GPU 2". If you use the numbers shown on screen, the roles end up swapped. docs/MULTI_GPU.md also says the --gpus numbers are nvidia-smi numbers.

On October 24, 2026, on our test machine (Strata 0.2.3.1), we ran the Gyro-S and Gyro-M versions of Qwen3.8-Flash-Next with the RTX 5080 as Main and the RTX 5060 Ti, attached externally over OCuLink (PCIe 4.0 x4, 7.0GB/s bandwidth as measured by the engine), as Helper. Generation speed was almost the same as on one RTX 5080, while prompt processing speed fell to about half with an input of about 4,000 tokens and to around 70% with an input of about 32,000 tokens. With the roughly 4,000-token input, Gyro-S ran at 1,310 tok/s (2,602 tok/s on one card) and Gyro-M at 1,225 tok/s (2,624 tok/s on one card).

Strata's documentation describes two separate mechanisms for having the second card help with prompt processing. One is a feature in which the idle card helps when the layers are split across two cards (STRATA_PREFILL_HELP=1), and the two-GPU section of GYRO.md says this also works with Gyro. According to docs/MULTI_GPU.md, this feature works only when you turn it on, and it does not help with inputs of about 3.3K tokens or more. The other is a path that processes the prompt on the second card, and the known-limitations section of GYRO.md says Gyro does not use it and the prompt stays on the first card. We have not isolated why prompt processing slowed down in the Gyro measurements, including whether the bandwidth of the OCuLink link plays a part.

These numbers come from our test machine's combination, in which a card with lower compute performance is added over a narrow link, and we cannot say the same would hold for two cards connected at PCIe x16 or for other combinations. In Strata 0.2.7, released on October 27, the default way the Qwen-family engine processes prompts changed when layers are split across two NVIDIA cards. The official docs say that on two 16GB RTX A4000 cards, with most of the IQ3_XXS experts read from system RAM, the time to the first character for an input of about 32,000 tokens went from 141.8 seconds to 27.7 seconds. They also say speed was not measured on other card combinations and that the old method is used if the cards lack headroom for the new one, so we do not know whether our test machine's two cards would change the same way. The two-card values in this section were measured on 0.2.3.1 and 0.2.4.1, not on 0.2.7. In 0.2.10, even with two cards in a layer split (assigning layers to each card), Qwen3.8's drafting becomes DFlash2 when it is set to Auto (when the number of concurrent requests is one). Comparing DFlash2 and MTP on the same two cards of our test machine in 0.2.10, IQ3_S was compared on long answers (we did not measure MTP on short answers), and the two were nearly the same. Gyro-S was slower with DFlash2, by 20–30% on short answers and at less than half of MTP's speed on long answers. Compared with one RTX 5080 on the same day, long-answer generation speed for two-card IQ3_S was in the 70% range with either drafting method, which differs from this section's 0.2.3.1 result (no clear difference from one card). Because the version, the requests and the load from other work all differ, the 0.2.3.1 result cannot be applied to 0.2.10 (the 0.2.10 values are our measurements from November 4, 2026). Two-card IQ3_S on 0.2.10 was in the 70% range of one card even in the runs where MTP was selected, so the drafting switch alone cannot explain the difference from the 0.2.3.1 result.

On October 25, 2026, we measured IQ3_S on the same combination (Strata 0.2.3.1, same launch options as Gyro). Generation speed, as the median of per-launch medians, was 84.3 tok/s (about 1,000-token input), 96.4 tok/s (about 4,000 tokens) and 97.5 tok/s (about 32,000 tokens). That is equal to or higher than one RTX 5080 on October 25 (83.3, 94.6 and 82.6 tok/s from one launch) and lower than one card on October 24 (102.4, 101.3 and 108.1 tok/s). Variation from request to request was large, answer length differed between requests, and other work was running in parallel that day, so we cannot say that generation speed changed with two cards. Prompt processing speed fell to around 30%, 887 tok/s, with an input of about 4,000 tokens (one RTX 5080: 2,887–3,332 tok/s across October 24 and 25), and to just under half, 1,745 tok/s, with an input of about 32,000 tokens (one card: 3,649–4,090 tok/s). Time to the first character with the roughly 32,000-token input was 18.2 seconds (one card: 7.8–8.7 seconds). IQ3_S is not Gyro, so we do not know whether the GYRO.md known-limitations explanation above applies to it as is. We have not isolated the cause of the slower prompt processing, including whether the bandwidth of the OCuLink link plays a part (one card on October 25 also had little available commit after launch, 1.17GiB, but its prompt processing did not slow down).

In our earlier article testing ways to use a second GPU with Strata 0.1.39–0.1.41 (October 6 and 9, 2026, Qwen3.8-Flash-Next IQ3_S), on the same pairing of the RTX 5080 and the OCuLink-attached RTX 5060 Ti, prompt processing was slower than on one RTX 5080 in every configuration we tried. The settings differ from the 0.2 series' Main/Helper split. The results comparing layer splitting with the helper cache are covered in detail in How to use a second GPU with Strata.

When the 2.00bit DeepSeek set was launched on two cards (launch log of Strata 0.2.4.1, engine 0.1.49), the engine stopped splitting each layer's computation across the two cards and ran with each card handling different layers. The RTX 5060 Ti (Helper) took layers 0–20 and the RTX 5080 (Main) took layers 21–39 plus the output part. The experts placed on the GPUs were 1,125 on the RTX 5060 Ti and 1,029 on the RTX 5080, 2,154 across the two cards (about 14% of all 15,360). That is more than the 659 (about 4%) on a single-RTX 5080 launch, but the CPU still handled most of the rest. The engine log labels the cards CUDA0 and CUDA1, but these are not nvidia-smi numbers; they follow the order in which Strata re-sorted the cards, Helper first and Main last. We matched them to the physical cards using this launch's settings, Strata's card ordering, and what MULTI_GPU.md says Main handles.

On October 25, we measured DeepSeek's speed on this two-card launch (the layer and expert split in the launch log was the same as on the October 24 launch described above). Generation speed, as the median of per-launch medians, was 9.7 tok/s with an input of about 1,000 tokens and 9.2 tok/s with about 4,000 tokens. One RTX 5080 gave 7.7 and 8.0 tok/s in the October 24 runs and 6.3 and 7.0 tok/s in a single launch on October 25, the same day as the two-card runs, so the two-card values are higher than both (two-card IQ3_S was equal to or higher than one card on October 25 and lower than one card on October 24). Prompt processing was about the same as on one card, 136.8 tok/s with an input of about 4,000 tokens (one card: 139.0–143.5 tok/s across October 24 and 25). However, the October 25 single-card figure comes from one launch only, it was measured at a different time from the two-card runs, and neither the load from other work nor the use of the setting that skips the test response at launch (used only on the October 25 two-card runs, as described in How we measured, and what we did not measure) was matched. So we have not isolated how much of the difference is the effect of using two cards, and we have not checked how it relates to the larger number of experts placed on the GPUs, or why one card on October 25 was slower than on October 24.

On two-card launches, the increase in commit charge from launch was larger than on one card for every model (about 14–16GiB, for Gyro on October 24 and for IQ3_S and DeepSeek on October 25; these are values on 0.2.3.1 for Qwen and 0.2.4.1 for DeepSeek, and on two cards with 0.2.10 we did not measure the increase in commit charge from launch). The two-card values in this section, on both October 24 and 25, come from our test machine's combination in which a card with lower compute performance is added over a narrow link. The re-measured commit values for the IQ3_S and DeepSeek runs we stopped partway on October 24 are at the end of the section Available commit after launch: values measured on a PC with 96GB of system RAM.

Summary: what to choose for each amount of system RAM

• For Qwen3.8-Flash-Next, the tier that decides the size Strata picks first is set by system RAM + VRAM − 5GB (the 0.2.4 documentation we retrieved on October 24, 2026 recommended that size, but the 0.2.10 documentation gives a recommendation order of ISTA-DASLab, Unsloth, then Gyro, separate from the size picked first), and for the four amounts in the quick reference table it does not change between 12GB and 16GB of VRAM. However, at 32GB and 48GB of system RAM, the size picked first does not fit within the system-RAM-only rule of thumb, and it runs in low-RAM mode. By the formula in setup.py, IQ2_XS at 32GB uses the mode that reads through the OS file cache (mmap), which the official docs say becomes much slower on a small card. IQ3_XXS at 48GB can use the mode that copies the experts into system RAM (resident). With 48GB of system RAM you can also choose Q2_0 or IQ2_XS, which fit within the rule of thumb (Coder also fits if you only need code). We have not measured how much slower it gets or which is faster.
• A PC with 32GB of system RAM and 12–16GB of VRAM falls in the 40GB tier; the size picked first is Swift 1.5's IQ2_XS, and the other candidate is Gyro-M (per the tier table in the 0.2.4 MODELS.md retrieved on October 24, 2026; the 0.2.10 MODELS.md has no such table). On a PC where nothing larger fits, Gyro-S is a candidate (the selection guidance in the official GYRO.md), and if you only need code, Coder is (the official docs say it is weaker in languages other than English). However, on this PC IQ2_XS runs in low-RAM mode using the mode that reads through the OS file cache (mmap) (by the setup.py formula), and the only model the official docs give as an example of the mode that copies the experts into system RAM (resident) for this configuration is Coder.
• In a comparison of the RTX 4070 SUPER with 12GB of VRAM and the RTX 5060 Ti with 16GB (Strata 0.1 series, Q2_0, all experts in system RAM), generation speed was about the same and prompt processing was 10–20% slower on the 12GB card. The card models also differ, so we cannot say for certain that this is due to the difference in VRAM.
• On the Strata 0.2 series (0.2.3.1 for Qwen, 0.2.4.1 for DeepSeek), we swapped the RTX 5060 Ti on our test machine's OCuLink port for an RTX 4070 SUPER 12GB and measured on that card alone (October 29, 2026, 96GB of system RAM). Generation speed, relative to the 16GB RTX 5060 Ti on October 24, ranged from about the same to about 90% for IQ3_S, was around 70% for Gyro-S, and was about 90% for DeepSeek. Prompt processing was slower for both Qwen models, except for Gyro-S at about 32,000 tokens. Here too the card model and the measurement date differ, the October 24 IQ3_S runs overlapped with the download of another model, and for the DeepSeek 12GB runs there is no record of whether the setting that skips the test response at launch was used, so we cannot say for certain that this is due to the difference in VRAM. For Qwen's IQ3_S and Gyro-S, the engine warned that free VRAM was low when a request was received (the warning also appeared on the 16GB RTX 5060 Ti), but within what we measured, no request saw generation speed drop to a few tok/s (the lowest for a single request was 31.7 tok/s). These values predate 0.2.7 for Qwen (where the defaults changed only for NVIDIA cards with 13GiB of VRAM or less) and 0.2.5 for DeepSeek (where the defaults changed for PCs with 16GB of VRAM or less). Of the Qwen settings in 0.2.7, the one that makes it easier to pick experts already placed on the card was removed from the defaults in 0.2.8 for RTX cards with 12GB of VRAM or less (this is a separate setting from the default for how prompts are processed when layers are split across two NVIDIA cards, and the 0.2.8 release notes mention no change to that one). The Qwen values predate 0.2.10, and both the RTX 4070 SUPER and the RTX 5060 Ti measured in this item are on the list of cards for which the official docs say 0.2.10 uses DFlash2 under Auto (our own matching of the cards to that list); with the drafting setting on Auto and one concurrent request, drafting switches to DFlash2. We did not measure speed on 0.2.8, and we cannot say these values carry over as is to the current defaults. The RTX 4070 SUPER was not measured on 0.2.10 (the official release notes have no DFlash2-versus-MTP figures for the RTX 40 series either), and on one 16GB RTX 5060 Ti with IQ3_S, long-answer generation speed showed no large difference between DFlash2 and MTP on 0.2.10 (our measurement on November 4, 2026).
• DeepSeek V4.1-Flash also runs in the desktop app from 0.2.5, released October 25 (in 0.2.4, as of October 24, 2026, it was Terminal only). Whether you use Terminal or the desktop app, you will need to check free disk space and system RAM first. On our test machine (96GB of system RAM, one RTX 5080), the engine-reported generation speed (tok/s) of DeepSeek on Strata 0.2.4.1 was much slower than that of the Qwen3.8-Flash-Next IQ3_S (tokenization and generated length were not matched). ISTA-DAS Coder, the set for code added in 0.2.10, needs less disk than the 2.00bit set. On one RTX 5080 in our test machine (November 5, 2026; inputs of about 1,000 and about 4,000 tokens, answers up to 256 tokens, on a day when other work was running), its time to first token was about one quarter to one third of that for 2.00bit on the same day. Its generation speed was a little over 10% faster by median, but the ranges of the nine individual values overlapped.
• When we added a second GPU in our test machine's OCuLink combination (Strata 0.2.3.1 for Qwen, 0.2.4.1 for DeepSeek), we cannot say that generation speed changed from one card for Qwen3.8-Flash-Next's Gyro (October 24) and IQ3_S (October 25), and prompt processing became slower. For DeepSeek V4.1-Flash (October 25), generation speed in the two-card runs was higher than in the single-card run. The October 25 values are from a day when other work was running in parallel, and the load was not matched between one and two cards (for DeepSeek, the setting that skips the test response at launch was used on the October 25 two-card runs but not on the one-RTX 5080 run the same day), so we have not isolated how much is the effect of using two cards. In 0.2.7, the default way the Qwen-family engine processes prompts when layers are split across two NVIDIA cards changed, and these results were not measured on 0.2.7. In 0.2.10, even with two cards in a layer split (assigning layers to each card), drafting becomes DFlash2 when the number of concurrent requests is one and the drafting setting is Auto. On every two-card launch on our test machine, the engine reported 0–73MiB of free VRAM on the last-stage RTX 5080 (for both Gyro-S and IQ3_S, in both the DFlash2 and the MTP runs). Of these, two-card Gyro-S was slower with DFlash2 than with MTP (by 20–30% on short answers, at less than half the speed on long answers), while two-card IQ3_S was nearly the same on long answers. We do not know why only two-card Gyro-S was slower, nor whether two cards with more VRAM headroom would behave the same way. Long-answer generation speed for two-card IQ3_S was in the 70% range of one RTX 5080 with either drafting method (all of these are our measurements from November 4, 2026). The 0.2.3.1 finding in the first half of this item, that generation speed "cannot be said to have changed from one card", cannot be applied to 0.2.10, because the version, the requests and the load from other work all differ.
• In our test machine's two-card configuration, the increase in commit charge from launch was about 14–16GiB larger than on a single-card launch (Qwen on 0.2.3.1, with Gyro measured on October 24 and IQ3_S on October 25; DeepSeek on 0.2.4.1, measured on October 25; the conditions were not matched). We measured DeepSeek on 0.2.10 on one card only (November 5, 2026), and its increase in commit charge from launch was larger than on one card with 0.2.4.1. We did not measure the increase in commit charge from launch on two cards with 0.2.10, so this difference cannot be applied to 0.2.10. For two-card IQ3_S and DeepSeek on October 25, Windows grew the page file during launch, and available commit after it grew was 0.26–1.36GiB, less than 1GiB away from one card on the same day (1.17–1.97GiB).

In separate testing on Strata 0.2.10, we checked installation and basic use, including whether to start with the desktop app or Terminal, launching, updating and uninstalling.

Related articles by goal, and the versions we measured

The measurements summarized below were taken on the Strata 0.1 series, except for the DeepSeek V4.1-Flash coding-agent runs added on November 5. Their conditions therefore differ from this article's 0.2-series measurements.

• Qwen3.8-Flash-Next by quantization: we measured its speed for each quantization (Q2_0, IQ3_XXS, IQ3_S, UD-Q4_K_XL, Coder), compared it with plain llama.cpp and Qwen3.8-27B, and also measured the RTX 4070 SUPER with 12GB of VRAM. Strata 0.1.31–0.1.41 (October 1–9, 2026).
• How to use a second GPU with Strata: compared ways of using a second GPU (layer splitting and the helper cache). 0.1.39–0.1.41 (October 6 and 9).
• Thinking settings: we compared the none, low, medium and high thinking settings. 0.1.40 (October 6; the Japanese-language build-advice test used 0.1.39).
• Coding agents: we connected and compared Claude Code, Codex CLI and OpenCode. 0.1.41 (October 10). On November 5 we added the results of connecting Claude Code and OpenCode to DeepSeek V4.1-Flash ISTA-DAS Coder on 0.2.10.
• What changed in Strata's updates: summarized what the updates changed, based on the release notes up to 0.1.45 (as of October 18), and measured 0.1.41 and 0.1.45. On November 1 and 4 we also added summaries of the release notes up to 0.2.9 and 0.2.10 (the measurements are still those of 0.1.41 and 0.1.45).

How we measured, and what we did not measure

Test machine

Our test machine has an Intel Core i7-14700F, 96GB of system RAM, Windows 11 and NVIDIA driver 610.88. The RTX 5080 16GB sits in a motherboard slot, and the RTX 5060 Ti 16GB is attached externally over OCuLink (PCIe 4.0 x4). On October 29, 2026, we swapped the RTX 5060 Ti on that OCuLink port for an RTX 4070 SUPER 12GB for measurement.

The values newly measured for this article were taken on this test machine on October 24, 25 and 29, 2026. The values in "Update, November 4, 2026 (our measurement)" were measured on the same test machine on November 4. The values in "Update, November 5, 2026 (our measurement)" were measured on November 5 on one RTX 5080 in the same test machine, without stopping other work. On the 25th we measured the re-runs of two-card IQ3_S and DeepSeek, the control runs on one RTX 5080, and the cross-check of available commit readings; on the 29th, IQ3_S, Gyro-S and DeepSeek on one RTX 4070 SUPER 12GB. Values taken from other articles are given with that article's measurement date and version. On November 4, 2026, we separately ran a measurement on Strata 0.2.10's Terminal (Control 0.1.56) with Qwen engine 0.1.56 that alternated launches with DFlash2 and MTP drafting to compare them, and also recorded available commit after launch, a launch with --parallel 2, and the official functional check (standard-v1). The method and results are in "Update, November 4, 2026 (our measurement)" and are not included in the October 24–29 tables. In the October 24–29 Qwen3.8-Flash-Next runs, we did not specify the drafting setting, and they ran with the MTP draft layers under 0.2.3.1's Auto (confirmed in the engine log).

Versions and launch options

Qwen3.8-Flash-Next IQ3_S, Gyro-S and Gyro-M were launched with Strata 0.2.3.1's Terminal (Control 0.1.48.1) and Qwen engine 0.1.48, using strata launch with --context 64k --vision off --tune skip --access local. DeepSeek V4.1-Flash used 0.2.4.1's Terminal (Control 0.1.49.1) and DeepSeek engine 0.1.49, with --dsv41-package pointing to the local engine, and was launched with the default 8K context. Single-card runs used --gpu-roles 0=main (RTX 5080) or --gpu-roles 1=main (RTX 5060 Ti; RTX 4070 SUPER on October 29), two-card runs used --gpu-roles 0=main,1=helper, and everything else was left at Strata's defaults. The Qwen engine in 0.2.4 and 0.2.4.1 is the same file as 0.1.48. We did not measure in the desktop app. For the DeepSeek runs, the engine location was pointed at the 0.2.3.1 folder (we did not check whether this affected the results).

The November 5 DeepSeek runs (ISTA-DAS Coder and 2.00bit) used 0.2.10's Terminal (Control 0.1.56) and DeepSeek engine 0.1.56, launched with strata launch plus --vision off --access local --gpu-roles 0=main, with the context and speed settings left at the defaults (128K, five of six experts). We did not pass the engine with --dsv41-package and used the one Strata installed; the location of the engine and pack was the same 0.2.3.1 folder as in October. The model files were on the NVMe SSD at C:.

What each option we added does is shown in the table of option meanings (the meanings are from docs/TERMINAL_LAUNCH.md and the option descriptions of strata launch).

Option	Meaning
--context 64k	Sets the maximum context to 64K tokens
--vision off	Does not use the image-reading component
--tune skip	Skips the initial tuning that measures settings to find fast ones (launches from the command line do not tune in the first place)
--access local	Makes it usable only from this PC
--gpu-roles 0=main	Sets each card's role (Main, Helper, Off). On our test machine, one RTX 5080 was made Main (the numbers are nvidia-smi numbers)
--gpu-roles 1=main	Made one RTX 5060 Ti (on October 29, the swapped-in RTX 4070 SUPER) Main
--gpu-roles 0=main,1=helper	Two-card launch with the RTX 5080 as Main and the RTX 5060 Ti as Helper
--dsv41-package	Installs a DeepSeek engine package downloaded by hand from the release page as is, after verifying it

On the runs where DeepSeek ran on the RTX 5060 Ti alone (Strata 0.2.4.1, --gpu-roles 1=main) and on the two-card runs on October 25 (--gpu-roles 0=main,1=helper), the launch-time test response stopped with "invalid device ordinal", so we launched with the setting that skips the test response (STRATA_DSV41_NO_SMOKE=1), and the measurements then ran normally. The two-card launch on October 24 got as far as loading without this setting; we did not check why they differed. The one-RTX 5080 run on October 25 was launched without this setting, and the launch options recorded in the engine log were the same for one and two cards apart from those for splitting across two cards (DSpark was not loaded in either). We did not check whether this setting affects speed. We also did not check whether this is a bug in Strata. For the one-RTX 4070 SUPER run on October 29 (--gpu-roles 1=main), there is no record of whether this setting was used.

How we measured speed

Speed was measured with the speed mode of strata-bench.py in the Strata GitHub repository's bench/results/2026-09-29-rtx3090-epyc-milan/data/ directory (a script that came with a community benchmark result and is not included in an installed Strata). The input was the script's default: a set of source files (here, files from the Strata repository) followed by a request to explain what the last file does and to propose one improvement as a diff, at temperature 0. We sent three inputs each sized to about 1,000 and about 4,000 tokens (and also about 32,000 tokens for Qwen), with a generation limit of 256 tokens and thinking off. The script gives each request its own identifier and re-adjusts the next input's length from the actual token count of the previous request, so no two requests had the same text, and the actual inputs were 977–1,129, 4,168–4,896 and 31,584–31,713 tokens. With IQ3_S, many requests ended before reaching 256 tokens. For each condition we repeated a cycle of stopping and restarting the server three times, and took the median of the per-launch medians (for DeepSeek on November 5, we took the median of the nine runs over three launches; the actual inputs on that day were 976–1,120 and 4,170–4,895 tokens, and the ranges in the previous sentence are from the October measurements). The October 25 re-measurements were three launches for two-card DeepSeek, two for two-card IQ3_S (the third was stopped partway), and one launch for each control run on one RTX 5080; where there is only one launch, the value is that launch's median. During the October 25 measurements, other work was running in parallel on the same PC almost continuously, so that day's speed values may be affected by it (we did not measure how heavy that load was). We did not clear the OS file cache, and with DeepSeek the engine's expert record (expert-profile.bin) was rewritten during the measurements, so restarted runs are not fully independent of each other. The speed values are those reported by Strata's engine, and they were nearly the same as values calculated from the API responses. Because these come from requests to read code, generation speed may differ in prose-centered conversations.

What we did not measure

Things we did not measure, in this article or in the related articles listed by goal, are: PCs with 32GB, 48GB or 64GB of system RAM; Gyro-M and two-card configurations on a card with 12GB of VRAM; a 12GB card plugged into a motherboard slot instead of over OCuLink; AMD and Intel cards and Macs; the desktop app; Swift 1.5, IQ2_XS, NVFP4 and Qwen3.6-35B-A3B, and the Unsloth files other than UD-Q4_K_XL; DeepSeek's 1.75bit and 2.25bit sets, Unsloth's 1bit set (from 0.2.9); two-card speed and commit charge for IQ3_S and DeepSeek without other work running in parallel (on versions before 0.2.10; two-card IQ3_S was measured on 0.2.10 on November 4 with other work stopped, but we report only the DFlash2-versus-MTP comparison (including the ratio to one RTX 5080 on the same day), available commit and the functional check results); a DeepSeek comparison with the test-response-skipping setting matched (one card versus two, RTX 5060 Ti versus RTX 4070 SUPER); speed on Strata 0.2.4.2–0.2.9; Gyro-M speed on 0.2.10; DeepSeek speed on 0.2.10 on the RTX 5060 Ti, on a card with 12GB of VRAM and on two cards, and commit charge on two cards; DeepSeek speed on 0.2.10 with other work stopped; a comparison placing 0.2.10 values side by side with the versions in the tables (for 0.2.10, the values from alternating DFlash2 and MTP and others are in the November 4, 2026 update); 12GB VRAM cards on 0.2.10, and Gyro-S on a single RTX 5060 Ti on 0.2.10; the behavior of moving work off the card in stages when VRAM runs short; splitting each layer across all cards; total speed with two or more concurrent requests; and speed differences depending on which drive Gyro is stored on. Answer quality is not compared in this article.

References

• Strata README (Niko1221/Strata, GitHub)
• Strata docs/MODELS.md
• Strata docs/GYRO.md
• Strata docs/QWEN36.md
• Strata docs/MULTI_GPU.md
• Strata docs/INSTALL.md
• Strata docs/TERMINAL_LAUNCH.md
• Strata docs/DEEPSEEK41.md
• Strata setup.py (memory tier boundaries)
• Strata docs/DETAILS.md (low-RAM mode methods)
• Strata docs/UNSLOTH_Q4.md
• Strata tools/strata_mcp.py (desktop app and strata launch suggestions)
• Strata v0.2.4 release (including the 0.2.4.1 and 0.2.4.2 updates)
• Strata v0.2.5 release (the version in which DeepSeek runs in the desktop app)
• Strata v0.2.6 release (the version that updated the DeepSeek engine to 0.1.51)
• Strata v0.2.7 release (including the 0.2.7.1 update)
• Strata v0.2.8 release (the version that removed the expert-selection setting made default in 0.2.7 from the defaults on RTX cards with 12GB or less)
• Strata v0.2.9 release (the version that added Unsloth's 1bit set for DeepSeek)
• Strata v0.2.10 release (the version that made Auto drafting use DFlash2 for Qwen3.8)
• Strata v0.2.3 release (the version that made DFlash2 selectable in Terminal)
• DeepSeek-V4.1-Flash-1017 GSQ-RCO GGUF (ISTA-DASLab, Hugging Face)
• DeepSeek-V4.1-Flash-1017 GSQ-RCO Coder GGUF (ISTA-DASLab, Hugging Face)
• Qwen3.8-Flash-Next GSQ-RCO GGUF (ISTA-DASLab, Hugging Face)
• Swift 1.5 GSQ-RCO GGUF (UkisAI, Hugging Face)
• Project Maya (GitHub)