StorageReview.com

Corsair FlexPrime V20C Review: A 24-Core Linux Workstation Built Around a 32GB Arc Pro B70

End User  ◇  Workstation

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.

Corsair FlexPrime V20C workstation in the StorageReview lab, a three-quarter view of the black micro-ATX tower with its perforated side panel and Corsair badge

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.

Corsair FlexPrime V20C with the side panel off and the 360mm radiator bracket lowered, showing the ASRock Intel Arc Pro B70, the Corsair pump block, four DIMMs, and the ASUS motherboard

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.

Corsair FlexPrime V20C top-front I/O strip with two USB Type-A ports, one USB Type-C port, a combo audio jack, and 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.

Rear of the Corsair FlexPrime V20C showing the Arc Pro B70's four display outputs above the motherboard I/O panel with Wi-Fi 7 antenna connectors, USB ports, 2.5GbE, DisplayPort, and HDMI

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.

Corsair FlexPrime V20C LLM serving chart for one request: 84.9 tokens/s on Ministral 3 3B, 63.7 on Ministral 3 8B, and 19.8 on Qwen3.8 27B against the Dell Pro Max Micro, Dell Pro Max with GB10, and AMD Ryzen AI Halo

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.

Corsair FlexPrime V20C LLM serving chart at four concurrent requests: 213.3 tokens/s on Ministral 3 3B, 141.8 on Ministral 3 8B, and 33.5 on Qwen3.8 27B against three comparison systems

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.

Ollama generation rate chart: Corsair FlexPrime V20C at 76.5 tokens/s in RAG answers and 32.2 in the coding agent against 137.0 and 76.2 for the Dell Pro Max Micro , 93.2 and 53.9 for the Dell Pro Max with GB10, and 80.0 and 41.2 for the AMD Ryzen AI Halo

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.

Image generation chart at 1024x1024: Corsair FlexPrime V20C at 4.26 images per minute on FLUX.2 klein 4B and 2.11 on Z-Image Turbo 6B against the Dell Pro Max Micro, Dell Pro Max with GB10, and AMD Ryzen AI Halo

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.

7-Zip 24.09 all-threads chart: Corsair FlexPrime V20C at 199.6 GIPS against 164.0 for the Dell Pro Max Micro, 149.5 for the Dell Pro Max with GB10, and 215.8 for the AMD Ryzen AI Halo Blender 4.5 CPU chart: Corsair FlexPrime V20C at 330.4 samples per minute in Monster, 212.5 in Junkshop, and 152.8 in Classroom against the Dell Pro Max Micro and AMD Ryzen AI Halo

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.

GROMACS 2025.3 benchMEM chart: Corsair FlexPrime V20C at 67.23 ns/day on 16 cores and 77.77 on all cores against the Dell Pro Max Micro, Dell Pro Max with GB10, and AMD Ryzen AI Halo

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.

Timed Linux kernel compile chart: Corsair FlexPrime V20C at 639 seconds against 918 for the Dell Pro Max Micro, 892 for the Dell Pro Max with GB10, and 727 for the AMD Ryzen AI Halo y-cruncher Pi chart: Corsair FlexPrime V20C at 111.2 seconds for 5B digits and 244.4 for 10B against the Dell Pro Max Micro and AMD Ryzen AI Halo
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.

ClickBench chart on ClickHouse 26.8: Corsair FlexPrime V20C at 7.39 seconds hot and 10.41 cold against the Dell Pro Max Micro, Dell Pro Max with GB10, and AMD Ryzen AI Halo OpenFOAM 13 drivAer chart: Corsair FlexPrime V20C solve time of 1,636 seconds against 2,320 for the Dell Pro Max Micro, 1,222 for the Dell Pro Max with GB10, and 1,148 for the AMD Ryzen AI Halo

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.

fio sequential 128K chart on a 25GiB footprint: Corsair FlexPrime V20C at 7,311MB/s read and 6,082MB/s write against the Dell Pro Max Micro, Dell Pro Max with GB10, and AMD Ryzen AI Halo fio random 4K peak chart on a 25GiB footprint: Corsair FlexPrime V20C at 1,184,970 read IOPS and 184,231 write IOPS against the Dell Pro Max Micro, Dell Pro Max with GB10, and AMD Ryzen AI Halo

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.

Corsair FlexPrime V20C with the side panel removed, showing the 360mm radiator mounted along the side of the chassis and the ASRock Intel Arc Pro B70 above it

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.

Corsair FlexPrime V20C Product Page

Engage with StorageReview

Newsletter | YouTube | Podcast iTunes/Spotify | Instagram | Twitter | TikTok | RSS Feed

Dylan Bryan