Nvidia has formally opened the cuFile APIs and the vertical storage stack beneath them, moving the interface that lets GPUs read and write storage directly into a cross-vendor GitHub organization called xio-sig with Google, Intel, and Meta as inaugural maintainers. At the same time, the company launched Storage-Next, an industry program that now counts more than 40 flash and storage vendors — including DDN, KIOXIA, and Micron — and introduced SCADA, a framework that moves the storage control path onto the GPU so massively parallel accelerators can issue their own small random reads without CPU mediation. The announcements, made at the Future of Memory and Storage (FMS) conference in Santa Clara on August 4, 2026, frame storage as the next frontier for AI infrastructure and argue that the next leap in model serving will depend as much on how quickly flash can feed a GPU as on the silicon doing the compute.
The core problem is not bandwidth but request size. Enterprise SSD controllers have been tuned for nearly a decade around 4 KB random reads to match virtualization and database workloads. AI inference, by contrast, fetches embeddings and KV-cache blocks in a few hundred bytes — often 512 bytes or less. Serving those tiny requests from 4 KB-tuned drives imposes roughly eightfold read amplification, and at tens of terabytes of small objects that amplification decides whether flash can function as a memory tier at all. Nvidia's answer is a two-layer approach: cuFile handles bulk DMA transfers between drive and GPU memory, while SCADA lets the GPU construct and complete its own storage requests, absorbing per-operation latency the same way it hides memory latency by keeping hundreds of thousands of operations in flight.
What's New / Specs
- cuFile open-sourced: The API set and its vertical storage stack moved to the new xio-sig GitHub organization. Components include cuFile, cuFileConformance, libxFile, and xioLinux. Google, Intel, Meta, and Nvidia are named as founding maintainers.
- Storage-Next initiative: Over 40 storage and flash vendors participating, including DDN, KIOXIA, Micron, Dell, HPE, IBM, VAST Data, and WEKA. Goal: align on GPU-driven storage behavior and produce interoperable, open standards.
- SCADA framework: Scaled Accelerated Data Access moves the control path to the GPU, enabling massively parallel GPUs to pull only the data they need directly from storage into high-speed memory. Complements cuFile: cuFile for bulk transfers, SCADA for high volumes of small random reads.
- Hardware targets: Kioxia XL-Flash drives built for 512-byte access are in development under Storage-Next. Nvidia's roadmap calls for Gen7 SSDs sustaining 100 million IOPS each — a controller-vendor design target, not a shipping product.
- Partner systems: DDN integrating SCADA with its Infinia platform; partner systems from DDN, Dell, HPE, IBM, VAST Data, and WEKA due in the second half of 2026.
- Vera BlueField-4 STX: Nvidia cites up to 3.21x higher throughput than an x86 CPU in a two-stage compression and encryption pipeline using the Vera CPU (part of Vera BlueField-4 STX). This is a vendor benchmark.
- CMX Context Memory Storage: An AI-native context tier for long-context, multi-turn, agentic inference, built on the STX platform and the DOCA security stack.
cuFile itself is not new — it debuted in 2019 as the interface component of GPUDirect Storage and has shipped since 2021. Its role has been to take the CPU out of the data path: bytes move by DMA straight between drive and GPU memory with no bounce buffer in host RAM. What remained on the CPU was the control path; host software still decided what to fetch and issued every request, with the GPU as the DMA target rather than the initiator. That split is invisible at large transfer sizes. A one-megabyte read essentially amortizes the per-request cost. At 512 bytes, the ratio inverts, the fixed cost dominates, and the CPU saturates long before the drives do. SCADA is the piece that moves the control path onto the GPU, letting it construct and complete its own storage requests.
The KV cache — essentially the attention state for every token already processed — grows with context length, and agentic deployments run thousands of concurrent conversations. It quickly outgrows GPU memory, and recomputing evicted entries costs more GPU time than reading them back. The standard design spills from GPU memory to system memory and flash, and refills through high volumes of small random reads. Serving that from flash rather than DRAM increases the context length and the concurrent user count each GPU can support, which in turn affects the per-user cost of serving a model. This also explains why Nvidia is focusing on 512-byte IOPS rather than raw bandwidth, since inference performance depends heavily on the former.
Why It Matters
Opening cuFile is a strategic departure; this layer has historically lived inside CUDA, and the logic is not charity. A GPU-initiated storage interface only pays off if drive, controller, and array vendors build to it, and vendors do not build to a proprietary interface owned by the company whose GPUs they are feeding. Publishing the interface, open-sourcing the implementation, and convening 40-plus vendors to standardize the underlying hardware behavior is how Nvidia aims to make GPU-initiated storage the industry default. It also stands to benefit the most from that outcome, since it sells most of the GPUs in question.
Intel's participation as a maintainer is significant; a leading supplier of the x86 silicon currently sitting in storage controllers has signed on to maintain software designed to remove that silicon from the I/O path. Google and Meta co-maintaining a layer that standardizes how accelerators reach storage, while building their own accelerators, points in the same direction. The ecosystem alignment suggests the industry recognizes the bottleneck: as AI agents consume massive datasets and context windows burst past system memory, storage must continuously encrypt, compress, verify, and reconstruct data at microsecond latencies. The old economics of deciding when data belongs in memory versus on a drive — first framed 40 years ago in minutes — now plays out in microseconds on GPUs paired with AI storage solutions.
For enterprises, the practical impact is a shift from passive capacity planning to active data-path design. Partner systems arriving in H2 2026 will integrate SCADA with platforms like DDN's Infinia, and the Storage-Next conformance program aims to reduce the risk that each file system, platform, and accelerator requires its own incompatible data path. However, the GitHub project is still at an early stage; announced components are not yet fully populated with code, and Gen7 SSDs targeting 100 million IOPS remain a design target rather than a product anyone can buy today.
Our Take
Nvidia's push is a coherent, well-argued attack on a real bottleneck, backed by unusually credible partners. The company is not claiming SSDs will replace HBM — latency and bandwidth gaps remain orders of magnitude — but it is arguing that flash can become a viable memory tier for the data that does not need to stay in scarce accelerator memory. If Intel, Meta, Google, storage manufacturers, and Nvidia actually converge on compatible interfaces, the resulting infrastructure layer could matter more than any single GPU generation. The caveats are real: the open-source stack is early, the 100 M IOPS target is aspirational, and the Vera throughput claim is a vendor benchmark. But the direction is clear — storage is moving from archive to active participant in the AI data path, and the economics of inference serving will increasingly hinge on 512-byte IOPS.
FAQ
What is cuFile and how does it differ from GPUDirect Storage?
cuFile is the API layer of GPUDirect Storage that enables direct DMA transfers between compatible storage and GPU memory without a CPU bounce buffer. It has shipped since 2021 inside CUDA; the news is that Nvidia has now open-sourced the APIs and the vertical storage stack beneath them under the xio-sig GitHub organization with Google, Intel, and Meta as maintainers.
What is SCADA and why does it matter for AI inference?
SCADA (Scaled Accelerated Data Access) moves the storage control path onto the GPU, letting massively parallel GPUs construct and complete their own small random read requests. This is critical for inference because KV-cache blocks and embeddings are fetched in a few hundred bytes — far smaller than the 4 KB requests enterprise SSD controllers are tuned for — and CPU-mediated requests saturate the host before the drives do.
Does this mean my consumer SSD can act like VRAM on a GeForce card?
No. The technology targets AI and HPC workloads on data-center GPUs with GPUDirect Storage–compatible storage systems. Nvidia has not announced a consumer feature that converts an SSD into additional VRAM, and NAND flash remains far behind HBM in latency and bandwidth. The benefit is a more efficient memory tier for data that does not need to stay in GPU memory, not a replacement for it.
When will partner systems with SCADA integration be available?
Partner systems from DDN, Dell, HPE, IBM, VAST Data, and WEKA are due in the second half of 2026. Kioxia XL-Flash drives built for 512-byte access are in development under Storage-Next. Gen7 SSDs targeting 100 million IOPS each remain a controller-vendor design target, not a shipping product.
Why are Google, Intel, and Meta co-maintaining cuFile if they build their own accelerators?
Standardizing how accelerators reach storage benefits the whole ecosystem by reducing the risk of incompatible data paths. Google and Meta operate massive AI factories and want interoperable storage interfaces; Intel supplies x86 silicon used in storage controllers today and is signaling support for a path that removes that silicon from the I/O critical path.
