The storage world has a GPU problem. Not in the sense that GPUs are failing, but in the sense that the infrastructure around them can’t keep up. Maybe the GPUs have a storage problem. Most enterprise storage was designed for a different era, one where the bottleneck was almost never the network path between a flash device and a processor. That’s no longer true. Giorgio Regni, Scality’s CTO and co-founder, explained that AI workloads, specifically training and inference at scale, consume vast amounts of data to generate an enormous volume of tokens. The sheer rate at which AI models consume and produce data has exposed a fundamental mismatch between how storage works and what GPUs actually need.
It’s worth understanding why that mismatch exists. S3 has been the dominant object storage protocol for years, and it works well for many use cases. But it runs over HTTP(S), and HTTP carries overhead. Every request goes through a CPU, through a software stack, through layers that were never optimized for the kind of sustained, low-latency, high-throughput data movement that keeps a GPU cluster fed. When you’re running training jobs and your GPUs are sitting idle waiting on storage, you’re not getting value from some of the most expensive hardware in your data center. That’s the problem Scality is trying to address with its enhancements for NVIDIA NIXL.
NIXL is NVIDIA’s open library for cross-framework data transfer, designed specifically to move data efficiently in GPU-centric environments. Scality has been contributing to that project, with eight pull requests to the NIXL community as of their presentation at AI Infrastructure Field Day 5. What they’ve built on top of NIXL is the ability to do S3 over RDMA (remote direct memory access), combined with NVIDIA’s CUObject, a stripped-down, native object API. The idea is to remove the CPU and software stack entirely from the critical path, so that data moves directly between flash devices and GPU memory.
That’s a meaningful architectural shift. File and block storage have traditionally had a performance advantage in high-throughput environments because they don’t incur the overhead of HTTP-based object storage. Scality’s argument is that with RDMA and a leaner API, object storage can compete directly in those environments, without requiring applications to be rewritten to use a different storage interface. That last part matters. One of the persistent complaints about high-performance AI storage is that optimizing for it often requires rearchitecting how applications communicate with storage. If you can achieve the performance benefits while keeping the S3-compatible interface, the migration path becomes much simpler.
The way this fits into the broader ADI architecture is through storage tiering behind the S3 over RDMA access. The extreme and hot tiers, where this NIXL-based direct path applies, use TLC flash. Below that, ADI manages warm data on QLC flash and HDDs, and cold data on tape or cloud. The system moves data between tiers based on workload requirements, so the ultra-low-latency path is available when it’s needed without requiring everything to live on expensive TLC flash all the time. It’s a sensible approach to a cost problem that doesn’t have an easy answer. Flash is fast, but it’s not cheap, and AI datasets grow fast.
There’s also an open-standards dimension worth noting. Scality’s decision to contribute pull requests to NIXL rather than build a proprietary integration is deliberate. It means other storage vendors can choose to build compatible backends. It means the ecosystem around NVIDIA’s data movement tooling gets richer. And it means customers aren’t entirely dependent on Scality to maintain a private fork of something critical. Given that data sovereignty and vendor lock-in are active concerns for many enterprises right now, that’s not a trivial consideration.
The deeper point Regni was making is that object storage has historically accepted a performance ceiling that file and block didn’t have. The reason was protocol overhead, and the fix is to get closer to the hardware. RDMA is how you do that. It’s well established in high-performance computing and networking, so the technology isn’t new. What’s new is applying it to object storage in a way that preserves the operational model enterprises already have, the S3 API, the tiering policies, the lifecycle management, while removing the bottleneck that’s been limiting GPU utilization.
Whether object storage can fully close the gap with file and block in the most demanding AI workloads remains to be seen. But the direction is clear. The storage layer in an AI infrastructure stack can’t be an afterthought, and the protocols that worked fine for cloud data lakes don’t automatically work fine when you’re trying to saturate a GPU cluster. Scality’s bet is that fixing the protocol path, rather than abandoning object storage altogether, is the right approach. Given how much enterprise infrastructure is already built around S3-compatible storage, that bet is at least worth watching closely.
