CoreWeave storage: Why HDDs now beat flash for AI

CoreWeave delivers 7 GB/s per GPU throughput, far exceeding traditional cloud object storage limits.

The strategic alliance between the provider and CoreWeave proves that HDD-based object storage is now critical for scaling AI infrastructure without bankrupting operations. By integrating cost-effective magnetic media with high-speed caching, the industry moves beyond expensive flash-only architectures. CoreWeave AI Object Storage achieves its massive throughput by using the provider capacity for less frequent access patterns. The LOTA distributed cache shields applications from the latency of spinning disks during retrieval-augmented generation and model training. This analysis quantifies the measurable ROI gained by shifting checkpointing and data preparation workloads to these new service tiers.

The recent $335 million deal announced on 06/23/2026 validates this hybrid approach, as the provider commits to supplying the raw capacity needed for CoreWeave customers. This collaboration ensures that massive datasets required for inference and model outputs remain accessible without consuming premium performance resources.

The Role of Multi-Exabyte HDD Object Storage in Modern AI Infrastructure

Defining Multi-Exabyte HDD Object Storage Capacity

Multi-exabyte capacity denotes infrastructure scaling beyond one billion gigabytes, a volume that exceeds traditional enterprise bounds. This scale necessitates HDD-based storage architectures that prioritize density and cost-efficiency over the low-latency access of flash memory. Unlike block storage, object storage manages data as discrete units with unique identifiers and descriptive tags, allowing it to scale cheaply for vast amounts of unstructured data.

The recent five-year arrangement between the provider and CoreWeave validates this architectural shift for heavy compute workloads. Valued at $335M, the deal secures backend capacity where spinning disks handle massive datasets while distributed caches serve active training batches. This separation allows organizations to store petabytes of raw video or model checkpoints economically, retrieving only hot data into high-speed tiers. the provider serves more than 100,000 customers worldwide and claims over 500,000 customers reaching end users in 175 countries.

HDD latency remains a physical constraint; random reads on spinning platters cannot match NAND flash speeds. Strict data lifecycle policies prevent performance bottlenecks during model iteration. By offloading bulk data to cost-efficient tiers, teams preserve expensive GPU cycles for computation rather than waiting on disk I/O. This approach democratizes access to vast datasets, allowing smaller entities to compete with hyperscalers who previously monopolized such scale. The multi-exabyte deal exemplifies how specialized hardware pairing enables this efficiency. Advocates for this hybrid topology emphasize balancing budget realities with the insatiable data demands of generative AI.

Optimizing RAG and AI Training with High-Throughput Storage

Retrieval-augmented generation (RAG) grounds AI responses in real-time data access rather than static model weights, demanding storage that sustains massive parallel read operations. When training loops stall waiting for data, expensive GPU cycles sit idle, inflating the effective cost per token. CoreWeave serves leading AI model developers, enterprises, and research organizations, including 9 of the top 10 AI model providers. This architecture ensures that HDD-based storage tiers can feed compute clusters without the latency penalties typical of spinning media.

Benchmark results confirm that node-local connections via the Local Object Transport Accelerator enable aggregate cluster reads reaching approximately 2 GB/s per GPU in sustained workloads. The system achieved an aggregate read throughput of approximately 24 GiB/s across a cluster. This high-throughput object storage is designed to support the massive parallelism required for training large language models, where data retrieval speeds are critical to maintaining compute efficiency.

Deploying such tiered architectures balances cost and speed effectively. Ignoring the transport layer optimization leaves significant performance headroom unused, regardless of the underlying disk count. The strategic placement of caching layers determines whether an AI pipeline scales linearly or collapses under its own data weight.

HDD Object Storage Versus Traditional Flash for AI Workloads

HDD object storage provides the economic density required for multi-petabyte AI datasets where all-flash arrays become cost-prohibitive. While flash delivers microsecond latency, spinning disks paired with intelligent caching sustain the massive sequential read throughput necessary for model training without exhausting capital budgets. The architectural trade-off involves accepting higher raw latency in exchange for vastly superior cost-per-gigabyte scalability.

The system guarantees enterprise-grade durability with 99.999999999% data reliability, a statistic that matches the rigor of financial ledgers while storing unstructured media. This durability allows organizations to retain entire historical datasets for retrieval-augmented generation pipelines rather than pruning data to fit expensive flash tiers. Operators must deploy hybrid topologies where hot data resides in cache while cold volumes settle on spinning platters. This approach democratizes access to exabyte-scale repositories for startups previously priced out of premium storage markets.

Inside the Architecture of Distributed Cache and HDD Performance Tiers

LOTA Distributed Cache Mechanics and Node-Local Data Paths

Standard network paths introduce latency that stalls GPU training loops before data transfer begins. The Local Object Transport Accelerator (LOTA) eliminates this bottleneck by establishing a node-local connection directly on the compute host. This patented proxy acts as an intelligent gateway, caching active dataset segments on the GPU node itself rather than fetching across the network for every read operation. Traditional S3-compatible stores rely on remote retrieval, forcing applications to wait for round-trip network latency. LOTA intercepts these requests locally, serving cached objects at high speeds while asynchronously prefetching subsequent blocks from the HDD-based storage tier.

The architectural consequence is a fundamental shift in how engineers approach data locality. Operators no longer need to build custom caching layers to achieve low-latency access. This design supports massive parallelism required for training large language models without the complexity of manual data orchestration. While standard object stores struggle with the "small file problem" common in AI checkpoints, the node-local architecture sustains high throughput even with fragmented data patterns.

The architecture relies on node-local connections to create data paths that differ significantly from the network-based retrieval paths used by traditional S3-compatible stores. By eliminating the need for engineers to build custom caching solutions, the system simplifies access patterns for diverse workloads. The solution addresses storage needs for various stages of the AI lifecycle, including Training, Inference, Checkpointing, Data preparation, Model outputs, and more.

Sustaining 2 GB/s Throughput During AI Model Checkpointing and RAG

While initial cache population yields approximately 1.2 GiB/s per node, the system sustains over 2 GB/s per node at full capacity, with a theoretical maximum of 7 GB/s per GPU. This transition prevents GPU starvation during critical phases like AI model checkpointing where write consistency matters more than raw burst speed. The architecture supports the full AI lifecycle including training, inference, and retrieval-augmented generation by maintaining steady data flow rather than spiking briefly.

Operators must distinguish between initial population speeds and steady-state capacity when sizing clusters for production workloads.

Engineers verify zero-code migration by confirming LOTA cache presence on existing GPU nodes. Customers currently using CoreWeave AI Object Storage with its patented LOTA distributed cache will gain immediate access to new service tiers without requiring any code modifications. This architectural continuity eliminates application refactoring costs during backend transitions.

The term multi-exabyte defines a scale storing multiple exabytes, where one exabyte equals about a billion gigabytes. Operators must distinguish this massive capacity from standard cloud buckets that often impose soft limits or performance cliffs. The reliance on high-speed interconnects ensures developers get high-throughput GPU performance without being constrained by geography. Scaling storage capacity often degrades latency unless the cache layer absorbs the shock. HDD tiers provide the density, but the distributed cache provides the speed. The limitation of spinning media remains its random access latency, which the cache must hide effectively. Without proper cache warming, initial reads may stall training jobs despite the massive underlying capacity. Ensure your durability metrics align with the 11 nines standard before committing critical model weights to the tier.

Measurable ROI from Cost-Efficient Storage in Large-Scale AI Deployments

Defining Measurable ROI in HDD-Based AI Storage Economics

Every AI workflow rests on storage, yet raw IOPS no longer dictate financial success. Measurable ROI in this domain shifts focus to cost-per-gigabyte scalability across multi-exabyte datasets. Financial returns now depend on separating active hot data from vast cold archives, allowing organizations to preserve premium flash for latency-sensitive tasks while offloading bulk training sets to spinning disk. This stratification reduces total cost of ownership without sacrificing aggregate throughput, provided the architecture includes intelligent caching layers. Capital expenditure on hardware often clashes with operational complexity, yet managed services can abstract these difficulties while maintaining enterprise-grade durability with "11 nines" reliability. Operators must evaluate storage partners not on list prices, but on their ability to integrate smoothly with existing distributed cache systems like LOTA. Success requires balancing the lower unit cost of HDDs against the performance requirements of specific AI stages like checkpointing or RAG. Customers migrating to this new storage tier have reported cost reductions exceeding a significant majority, driven by the removal of data replication overhead and the elimination of cross-cloud transfer charges.

Applying High-Throughput HDD Tiers to AI Checkpointing and RAG Workloads

Spinning disks become viable for AI workloads only when distributed caching masks their inherent latency. Operators deploying retrieval-augmented generation systems often hesitate to use cost-optimized tiers due to fears of GPU starvation during vector lookups. Architectural patterns using node-local proxies allow these environments to sustain high concurrency without premium flash costs. The mechanism relies on prefetching data segments to local NVMe before the GPU requests them, effectively decoupling storage media speed from compute consumption rates. This economic advantage enables organizations to retain massive context windows in RAG workflows that would otherwise be cost-prohibitive. The architecture uses a patented technology called Local Object Transport Accelerator (LOTA), which creates node-local connections to cache data directly on GPU nodes, differing notably from the network-based retrieval paths used by traditional S3-compatible stores.

System performance remains reliable under load. The system sustains over 2 GB/s per node at full capacity, with a theoretical maximum of 7 GB/s per GPU, ensuring that latency does not overwhelm the compute layer. Such throughput supports scales of hundreds of thousands of GPUs simultaneously, addressing the massive parallelism required for training large language models. Two distinct advantages emerge from this configuration: reduced capital outlay for flash memory and sustained data feeding rates for training clusters.

Navigating Pricing Increases and Supply Chain Risks in Long-Term Storage Contracts

A scheduled pay-as-you-go storage pricing increase on May 1, 2026, introduces measurable variance into five-year total cost of ownership models. Operators must reconcile this fixed escalation against volatile hardware markets where supply chain disruption remains a persistent threat to capacity planning. The economic value of the initial agreement relies on stable volume commitments that market competition could erode if alternative providers undercut rates before the term expires. Securing low baseline rates creates a conflict with the need to maintain flexibility should component shortages delay rack deployments. The transparent pricing framework is marketed as a direct response to the complexity and lock-in barriers present in traditional cloud storage billing, aiming to provide straightforward cost predictability for AI enterprises. Teams should model scenarios where inactive data costs rise unexpectedly, forcing a re-evaluation of retention policies mid-contract. Actual results may differ due to factors such as market competition, supply chain disruption, and the ability to scale the business. Planning horizons extending to 2026 require strict adherence to these variable cost structures. Four potential risk vectors demand attention: hardware availability, bandwidth fluctuations, regulatory shifts, and competitor pricing strategies.

Implementing Optimized Data Placement Strategies for RAG and AI Training

Implementation: LOTA Distributed Cache Mechanics and Node-Local Data Paths

Local Object Transport Accelerator (LOTA) bypasses traditional network stacks by establishing direct node-local connections that cache data physically on GPU hosts. Standard S3-compatible retrieval paths used by generic cloud providers introduce latency penalties that this architecture avoids entirely. An intelligent proxy creates these node-local connections, a sharp departure from the network-based retrieval paths defining traditional object storage.

The mechanism relies on an intelligent proxy that acts as a local gateway, accelerating reads by serving data from the host rather than traversing the fabric. Unlike standard configurations where data travels over the network for every read operation, this approach sustains higher concurrency by decoupling storage media speed from compute consumption. The architecture supports scales of hundreds of thousands of GPUs simultaneously, addressing the massive parallelism required for instruction large language models.

Failure domain analysis changes fundamentally because engineers no longer need to build custom caching solutions or replicate data across geographic zones for low-latency access. Customers already using CoreWeave AI Object Storage with its LOTA distributed cache gain immediate access to new service tiers without any code modifications. HDD backends feed AI workloads with flash-like responsiveness in this storage topology, provided the local cache remains warm.

Deploying CoreWeave AI Object Storage Tiers Without Code Modifications

Existing CoreWeave users access new HDD-based storage tiers immediately without modifying application code or rebuilding pipelines. The integration uses the LOTA distributed cache to abstract physical media differences from the compute layer, while the agreement uses the provider technology to support these HDD-based storage tiers within CoreWeave AI Object Storage.

1. Use the existing LOTA integration to abstract physical media differences from the compute layer.
2. Apply lifecycle rules to move inactive RAG datasets from performance tiers to cost-optimized HDD-based storage.
3. Monitor aggregate read throughput to confirm the system sustains high concurrency during cache warm-up phases.

Organizations scale storage for AI workloads using a usage-based model that targets cost reduction for inactive data. Operators achieve significant savings by offloading bulk archives while maintaining low-latency access for active training epochs. The pricing structure explicitly eliminates egress fees, ingress fees, and request fees, removing hidden costs often associated with moving large AI datasets. Removing egress costs encourages a "single dataset" approach where data does not need replication across different geographic zones. Hundreds of thousands of GPUs run simultaneously on the underlying infrastructure, addressing the massive parallelism required for modern large language models.

Validating Throughput Benchmarks for AI Training and Inference Phases

Benchmark validation begins by measuring aggregate read throughput against the 1.2 GiB/s per node baseline before cache saturation occurs. Operators must verify that the system sustains over 2 GB/s per node once the distributed cache reaches full capacity across the cluster, with a theoretical maximum of 7 GB/s per GPU. Initial cold starts differ notably from steady-state training loops where data locality drives performance.

1. Deploy the LOTA proxy agent on each compute node to intercept object storage requests.
2. Use the automated caching mechanism to populate local caches as data is requested.
3. Monitor aggregate read throughput to confirm the system sustains high concurrency during cache warm-up phases.

Infrastructure meets rigorous AI lifecycle demands without custom code modifications when operators follow a specific checklist. Private interconnects and direct cloud peering with ports capable of handling 400 Gbps ensure data integrity across global workloads.