DeepSeek V4.1 on RTX 4090 24GB: 27.9 tok/s, 15.0 with RAM capped at 64GiB

We measured the 274GB version of DeepSeek V4.1 Flash, compressed to an average of 2.25 bits, with Strata 0.2.13.1 on one rented cloud server (RTX 4090 24GB, 180.6GiB of usable RAM). Generation speed for a short question was 27.9 tokens per second (median of three runs, range 24.0~30.5). When we cut the RAM the engine could use to 64GiB, speed fell to 15.0 tokens per second, but the engine did not stop. On a 150-question Korean multiple-choice test, it answered 106 correctly (70.7%).

All values come from a single test campaign on this one server (speeds are medians of three runs). We cannot guarantee that another computer would get the same value for RAM read speed (this server's peak was 61.4GB per second).

Conclusions first

1. Speed: Even with the input stretched to about 31,000 tokens, generation stayed at 25.3 tokens per second, but the time to the first character was 18.8 seconds. With an input of about 119,000 tokens it was 60.6 seconds.
2. RAM: When we cut the RAM the engine could use from 180.6GiB to 128, 96 and 64GiB, speed fell to 27.3, 23.8, 20.1 and 15.0 tokens per second (87, 74 and 55% of the maximum). This test only reduced capacity.
3. Korean and coding: On KMMLU, 106 of 150 questions were correct (95% interval 62.9~77.4%). For coding, only the first 20 of the 52 problems were run, and 16 passed. For tool calls, only the first 15 of the 49 tasks were run, and 14 passed. There is no comparison model, so we do not say whether these scores are good or bad.

What kinds of numbers are in this article

• Our measurement: values we measured directly on this server. Speeds are the median of 3 runs (2 runs for long inputs).
• Calculation: arithmetic done on our values (percent of maximum, adoption rate, confidence interval, cost).
• Program output: the plan and metrics Strata reported on the server.
• Official documentation / reports by others: the Strata repository documentation and other people's values quoted there. We do not put them on the same line as our values.
• Estimate: not used as a number.

How the 274GB model runs

274GB is the sum of the main model at 155GB, the n-gram (word-group) table at 111GB and the helper model (DSpark) at 8GB (program output). It does not fit entirely on a 24GB card. The plan the program reported puts only 1,577 of the 15,360 experts on the card (about 16GB, 10.3%). The other 13,783 (about 133GB) are computed by the CPU from RAM, and whatever does not fit in RAM, plus the n-gram table, is read from the SSD. The 1,577 figure is a planned value. The number of expert slots on the card reported by the servers we actually started was 1,634 at 8K context, 1,623 at 64K and 1,613 at 128K.

The Strata documentation has no DeepSeek figures measured on a 24GB card, and it states that the author could not test on the RTX 40 series directly (official documentation, accessed 2026-11-10).

Speed: generation runs at 22~28 tokens per second, and the first character takes longer as the input grows

We turned thinking off and sent one request at a time. The speed test used temperature 1.0 and 256 output tokens.

*Measured on a server started with a context limit of 131,072 tokens, 2 runs each, with 128 output tokens. The 61,054-token row and the other two were measured on separately started servers, so they are not a side-by-side comparison with the top 4 rows. The longest input was 119,069 tokens; we could not measure a 131,072-token input. The time to first character at the 4K input (8.6 s) is long for its input length. It was the same after we restarted the server, but we did not find the reason. The RTX 5070, 3060 and Radeon values in the dotted boxes below the figure are other people's reports quoted in the Strata plan output, so they are not on the same axis as our bars.

The helper model DSpark was not used by this server under the default (auto) setting (all 12 requests had 0 proposals and 0 accepted). When we forced it on, 586 of 728 proposals were accepted (80.5%), but speed rose only to 28.8 and 25.9 tokens per second, which is 3.3% and 0.5% higher, and the ranges of the three runs overlap. The server with it on had 798 expert slots on the card (1,623 by default), so this is not a comparison where only one thing changed. The RTX 4090 48GB value in the dotted box is a report by others on a card with different memory, so we did not line it up with our values (reports by others).

When the RAM is reduced

On the same server, we occupied RAM so that only the RAM the engine could use was reduced. RAM read speed and the card stayed the same. The server context was 8K, each step is the median of 2 runs, and the basis is context 0 (short question).

There were no errors or stops even at 64GiB. The percent versus maximum is a calculation, and the SSD read is a calculated value: the amount read during the test window divided by the time. SSD reads rose as RAM shrank, but we only checked that they move together and do not conclude that one causes the other. The 27.3 at the maximum step differs from the 27.9 in the speed table because the server setting (context 8K) is different. We did not measure RAM below 64GiB, and because we occupied RAM, there is no guarantee that this equals a computer that really has 64GB of RAM.

Korean, coding and tool calls

All were measured with thinking off and greedy decoding (one run per question). The KMMLU multiple-choice test (10 subjects × 15 questions, 4 choices each) gave 106 correct out of 150, which is 70.7%, with a 95% interval of 62.9~77.4%. Guessing would give 25%. The 4 answers that could not be read were counted as wrong. We have no other model's score on the same questions, so we do not say whether it is good or bad.

Chinese characters mixed into the output appeared in 1 of 12 short Korean requests ('교류' was output as '交流'). Among 20 long texts where we let it write up to 700 tokens, 0 were judged to have collapsed into repeating the same words. Answers mixed with Chinese characters or Chinese were 1 of 10 for greedy and 1 of 10 for sampling, counted after reading the original text and excluding parenthetical glosses.

For coding, only the first 20 of the 52 problems (27 contest problems and 25 practical ones we made ourselves) were run, and all of those 20 are contest problems (LiveCodeBench, based on Japan's AtCoder). 16 passed (80.0%, 95% interval 58.4~91.9%): 8/8 easy and 8/12 medium. We ran none of the 25 practical problems we made. For tool calls, 14 of the first 15 of 49 tasks passed (93.3%, 70.2~98.8%). The one failure was caused by a disallowed argument and one unnecessary tool call, and the final answer was correct. Both are single-run results on only the first part of each set, so they are not scores for real development work.

Cost calculation

The server rate shown on the rental screen is 0.696 dollars per hour (graphics card 0.600 + disk 0.096). Assuming the server never rests and produces text for one request at a time, the cost per 1 million output tokens is 0.696 ÷ (generation speed × 3,600) × 1,000,000, which is 7.09 dollars at maximum RAM, 8.14 dollars at 128GiB, 9.60 dollars at 96GiB and 12.93 dollars at 64GiB (calculation; the rate is the value shown on the rental screen). This is the most favorable condition, excluding time spent reading input, time spent loading the model, idle time and the download bandwidth charge (about 2.61 dollars). We could not confirm the official API prices, so we did not compare against them.

Limits and what we could not confirm

• One server, first round. We did not repeat the same tests on another server.
• The RAM read speed of 61.4GB/s is the peak of sequential reads with 24 threads with the engine turned off; the engine's actual access is probably lower, but we did not measure it. The RAM type, speed and module layout could not be checked because the container blocks it.
• The card's power was limited to 350W out of a maximum of 450W (same wording as in the video; the 450W figure is from the server session). We did not change the limit and measure again, so we do not know whether it affected speed.
• There is no comparison model (a score from solving the same questions with another model or at original precision).
• The headline speed is the value from the speed test (temperature 1.0, 256 output tokens). The generation speed the engine reported during the Korean and coding tests was 31~42 tokens per second for requests with 100 or more output tokens, and we could not confirm the reason for the difference.
• Once, sending the same request twice with greedy decoding gave different answers, so we cannot say that rerunning the scores would give the same result.
• We did not reduce card memory, measure wall power, test concurrent requests, or compare with other engines.
• In the task test (temperature 0.7, one run each), turning thinking on increased the apology email from 8.2 to 19.0 seconds, and the snake game was cut off at the 3,500-token limit. We did not grade whether the output works.

Reference date

Measurements were taken on 2026-11-10, and this article is based on the video publication date (2026-11-10). Strata 0.2.13.1 (engine 0.1.59.1), and the model is the 2.25-bit average version. Rental rates and documentation content may change.