The Corsair FlexPrime V20C is a micro-ATX tower workstation built for local AI work, pairing a 24-core Intel Core Ultra 7 270K Plus with an Intel Arc Pro B70 and its 32GB of dedicated graphics memory. It ships with Ubuntu 24.04 LTS, a 360mm liquid CPU cooler, and an 850W power supply, and it belongs to the CORSAIR PRO line of AI workstations and servers the company introduced in May 2026. We tested it on Linux against a compact RTX PRO 4000 workstation and two desktops built around 128GB of unified memory.

Key Takeaways
- The Arc Pro B70 led or tied our LLM serving tests on every model that fit. Through llama.cpp on SYCL, the V20C served Ministral 3 8B to one user at 63.7 tokens per second, against 52.0 for the RTX PRO 4000 SFF in the Dell Pro Max Micro and 37.0 for the Dell Pro Max with GB10.
- 32GB of graphics memory ran a 27B model that the 24GB card could not load. Qwen3.8 27B generated 19.8 tokens per second for one request and 35.4 across eight. The GB10 managed 11.2 for one request and matched the V20C at eight.
- The 24-core Core Ultra 7 270K Plus led every build and render test we ran. It rendered Blender Monster at 330.4 samples per minute against 285.3 on the AMD Ryzen AI Halo, finished the LLVM build in 136 seconds against 149, 173, and 175, and compiled the Linux kernel in 639 seconds against 918 and 892.
- The software backend decides the result on this GPU. Ollama and stable-diffusion.cpp ran through Vulkan, where the V20C generated 32.2 tokens per second in the coding agent against 53.9 on the GB10 and produced 4.26 FLUX.2 images per minute against 9.96.
- It lists at $3,999.99, level with the AMD Ryzen AI Halo and about $3,500 under a 128GB Dell Pro Max with GB10. Those systems hold larger models and reach 114GB/s to 121GB/s of memory bandwidth against 68GB/s here, which showed in OpenFOAM at 1,636 seconds against 1,222 and 1,148.
- Fan control and the SSD need attention. The fans ramped up and down irregularly during testing, which we did not take the time to diagnose, and the 1TB SSD peaked at 184K IOPS in 4K random write while reaching 81C.
Where the FlexPrime V20C Sits
CORSAIR PRO is the portfolio of AI systems Corsair launched earlier this year, with FlexPrime as the workstation family and FlexGrid as the rack servers. Corsair describes FlexPrime as an AI workstation for teams that want to develop, fine-tune, and deploy AI locally, and the V20C is a fixed configuration in the line’s V20 chassis, sold as SKU CSW-9040004-NA. The same chassis is available through Corsair’s configurator with NVIDIA RTX PRO Blackwell cards and the AMD Radeon AI PRO R9700, with other processors and up to 128GB of memory.
The V20C lists at $3,999.99 on Corsair’s store and was in stock at the time of writing, with a three-year warranty and lifetime technical support. That price covers the Core Ultra 7 270K Plus, the Arc Pro B70, 32GB of DDR5 as two 16GB DIMMs, a 1TB M.2 NVMe SSD, and Ubuntu 24.04 LTS. Corsair shipped our review unit with four 16GB DIMMs for 64GB of system memory, so the results below reflect twice the listed memory. Corsair sells the B70 system in the US only as a predefined, validated configuration outside its configurator, so the 64GB build we tested has no separate listed price.
Intel launched the Arc Pro B70 at $949 with 32GB of GDDR6, 32 Xe2 cores, 256 XMX engines, and 608GB/s of memory bandwidth, which is how a workstation at this price reaches 32GB of graphics memory. In our Intel Arc Pro B70 review, we found the hardware ahead of its software stack, with driver and framework support trailing CUDA and ROCm. The V20C puts that card in a prebuilt Linux workstation, so this review also checks how far the stack has come since then.
Corsair publishes token rates for the B70 on the product page, including about 55 tokens per second on Qwen3.8-27B, about 85 on Gemma-4-E4B, and about 20 on Qwen3.5-27B. The page does not list the quantization, inference engine, or context length behind those numbers, so they should be considered directional.
Build and Design
The V20C measures 202 x 451 x 286mm (7.95 x 17.76 x 11.26in) in width, depth, and height and weighs 14kg (30.9lb), a small footprint for a fractional tower that carries a full-size graphics card and a 360mm radiator. Corsair puts the volume at 26.1 liters and rotates the motherboard 180 degrees, so the graphics card draws intake air from the top and exhausts out the side. The case clears cards up to 400mm long and has a rear 120mm exhaust mount. The micro-ATX chassis is black with a Corsair badge on its perforated side panel, though we couldn’t match it to a case in Corsair’s retail lineup.
Corsair specifies tool-free panel removal, and the side panel on our unit comes off as it should. The company describes the layout as a component-focused cooling design with individual dedicated airflow paths. The configurator lists support for two 360mm radiators. Corsair also sells a display panel accessory for the side of the chassis, which we did not test, and it is hard to see the use for one on a workstation.
CPU cooling comes from a 360mm liquid cooler, and Corsair includes five 120mm fans in the system. The cooler in our unit is a variant of Corsair’s iCUE LINK TITAN 360 RX RGB fitted with non-RGB fans, and its radiator and three fans mount on a bracket along the side of the case that comes away with the tubes attached to expose the motherboard. The graphics card is an air-cooled ASRock Arc Pro B70, and power comes from a Corsair RM850e, an 850W supply with an 80 PLUS Gold rating.

During our testing under Ubuntu, the fans ramped up and down irregularly as loads started and stopped. We did not spend much time diagnosing the behavior to see whether it is fixable, and if it is not resolved, it is a little distracting.
The motherboard in our unit is reported as the ASUS PRIME Z890M-PLUS WIFI on BIOS 3012, a micro-ATX Z890 board with Wi-Fi 7. Memory is Crucial Pro DDR5-6400 in 16GB DIMMs, with all four slots filled on our unit, and storage is a 1TB XPG MARS 970 PLUS on a PCIe Gen5 x4 link. These are standard desktop parts, so memory, storage, the graphics card, and the power supply can all be replaced later.
Corsair’s configurator lists three M.2 2280 slots: one PCIe 5.0 x4 and two PCIe 4.0 x4. Storage expansion also includes six SATA ports, two 2.5-inch bays, and one bay that accommodates either a 3.5-inch or a 2.5-inch drive. The board has four expansion slots: a PCIe 5.0 x16 slot for the B70, one PCIe 4.0 x4 slot, and two PCIe 4.0 x1 slots. With the boot drive in the Gen5 slot, the two Gen4 M.2 slots are open for more storage.
The front I/O strip sits on the top panel and carries one 5Gbps USB Type-C port, two 5Gbps USB Type-A ports, and a combo audio jack beside the power button.

Around the back, the motherboard supplies one 20Gbps USB Type-C port, one 10Gbps USB Type-A port, four 5Gbps USB Type-A ports, and two USB 2.0 ports, with 2.5GbE, Wi-Fi 7 antenna connectors, and three audio jacks. The B70 has four DisplayPort 2.1 outputs, and the board adds DisplayPort and HDMI for the processor’s integrated graphics.

Corsair ships the V20C with Ubuntu 24.04 LTS and lists Windows 11 Pro as an alternative in the configurator. The company advertises a turnkey agentic AI software stack with integrated frameworks, GPU acceleration, containers, monitoring, and developer tools. Corsair describes a CORSAIR PRO dashboard on that image for downloading and switching local models, choosing between the PI Agent and Hermes agent harnesses, and managing apps. Its setup guide for this SKU walks through serving Qwen3.8-27B with llama.cpp in Docker at a 65,536-token context and connecting Hermes Desktop to that local endpoint.
Corsair’s configurator describes the Ubuntu installation as including the GPU driver and a compute runtime matched to the graphics card, with an optional Corsair AI Stack that adds Docker with a GPU runtime, monitoring tools, and Python. The lab replaced the factory image before testing.
Corsair FlexPrime V20C Specifications
| Specification | Corsair FlexPrime V20C |
|---|---|
| Platform | |
| SKU | CSW-9040004-NA |
| Processor | Intel Core Ultra 7 270K Plus, 24 cores (8 P-cores, 16 E-cores), 24 threads, up to 5.5GHz |
| Graphics | Intel Arc Pro B70, 32GB GDDR6 32 Xe2 cores, 256 XMX engines 608GB/s memory bandwidth ASRock card as tested |
| Memory | 32GB (2x 16GB) DDR5 as listed 64GB (4x 16GB) Crucial Pro DDR5-6400 as tested |
| Storage | 1TB M.2 NVMe SSD XPG MARS 970 PLUS on a PCIe Gen5 x4 link as tested |
| Motherboard | Intel Z890, micro-ATX ASUS PRIME Z890M-PLUS WIFI as tested |
| Operating System | Ubuntu 24.04 LTS as shipped Ubuntu 26.04.1 LTS as tested |
| Cooling and Power | |
| CPU Cooling | 360mm liquid cooler Corsair iCUE LINK TITAN 360 RX with non-RGB fans as tested |
| System Fans | 5x 120mm |
| GPU Cooling | Air |
| Power Supply | 850W Corsair RM850e as tested |
| Connectivity | |
| Front Ports | 1x USB Type-C (5Gbps) 2x USB Type-A (5Gbps) 1x combo audio |
| Rear Ports | 1x USB Type-C (20Gbps) 1x USB Type-A (10Gbps) 4x USB Type-A (5Gbps) 2x USB 2.0 DisplayPort, HDMI 3x audio |
| GPU Outputs | 4x DisplayPort 2.1 |
| Networking | 2.5GbE Wi-Fi 7, Bluetooth 5.4 |
| Expansion | M.2 2280: 1x PCIe 5.0 x4, 2x PCIe 4.0 x4 PCIe: 1x 5.0 x16, 1x 4.0 x4, 2x 4.0 x1 Bays: 2x 2.5-inch, 1x 3.5-inch or 2.5-inch |
| Physical and Support | |
| Dimensions (W x D x H) | 202 x 451 x 286mm (7.95 x 17.76 x 11.26in) |
| Weight | 14kg (30.9lb) |
| Color | Black |
| Warranty | 3 years, lifetime technical support |
| Price | $3,999.99 (Corsair, with 32GB of memory) |
Test Setup and Methodology
Corsair’s factory image is Ubuntu 24.04 LTS, and because we test higher-end workstations on Linux with a current kernel, the lab installed Ubuntu 26.04.1 LTS with the 7.0 kernel. That’s the same release running on the Dell Pro Max Micro in this review. The V20C ran on the performance power profile with BIOS 3012, Mesa 26.0.8, and Intel’s xe kernel driver, and the suite measured 31.9GB of GPU-usable memory on the Arc Pro B70.
Results come from three in-house suites, starting with sr-client_linux 0.1, the Linux build of our client suite, which covers local AI, content creation, graphics, and storage. Cinebench, Geekbench, 3DMark, PCMark, and Procyon have no Linux builds, so those tests and our 30-minute sustained loop are absent. Our benchmark harness wraps Phoronix Test Suite workloads and y-cruncher, and our server suite runs ClickBench, OpenFOAM, STREAM, and Valkey.
The client results combine three runs of the suite, and where a test ran more than once, we report the newest valid result. Each figure is the median of repeated passes. Fine-tuning did not run on the V20C because the suite’s PyTorch builds cover CUDA and ROCm, so we have no measured result for the fine-tuning part of Corsair’s description, and the image and LLM workloads that need 38GB or more of GPU memory did not fit.
The comparison set covers three ways to buy local AI hardware. The Dell Pro Max Micro is a compact workstation with the 24-core Core Ultra 9 285, a 24GB RTX PRO 4000 Blackwell SFF, and 96GB of DDR5-6400. The Dell Pro Max with GB10 runs NVIDIA’s 20-core GB10 with 128GB of unified memory on NVIDIA’s Ubuntu 24.04 image, and the AMD Ryzen AI Halo runs the 16-core Ryzen AI Max+ 395 with 128GB of unified LPDDR5X on AMD’s Linux developer image.
The Halo ran sr-client_linux 0.1, harness v3.6, and server suite r5.28 on AMD’s developer image. The GB10 ran earlier releases of the harness and server suite with the same application versions, and the three operating systems carry different compilers, which affects source-built tests such as the kernel compile.
Software paths differ by GPU vendor and shape every AI result that follows. On the V20C, MLPerf Client ran through OpenVINO, while llama.cpp ran on its SYCL backend at fp16. Ollama and stable-diffusion.cpp ran through Vulkan because Ollama’s native path placed none of the model on the Arc card. The two NVIDIA systems used CUDA throughout, and the Halo used AMD’s ROCm, and one Ollama run on the V20C ended with a Vulkan device-lost error before passing on a rerun.
| Configuration | CPU | Memory | GPU | Boot Drive | Operating System |
|---|---|---|---|---|---|
| Corsair FlexPrime V20C | Core Ultra 7 270K Plus, 24 cores | 64GB DDR5-6400 (4x 16GB) | Intel Arc Pro B70, 31.9GB usable | 1TB XPG MARS 970 PLUS, PCIe Gen5 | Ubuntu 26.04.1 LTS, kernel 7.0 |
| Dell Pro Max Micro (FCM2250) | Core Ultra 9 285, 24 cores | 96GB DDR5-6400 (2x 48GB) | NVIDIA RTX PRO 4000 Blackwell SFF, 23.9GB usable | 1TB Sandisk SN8050S, PCIe Gen5 | Ubuntu 26.04.1 LTS, kernel 7.0 |
| Dell Pro Max with GB10 (FCM1253) | NVIDIA GB10, 20 cores | 128GB LPDDR5X-8533, unified | NVIDIA GB10, 121.6GB usable | 4TB PCIe Gen4 | Ubuntu 24.04.5 LTS, NVIDIA kernel 7.0 |
| AMD Ryzen AI Halo | Ryzen AI Max+ 395, 16 cores | 128GB LPDDR5X-8000, unified | Radeon 8060S (integrated), 95.5GB usable | 2TB Micron 4600, PCIe Gen4 link | AMD Linux developer image, kernel 7.2 |
Local AI Performance
The Arc Pro B70 gives the V20C 32GB of dedicated graphics memory, 8GB more than the RTX PRO 4000 SFF in the Dell Pro Max Micro and about a quarter of what the GB10 can address from its unified pool. The suite placed the V20C’s 31.9GB in the same memory tier as the 24GB Dell, so it ran the 20B agent model and the 27B serving model. The larger tiers that the 128GB systems qualify for did not run.
LLM Serving
| llama.cpp server (higher is better unless noted) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| Ministral 3 3B, 1 request (tokens/s) | 84.9 | 80.7 | 53.2 | 43.0 |
| Ministral 3 3B, 4 requests (tokens/s) | 213.3 | 201.5 | 139.8 | 105.1 |
| Ministral 3 3B, 1 request, time to first token (ms, lower is better) | 590 | 666 | 572 | 1,659 |
| Ministral 3 8B, 1 request (tokens/s) | 63.7 | 52.0 | 37.0 | 30.6 |
| Ministral 3 8B, 4 requests (tokens/s) | 141.8 | 108.9 | 97.2 | 66.6 |
| Ministral 3 8B, 1 request, time to first token (ms, lower is better) | 1,362 | 1,477 | 1,398 | 4,602 |
| Qwen3.8 27B, 1 request (tokens/s) | 19.8 | Did not fit | 11.2 | 9.1 |
| Qwen3.8 27B, 4 requests (tokens/s) | 33.5 | Did not fit | 27.1 | 18.4 |
| Qwen3.8 27B, 8 requests (tokens/s) | 35.4 | Did not fit | 35.6 | 20.1 |
| Qwen3.8 27B, 1 request, time to first token (ms, lower is better) | 9,005 | Did not fit | 9,207 | 24,024 |
LLM serving runs the llama.cpp server with 4,096-token prompts and 1,024-token outputs on the Ministral 3 models. The V20C led both NVIDIA systems on those models, serving the 3B model to one user at 84.9 tokens per second, 5 percent ahead of the RTX PRO 4000 SFF and 60 percent ahead of the GB10, and the 8B model at 63.7 tokens per second, which is 22 percent and 72 percent ahead of the same two systems. At four concurrent requests, it delivered 213.3 and 141.8 tokens per second, 6 percent and 30 percent ahead of the Dell Pro Max Micro.
The Halo’s integrated Radeon 8060S, running llama.cpp on ROCm, trailed all three. It served the 3B model at 43.0 tokens per second for one request and the 8B model at 30.6, about half the V20C’s rates, and generated 9.1 tokens per second on Qwen3.8 27B with a median first token at 24.0 seconds, against 9.0 seconds on the V20C.

Qwen3.8 27B at Q4_K_M needs 30GB of GPU-usable memory for its weights and one request’s KV cache, so the 24GB RTX PRO 4000 SFF could not run it, and the V20C’s 31.9GB cleared the bar at every concurrency level. With a single request, the V20C generated 19.8 tokens per second, 77 percent faster than the GB10’s 11.2. Its lead narrowed to 24 percent with four concurrent requests. At eight, the systems were effectively tied, delivering 35.4 and 35.6 tokens per second, respectively.
Time to first token on the 27B model’s 8,192-token prompts was 9.0 seconds on the V20C and 9.2 seconds on the GB10, so prompt processing is level between them and the B70’s advantage is in generation. Corsair lists about 55 tokens per second for this model without stating its settings. Under our conditions, a single V20C user sees about 20 tokens per second, and the system’s total output tops out near 35 as requests are added.

MLPerf Client v2.0
| MLPerf Client v2.0 (OpenVINO, GPU) | Corsair FlexPrime V20C |
|---|---|
| Llama 3.1 8B, time to first token (s, lower is better) | 0.08 |
| Llama 3.1 8B, token rate (tokens/s) | 105.4 |
| Phi-4-mini, time to first token (s, lower is better) | 0.07 |
| Phi-4-mini, token rate (tokens/s) | 130.0 |
MLPerf Client v2.0 ran through OpenVINO on the Arc Pro B70 and returned the highest single-stream token rates the V20C produced in any test. Llama 3.1 8B generated 105.4 tokens per second with a first token in 0.08 seconds, and Phi-4-mini reached 130.0 tokens per second. The benchmark’s Linux release ships only Intel OpenVINO configurations and has no arm64 build, so none of the other three systems could run it; the V20C stands alone in this table.
Model Loading and the Coding Agent
| gpt-oss:20b (Ollama 0.40.3) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| gpt-oss:20b cold load to first token (s, lower is better) | 6.29 | 5.11 | 6.86 | 4.20 |
| gpt-oss:20b warm load to first token (s, lower is better) | 3.18 | 3.12 | 6.36 | 4.03 |
| Coding agent, successful runs (of 3) | 3 | 1 | 3 | 2 |
| Coding agent, median wall time (s, lower is better) | 368 | 80* | 221 | 282* |
| Coding agent, generation rate (tokens/s) | 32.2 | 76.2 | 53.9 | 41.2 |
| Speedometer slowdown beside the agent (x, lower is better) | 1.03 | Not run | 1.54 | 1.16 |
*The Dell Pro Max Micro completed one of three agent runs and the AMD Ryzen AI Halo completed two of three; the times shown are for the completed runs.
The model-load test times Ollama from launch to first token on gpt-oss:20b, a 12.8GB model, cold from the SSD and warm from the page cache. The V20C took 6.29 seconds cold and 3.18 seconds warm, against 5.11 and 3.12 on the Dell Pro Max Micro, 6.86 and 6.36 on the GB10, and 4.20 and 4.03 on the Halo. During the cold load, the V20C read at 4,040MB/s against the 7,311MB/s ceiling we measured for its drive in fio, so the runtime sets the pace more than the SSD does.
The coding agent test runs Crush against gpt-oss:20b with a 64K context through a fixed programming task, three times, with up to three rounds each. The V20C passed all three runs with 11 of 11 tests, as did the GB10, while the Halo passed two of three and the Dell Pro Max Micro passed one of three. The V20C’s runs took 102, 368, and 530 seconds, and its 32.2 tokens per second through Ollama on Vulkan trailed the Halo at 41.2, the GB10 at 53.9, and the RTX PRO 4000 SFF at 76.2.
The 128GB GB10 also ran the agent on qwen3.6:35b-a3b at 64K and 128K contexts and finished those tasks in a median of 90 and 70 seconds, well under its 221 seconds on gpt-oss:20b. Those tiers did not run on the V20C. With Speedometer running beside the agent, the V20C’s browser score moved from 51.8 to 50.4, a 1.03x slowdown, while the Halo’s browser score fell by 1.16x and the GB10’s by 1.54x under the same test.

RAG at Two Scales
| RAG, 20,963 passages (Ollama 0.40.3) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| Ingest, passages per second | 87.5 | 268.2 | 211.4 | 95.5 |
| Ingest, embedding rate (tokens/s) | 14,162 | 43,430 | 34,227 | 15,468 |
| Answer, generation rate (tokens/s) | 76.5 | 137.0 | 93.2 | 80.0 |
| Answer, time to first token p50 (s, lower is better) | 0.30 | 0.16 | 0.15 | 0.42 |
| Question to answer p50 (s, lower is better) | 0.39 | 0.22 | 0.22 | 0.50 |
The RAG test embeds 20,963 SQuAD passages, retrieves the top five for each question, and answers with Phi-4-mini, all through Ollama. On Vulkan, the V20C ingested 87.5 passages per second. That’s about a third of the Dell Pro Max Micro’s 268.2 and well under half of the GB10’s 211.4. Answers were generated at 76.5 tokens per second vs. 137.0 and 93.2, and the median time from question to answer was 0.39 seconds vs. 0.22 on both NVIDIA systems. The Halo landed closest to the V20C, at 95.5 passages per second on ingest, 80.0 tokens per second on answers, and 0.50 seconds from question to answer.
| RAG at scale, 1,002,067 passages | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|
| Ingest, 1M passages (passages/s) | 321.4 | 313.9 | 65.8 |
| Ingest wall time (s, lower is better) | 3,118 | 3,192 | 15,230 |
| HNSW index build (s, lower is better) | 73.4 | 78.9 | 68.9 |
| HNSW search, ef 64 (queries/s) | 29,643 | 27,359 | 34,012 |
| HNSW search, ef 256 (queries/s) | 8,285 | 7,664 | 9,649 |
| Question to answer p50 (s, lower is better) | 0.36 | 0.20 | 0.46 |
The larger RAG test embeds a million Wikipedia passages through llama.cpp, builds an HNSW index on the CPU, and searches it. With embedding on SYCL, the V20C ingested 321.4 passages per second and finished in 52 minutes, slightly ahead of the Dell Pro Max Micro at 313.9. The same embedding model processed 14,162 tokens per second through Ollama on Vulkan in the smaller test and 45,498 through llama.cpp on SYCL in this one, while the Dell’s CUDA rates in the two tests were within 3 percent of each other.
The CPU-side work favors the V20C by a small margin, with its 24 cores building the index in 73.4 seconds against 78.9 and searching it at 29,643 queries per second against 27,359 at an ef setting of 64. Recall against exact search was above 91 percent on both systems. Answer generation in this test returns to Ollama, and the median question-to-answer time was 0.36 seconds on the V20C against 0.20 on the Dell.
The Halo also completed the million-passage test, and its embedding stage was far slower, at 65.8 passages per second and 4.2 hours for the ingest. Its 16-core processor built the index in 68.9 seconds and searched it at 34,012 queries per second, ahead of the V20C in both, and its median question-to-answer time was 0.46 seconds.
Image Generation
| stable-diffusion.cpp, 1024×1024 (images/min, higher is better) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| FLUX.2 klein 4B Q4_0 (images/min) | 4.26 | 11.46 | 9.96 | 3.86 |
| FLUX.2 klein 4B BF16 (images/min) | 2.40 | 10.93 | 10.28 | 4.17 |
| Z-Image Turbo 6B Q4_0 (images/min) | 2.11 | 4.39 | 3.68 | 1.85 |
| Z-Image Turbo 6B BF16 (images/min) | 0.96 | 3.95 | 3.94 | 0.47 |
| Qwen-Image 20B Q4_0 (images/min) | 0.35 | Did not fit | 0.50 | 0.23 |
| Qwen-Image 20B Q8_0 (images/min) | Did not fit | Did not fit | 0.48 | 0.23 |
Image generation is the V20C’s weakest result: on stable-diffusion.cpp through Vulkan, it produced 4.26 images per minute on FLUX.2 klein 4B at Q4_0, against 11.46 on the RTX PRO 4000 SFF and 9.96 on the GB10 with CUDA. The GB10 also ran this test on Vulkan and produced 8.29 images per minute, so the backend explains part of the gap, and the B70 still ran at about half the GB10’s rate on the same API. The Halo produced 3.86 images per minute on ROCm, the one system the V20C led at Q4_0.
Higher precision widens the difference: at BF16 the V20C fell to 2.40 images per minute on FLUX.2 klein and 0.96 on Z-Image Turbo, while both NVIDIA systems held close to their Q4_0 rates. Memory capacity works in the V20C’s favor on Qwen-Image 20B, which needs 28GB at Q4_0: the V20C ran it at 0.35 images per minute vs. 0.50 on the GB10 and 0.23 on the Halo, and the 24GB card couldn’t load it. The Q8_0 version needs 38GB and ran only on the two unified-memory systems.

CPU Performance
7-Zip, Blender, HandBrake, and LLVM
| Test | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| 7-Zip, all threads, total (GIPS) | 199.6 | 164.0 | 149.5 | 215.8 |
| 7-Zip, one thread, total (GIPS) | 11.26 | 10.90 | 9.68 | 9.66 |
| Blender 4.5 Monster (samples/min) | 330.4 | 243.1 | No arm64 build | 285.3 |
| Blender 4.5 Junkshop (samples/min) | 212.5 | 161.6 | No arm64 build | 173.9 |
| Blender 4.5 Classroom (samples/min) | 152.8 | 114.5 | No arm64 build | 144.0 |
| HandBrake x265 (fps) | 49.6 | 39.7 | No arm64 build | 44.5 |
| HandBrake SVT-AV1 (fps) | 177.4 | 147.9 | No arm64 build | 194.1 |
| LLVM build (s, lower is better) | 136 | 173 | 175 | 149 |
The Core Ultra 7 270K Plus is a 24-core desktop processor under a 360mm liquid cooler, and it led both Dell systems in every row of this table. The V20C scored 199.6 GIPS in 7-Zip, 22 percent ahead of the Core Ultra 9 285 in the Dell Pro Max Micro and 34 percent ahead of the GB10. Blender ran 31 to 36 percent ahead of the Dell across the three scenes, and x265 and SVT-AV1 encodes were 25 and 20 percent faster. Blender and HandBrake have no arm64 Linux builds in our suite, so the GB10 has no results there.
The Halo’s 16-core Ryzen AI Max+ 395 split these tests with the V20C. It scored 215.8 GIPS in all-thread 7-Zip, 8 percent ahead, and encoded SVT-AV1 at 194.1 fps against 177.4, while the V20C led Blender by 6 to 22 percent, x265 by 11.5 percent, and the LLVM build at 136 seconds against 149.
The LLVM build finished in 136 seconds on the V20C, compared with 173 on the Dell Pro Max Micro and 175 on the GB10, which is the result most relevant to a developer workstation. Single-thread 7-Zip was closer, with the V20C 3 percent ahead of the Core Ultra 9 285 and 16 percent ahead of the GB10. Dell’s processor has the same core count, which points to the power and cooling headroom of a tower over a compact chassis as the source of the multi-thread gap.

Stockfish, primesieve, Python, and the Browser
| Test | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| Stockfish, one thread (Mnps) | 2.08 | 2.02 | 1.66 | 2.15 |
| Stockfish, all threads (Mnps) | 40.55 | 31.58 | 23.86 | 38.74 |
| primesieve to 10^12, all threads (s, lower is better) | 6.48 | 8.72 | 9.16 | 6.29 |
| primesieve to 10^11, one thread (s, lower is better) | 9.03 | 9.07 | 12.32 | 6.76 |
| PyPerformance go (ms, lower is better) | 56.0 | 57.8 | 85.5 | 69.1 |
| PyPerformance nbody (ms, lower is better) | 36.3 | 38.9 | 55.0 | 43.1 |
| Speedometer 3.1 (score) | 51.8 | Not run | 37.2 | 38.7 |
All-thread Stockfish reached 40.55 Mnps on the V20C, 28 percent ahead of the Dell Pro Max Micro and 70 percent ahead of the GB10, and primesieve to 10^12 finished in 6.48 seconds, compared with 8.72 and 9.16. One-thread results between the two Intel systems were within 3 percent in Stockfish and level in primesieve. The V20C scored 51.8 in Speedometer 3.1 against 37.2 on the GB10, and its PyPerformance go result of 56.0ms compares with 85.5ms on the Arm system. The Halo ran close behind in all-thread Stockfish at 38.74 Mnps, finished primesieve in 6.29 seconds, and scored 38.7 in Speedometer.
GROMACS and OpenBLAS
| Test | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| GROMACS benchMEM, 16 cores (ns/day) | 67.23 | 52.68 | 27.81 | 72.39 |
| GROMACS benchMEM, all cores (ns/day) | 77.77 | 55.52 | 34.61 | 70.95 |
| OpenBLAS DGEMM, all cores (GFLOPS) | 1,100.0 | 791.6 | 418.0 | 1,610.3 |
| OpenBLAS LU solve N=20000, all cores (GFLOPS) | 938.6 | 717.0 | 393.0 | 1391.3 |
| Memory latency, 4KiB pages (ns, lower is better) | 105.2 | 129.0 | 123.8 | 162.2 |
GROMACS benchMEM ran at 67.23 ns/day on 16 cores and 77.77 on all 24, which is 28 and 40 percent ahead of the Dell Pro Max Micro and more than double the GB10’s 27.81 and 34.61. OpenBLAS DGEMM reached 1,100.0 GFLOPS on all cores, up from 791.6 and 418.0, and the LU solve at N=20000 reached 938.6 GFLOPS. Memory latency on 4KiB pages measured 105.2ns on the V20C’s DDR5-6400, the lowest in the group.
The Halo led the 16-core GROMACS run at 72.39 ns/day and OpenBLAS DGEMM at 1,610.3 GFLOPS, 8 and 46 percent ahead of the V20C, and reached 1,391.3 GFLOPS in the LU solve. With every thread in use, the V20C stayed ahead in GROMACS at 77.77 ns/day against 70.95.

Server and HPC Workloads
These results come from our benchmark harness and server suite, which run on Linux only. They measure the V20C as a general compute node: compiling, compressing, serving web and cache requests, running analytics queries, and solving a CFD case. Because each system runs a different Linux distribution and compiler, the V20C and the Dell Pro Max Micro, which share Ubuntu 26.04.1, form the tightest pairing.
| Phoronix Test Suite and y-cruncher (higher is better unless noted) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| Timed Linux kernel compile, allmodconfig (s, lower is better) | 639 | 918 | 892 | 727 |
| 7-Zip compression rating, all threads (MIPS) | 186,668 | 150,543 | 154,634 | 178,530 |
| 7-Zip decompression rating, all threads (MIPS) | 128,723 | 88,641 | 106,148 | 143,464 |
| 7-Zip compression rating, one thread (MIPS) | 10,260 | 9,351 | 7,474 | 8,019 |
| OpenSSL AES-256-GCM, all threads (GB/s) | 171.4 | 110.0 | 97.1 | 298.6 |
| nginx, 1,000 connections (requests/s) | 225,708 | 155,203 | 114,909 | 223,433 |
| nginx, 4,000 connections (requests/s) | 155,146 | 109,352 | 101,613 | 190,454 |
| y-cruncher Pi, 1B digits (s, lower is better) | 17.54 | 30.10 | Not run | 10.46 |
| y-cruncher Pi, 5B digits (s, lower is better) | 111.17 | 158.24 | Not run | 63.45 |
| y-cruncher Pi, 10B digits (s, lower is better) | 244.44 | 342.87 | Not run | 135.18 |
The V20C compiled the Linux kernel in 639 seconds, compared with 918 on the Dell Pro Max Micro and 892 on the GB10, and led both in 7-Zip, OpenSSL, and nginx. The Halo is a closer match than its 16 cores suggest. It compiled the kernel in 727 seconds, tied the V20C in nginx at 1,000 connections and led by 23 percent at 4,000, and ran OpenSSL AES-256-GCM at 298.6GB/s against 171.4GB/s. In all-thread 7-Zip it trailed the V20C by 4 percent in compression and led by 11 percent in decompression, and the V20C was 28 percent faster in single-thread compression.
In y-cruncher, the Halo computed five billion digits of Pi in 63.45 seconds, compared with 111.17 on the V20C and 158.24 on the Dell Pro Max Micro, and the gap widened to 135.18 against 244.44 seconds at ten billion. The test is sensitive to memory bandwidth and vector width, and the Halo brings AVX-512 and a wider memory bus, whereas the V20C has two channels of DDR5. The GB10 has not run y-cruncher, so it has no entry in those rows.

| Server suite (higher is better unless noted) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| ClickBench hot run, 43 queries (s, lower is better) | 7.39 | 8.11 | 6.67 | 5.82 |
| ClickBench cold run, 43 queries (s, lower is better) | 10.41 | 10.80 | 11.01 | 9.30 |
| OpenFOAM drivAer, 3M cells, solve time (s, lower is better) | 1,636 | 2,320 | 1,222 | 1,148 |
| STREAM Triad (MB/s) | 68,252 | 65,802 | 121,313 | 114,007 |
| Valkey cache, SET (requests/s) | 1,852,556 | 1,389,084 | 810,246 | 1,211,538 |
| Valkey cache, GET (requests/s) | 1,866,031 | 1,398,409 | 884,644 | 1,271,481 |
Memory bandwidth explains most of the server suite results, with STREAM Triad at 68GB/s on the V20C’s two DDR5 channels against 121GB/s on the GB10 and 114GB/s on the Halo. The OpenFOAM drivAer case, a 3-million-cell solve, finished in 1,636 seconds on the V20C against 1,222 on the GB10 and 1,148 on the Halo, and the ClickBench hot run took 7.39 seconds against 6.67 and 5.82. The Dell Pro Max Micro took 42 percent longer than the V20C in OpenFOAM and 10 percent longer in ClickBench.
The V20C’s faster cores gave it an advantage in Valkey’s cache profile, handling 1.85 million SET requests and 1.87 million GET requests per second. Those rates were 33 percent higher than the Dell Pro Max Micro’s and more than double the GB10’s 810K SET and 885K GET requests per second. The Halo handled 1.21 million SET and 1.27 million GET requests per second, about two-thirds of the V20C’s rates. A workstation that also hosts a vector store, a cache, or a small database beside the model server leans on that per-core speed, and the 270K Plus leads this group on most of our per-core tests.

Graphics and GPU Encoding
| SuperTuxKart 1.5 and FFmpeg (higher is better) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| SuperTuxKart 1080p, average FPS | 345.7 | Not run | 277.1 | 274.7 |
| SuperTuxKart 1080p, steady FPS | 249 | Not run | 195 | 166 |
| SuperTuxKart 4K, average FPS | 174.0 | Not run | Not run | 90.8 |
| SuperTuxKart 4K, steady FPS | 137 | Not run | Not run | 66 |
| FFmpeg 8.1 hardware HEVC encode (fps) | 154 (Quick Sync) | 123 (NVENC) | 134 (NVENC) | 204 (VAAPI) |
SuperTuxKart with the highest preset is the suite’s one-game test, and the V20C averaged 345.7 fps at 1080p and 174.0 fps at 4K on Mesa’s OpenGL driver. The GB10 averaged 277.1 fps at 1080p, putting the Arc Pro B70 25 percent ahead; the test did not run on the Dell Pro Max Micro. The GB10 had no 4K result because its display was limited to 1080p. The Halo averaged 274.7 fps at 1080p and 90.8 fps at 4K, about half the V20C’s 4K rate.
For GPU encoding, FFmpeg 8.1 with HEVC Quick Sync ran at 154 fps on the suite’s 4K Big Buck Bunny clip, and the VAAPI path ran at 152 fps. The NVIDIA systems use NVENC with different encoder settings, so their 123 and 134 fps are shown for reference and do not rank the three encoders. The Halo’s Radeon ran FFmpeg’s VAAPI path at 204 fps. Both Intel encode paths failed to initialize on the first run and worked on the second.
Thermals Under Load
| Corsair FlexPrime V20C | CPU Max (C) | CPU Mean (C) | GPU Max (C) | GPU Mean (C) |
|---|---|---|---|---|
| 7-Zip | 91 | 67.8 | 50 | 47.5 |
| Blender | 88 | 77.7 | 50 | 49.2 |
| LLVM build | 88 | 77.8 | 48 | 48.0 |
| GROMACS | 97 | 77.5 | 48 | 48.0 |
| MLPerf Client | 69 | 41.6 | 72 | 62.7 |
| Coding agent | 66 | 43.1 | 74 | 71.5 |
| LLM serving | 68 | 46.1 | 84 | 80.1 |
| RAG at scale | 81 | 49.4 | 80 | 78.5 |
| Image generation | 89 | 43.8 | 82 | 76.5 |
| SuperTuxKart | 61 | 44.1 | 76 | 70.6 |
The liquid cooler kept the 270K Plus between 88C and 91C at peak in most all-core tests, with means in the high 70s during Blender, the LLVM build, and GROMACS. GROMACS produced the one higher reading at 97C. The CPU idled at 37C to 38C between tests and averaged 42C to 49C during GPU work such as MLPerf Client, LLM serving, and the million-passage RAG run.
The Arc Pro B70 idled near 48C and ran hottest during LLM serving, peaking at 84C and averaging 80.1C across a 26-minute test. Image generation and the large RAG ingest held it at 82C and 80C. Those sustained GPU loads are also where steady airflow matters most, which makes the irregular fan ramping described earlier worth sorting out.
Storage Performance
| fio, 25GiB footprint (higher is better) | Corsair FlexPrime V20C (Ultra 7 270K Plus, Arc Pro B70 32GB) | Dell Pro Max Micro (Ultra 9 285, RTX PRO 4000 SFF 24GB) | Dell Pro Max with GB10 (128GB unified) | AMD Ryzen AI Halo (Ryzen AI Max+ 395, 128GB unified) |
|---|---|---|---|---|
| Sequential read 128K (MB/s) | 7,311 | 9,433 | 6,947 | 7,232 |
| Sequential write 128K (MB/s) | 6,082 | 6,766 | 6,310 | 1,554* |
| Random read 4K, peak (IOPS) | 1,184,970 | 2,084,437 | 932,210 | 1,197,992 |
| Random write 4K, peak (IOPS) | 184,231 | 1,028,079* | 997,758 | 121,285* |
| Random read 4K, QD32 x 4 jobs (IOPS) | 1,184,970 | 1,386,889 | 754,896 | 1,001,941 |
| Random write 4K, QD32 x 4 jobs (IOPS) | 178,312 | 1,028,079* | 946,264 | 121,285* |
*Flagged by the suite for run-to-run variance after a rerun.
The 1TB XPG MARS 970 PLUS in our unit links at PCIe Gen5 x4 and performs like a fast Gen4 drive in sequential work. It read at 7,311MB/s and wrote at 6,082MB/s on the 25GiB footprint, close to the Gen4 drive in the GB10 at 6,947 and 6,310MB/s. The Gen5 Sandisk in the Dell Pro Max Micro read at 9,433MB/s. Peak 4K random read reached 1.18 million IOPS on the V20C, ahead of the GB10 and a little over half of the Dell’s 2.08 million. The Halo’s Micron 4600 read at 7,232MB/s and reached 1.20 million IOPS in random read, level with the V20C.
Random write is the drive’s weak point, peaking at 184K IOPS on the 25GiB footprint and 350K on the 5GiB footprint, with passes within 3 percent of each other, while the two Dell systems wrote at about 1.0 million IOPS and the Halo’s drive peaked at 121K with a variance flag. The drive also ran hot, reaching 80.8C with a 75.3C mean across the 99-minute storage test.
Corsair’s configurator lists 2TB and 4TB options for the V20 chassis, and buyers who plan to keep datasets or vector indexes on the boot drive should budget for one. The drive sits in the M.2 slot between the graphics card and the CPU block, wearing XPG’s heat spreader with no motherboard heatsink over it.

Conclusion
The Corsair FlexPrime V20C shows that the Arc Pro B70 can anchor a capable local AI workstation when the software uses the right backend. Through llama.cpp on SYCL, it out-served an RTX PRO 4000 SFF by 5 to 30 percent on the Ministral models and ran a 27B model that the 24GB card could not load, at 77 percent above the GB10 for a single user. Around that GPU, the 24-core 270K Plus led every compile, render, and cache-serving test in the comparison.

At $3,999.99 with 32GB of system memory, the V20C lists level with the AMD Ryzen AI Halo at Micro Center and about $3,500 below the $7,521 Dell.com lists for a 128GB Pro Max with GB10 and a 1TB SSD. Both of those desktops carry 128GB of unified memory, which lets the GB10 run agent and image models the V20C can’t load, and both finished our OpenFOAM case sooner. The V20C answers with faster llama.cpp serving on models that fit in 32GB, about twice the Halo’s rate on the Ministral models, and a tower built from parts that can be easily serviced or replaced.
The rough edges are in software and tuning: Ollama and stable-diffusion.cpp fell back to Vulkan and trailed both NVIDIA systems in every generation and ingest test; our fine-tuning test had no Intel path, and the fans ramped irregularly during testing. The 1TB SSD is slow in random writes and peaked at 81C. Developers who serve models through llama.cpp or OpenVINO and want a strong x86 build machine under the same lid are the buyers this configuration suits. Teams that rely on Ollama, image generation, or models beyond 32GB should look at the unified-memory desktops or one of Corsair’s NVIDIA configurations.