CoreWeave is a pure-play NVIDIA GPU cloud whose differentiation lives at three layers: the compute fabric (0), infrastructure orchestration (2A), and application runtime (2B). Unusually for a cloud in this assessment, it's built deliberately on open substrate. Its orchestration opinions rest on Kubernetes (CKS) and Slurm (SUNK), not a proprietary managed scheduler, and SUNK Anywhere runs the same workflows on non-CoreWeave and on-prem clusters with few configuration changes. That makes CoreWeave's orchestration the rare cloud cell where the opinions lift out: a CoreWeave-operated service behind open standards, Delegated, where the hyperscalers' managed schedulers read Ceded.
The capture mechanism is decoupled and invisible. The substrate the buyer sees (Kubernetes, Slurm, an S3-compatible object store with no egress fees, open-weight models behind the OpenAI-compatible API) is genuinely open and portable, which is reassuring at purchase. The value that actually accumulates sits in two captive places the buyer underprices: the network fabric and rack-scale systems, wholly NVIDIA, and CoreWeave Forge, the development layer above the runtime that carries the former Weights & Biases products. Experiment history, registry lineage, evaluations, and the improvement loop accumulate there, and they don't move when the substrate does.
The data layers are where CoreWeave's openness gets its sharpest test, and the reading is substrate-agnostic: the customer contracts with CoreWeave for a CoreWeave service backed by a CoreWeave SLA, so whatever storage platform sits underneath (VAST, WEKA, DDN, and others all appear in the dedicated tier) is an implementation detail and irrelevant to authority, the same way a hyperscaler's object store is not scored on its drive supplier. What matters is the interface and the lift-to-leave. CoreWeave's default data services (AI Object Storage (CAIOS) via an S3-compatible API, and Distributed File Storage via POSIX) sit behind open, portable interfaces: a customer can re-point and leave, so authority is Delegated (a CoreWeave-managed service behind an open interface: the customer could switch without rebuilding; Retained is reserved for an open substrate the enterprise operates itself). The governance surface (catalog, lineage, advanced data services) exists only on the optional Dedicated tier, which CoreWeave's own docs steer most workloads away from; those governed artifacts are a closed proprietary platform with no open exit and are Ceded. So Layer 1A reads strong: the Dedicated tier is Dedicated VAST Storage, and VAST Catalog carries the enterprise's tags as queryable fields. It's optional, a price rather than a gate, and the only captive piece, while the default experience stays open. Context/retrieval (1B) and pipelines (1C) have no CoreWeave product at all and remain the enterprise's to provide.
The buyer's trade: CoreWeave offers the latest NVIDIA silicon, best-in-class GPU-cluster orchestration on open standards, open serving behind a standard interface, and a credible development loop in Forge, with a far more favorable orchestration-layer authority profile than any hyperscaler. It also sells one vertical business application, Monolith, for engineering test and calibration, to a buyer who isn't building generative AI at all. In exchange it cedes total dependence on NVIDIA at the fabric (supplier, strategic partner, and equity holder after the January 2026 $2B investment) and accumulates captive value in Forge, read at 2B. The instrument's reading: open where it is cheap to be open, captive where the value compounds.
Layer-by-layer status: Layer 0A (The Freshest NVIDIA Fleet, Rented by the Bare-Metal Node), Layer 0B (Quantum-X800 InfiniBand, NVIDIA's Fabric on CoreWeave's Topology), Layer 0C (AI Object Storage With LOTA Caching Feeds the GPUs), Layer 1A (Dedicated VAST Storage With VAST Catalog; Bucket Security Policies on the Default Tier), Layer 1B (Enterprise-provided), Layer 1C (Fast Transport, No Pipeline Layer), Layer 2A (Open-Substrate GPU Orchestration), Layer 2B (Strong: Open Serving and an OpenAI-Compatible Catalog; Capture Sits in Forge), Layer 2C (Gap: Improvement Loop, Not a Reasoning Plane), Layer 3 (+1) (Monolith's Engineering-Test Modules; Forge Read at 2B).
Assessment framework: 4+1 Layer AI Infrastructure Model. Scoring model: Decision Authority Placement Model (DAPM) — Retained, Delegated, or Ceded. Published by The CTO Advisor LLC (DBA The Advisor Bench). Author: Keith Townsend. Date assessed: October 27, 2026. Version: v1.32 - 4+1 v3: Layer 0 Sub-Layers.
CoreWeave is a pure-play NVIDIA GPU cloud whose differentiation lives at three layers: the compute fabric (0), infrastructure orchestration (2A), and application runtime (2B). Unusually for a cloud in this assessment, it's built deliberately on open substrate. Its orchestration opinions rest on Kubernetes (CKS) and Slurm (SUNK), not a proprietary managed scheduler, and SUNK Anywhere runs the same workflows on non-CoreWeave and on-prem clusters with few configuration changes. That makes CoreWeave's orchestration the rare cloud cell where the opinions lift out: a CoreWeave-operated service behind open standards, Delegated, where the hyperscalers' managed schedulers read Ceded.
The capture mechanism is decoupled and invisible. The substrate the buyer sees (Kubernetes, Slurm, an S3-compatible object store with no egress fees, open-weight models behind the OpenAI-compatible API) is genuinely open and portable, which is reassuring at purchase. The value that actually accumulates sits in two captive places the buyer underprices: the network fabric and rack-scale systems, wholly NVIDIA, and CoreWeave Forge, the development layer above the runtime that carries the former Weights & Biases products. Experiment history, registry lineage, evaluations, and the improvement loop accumulate there, and they don't move when the substrate does.
The data layers are where CoreWeave's openness gets its sharpest test, and the reading is substrate-agnostic: the customer contracts with CoreWeave for a CoreWeave service backed by a CoreWeave SLA, so whatever storage platform sits underneath (VAST, WEKA, DDN, and others all appear in the dedicated tier) is an implementation detail and irrelevant to authority, the same way a hyperscaler's object store is not scored on its drive supplier. What matters is the interface and the lift-to-leave. CoreWeave's default data services (AI Object Storage (CAIOS) via an S3-compatible API, and Distributed File Storage via POSIX) sit behind open, portable interfaces: a customer can re-point and leave, so authority is Delegated (a CoreWeave-managed service behind an open interface: the customer could switch without rebuilding; Retained is reserved for an open substrate the enterprise operates itself). The governance surface (catalog, lineage, advanced data services) exists only on the optional Dedicated tier, which CoreWeave's own docs steer most workloads away from; those governed artifacts are a closed proprietary platform with no open exit and are Ceded. So Layer 1A reads strong: the Dedicated tier is Dedicated VAST Storage, and VAST Catalog carries the enterprise's tags as queryable fields. It's optional, a price rather than a gate, and the only captive piece, while the default experience stays open. Context/retrieval (1B) and pipelines (1C) have no CoreWeave product at all and remain the enterprise's to provide.
The buyer's trade: CoreWeave offers the latest NVIDIA silicon, best-in-class GPU-cluster orchestration on open standards, open serving behind a standard interface, and a credible development loop in Forge, with a far more favorable orchestration-layer authority profile than any hyperscaler. It also sells one vertical business application, Monolith, for engineering test and calibration, to a buyer who isn't building generative AI at all. In exchange it cedes total dependence on NVIDIA at the fabric (supplier, strategic partner, and equity holder after the January 2026 $2B investment) and accumulates captive value in Forge, read at 2B. The instrument's reading: open where it is cheap to be open, captive where the value compounds.
CPUs, accelerators, servers, integrated systems, OS and hypervisor, physical plant
Single-GPU through 8× NVLink systems; HGX B300 with 2.1 TB HBM3e. Standard NVIDIA nodes: a CUDA or PyTorch workload moves to another cloud's NVIDIA instances or an OEM server without a rebuild. Retained under the Layer 0 runtime rule, read from the customer's seat; the CUDA dependency is NVIDIA's and sits in the NVIDIA column. Renting the capacity doesn't place it. Multi-node InfiniBand clusters are read on the network fabric chip.
GB200 and GB300 NVL72 instances, deployed as "full racks of 18 Nodes". Ceded on the integrated-system rule, the Lenovo NVL-class reading: a rack-scale system built around a captive NVLink fabric can't be lifted as deployed. Vera Rubin (verarubin-4x-e, "in limited availability for select customers") isn't scored here: limited availability without GA wording is a selection program under the GA evidence table.
CPU-only bare-metal nodes in named availability zones, from General Purpose AMD Genoa to High Core AMD Genoa 9654 and Intel Emerald Rapids 8562Y+, per CoreWeave's CPU instance docs. Commodity x86: a workload moves to another cloud's or an OEM's servers without a rebuild.
HGX B300, GB200, GB300 and Vera Rubin NVL72 rack-scale, Hopper and Ada. CoreWeave has no own-silicon hedge. The CUDA dependency is read on NVIDIA's row.
CoreWeave rents bare-metal NVIDIA nodes from a single GPU through eight-way HGX B300 with 2.1 TB of HBM3e, plus GB200, GB300 and Vera Rubin NVL72 rack-scale systems and CPU nodes, across 40+ data centers. The buyer gets current-generation accelerated compute without a procurement cycle. The architect's concern is that the dependence is total. NVIDIA is supplier, Elite Cloud Partner and, after the January 2026 $2B investment, a significant equity holder. There's no alternative-accelerator path like Trainium or TPU. A CUDA or PyTorch workload on HGX nodes still leaves for another NVIDIA cloud; the GB200 and GB300 racks can't be lifted as deployed. Calibration: AWS, Azure and Nebius read strong on the same rented shape; Dell and HPE strong on hardware the enterprise owns.
Rented, so the runtime call is CoreWeave's. CoreWeave decides which bare-metal node a workload gets, the generation it stocks and node maintenance; the enterprise picks a node type: vendor decides, visible, not overridable, Ceded. Portability: the HGX nodes read Retained, and the GB200 and GB300 racks read Ceded on the integrated-system rule.
Scored with gating (October 23, 2026): Vera Rubin NVL72, documented as the verarubin-4x-e instance and described by CoreWeave on September 30, 2026 as limited availability for select customers. Vera Rubin NVL72 comes out of the rack-scale chip under the GA evidence table (October 24, 2026): limited availability for select customers.
Interconnects, switching and routing, network virtualization
NVIDIA Quantum-X800 InfiniBand, ConnectX, BlueField DPUs; multi-cloud backbone with private interconnects, direct cloud peering, 400 Gbps-capable ports. No commodity-substrate equivalent.
The captive NVLink fabric inside the rack-scale systems. Ceded with the system on the integrated-system rule.
VPCs set the network isolation boundary and addressing for CKS clusters, managed in the console, a REST and gRPC API, and Terraform. Direct Connect links VPCs to on-premises or hyperscaler networks.
Quantum-X800 InfiniBand, ConnectX NICs and BlueField DPUs: the entire fabric is NVIDIA silicon.
The racks' NVLink domain is NVIDIA's, captive inside the integrated system.
CoreWeave builds its clusters on NVIDIA Quantum-X800 InfiniBand with ConnectX adapters and BlueField data processing units (DPUs). Behind them runs a multi-cloud backbone with private interconnects, direct cloud peering and 400 Gbps-capable ports. VPCs set the isolation boundary and addressing for CoreWeave Kubernetes Service (CKS) clusters, and Direct Connect links them to on-premises or hyperscaler networks. The buyer gets an NVIDIA reference fabric already built. The architect's concern is that the whole fabric is NVIDIA silicon on CoreWeave's topology, with no commodity-substrate equivalent. The GB200 and GB300 racks add a captive NVLink domain. Calibration: Nebius reads strong on the same InfiniBand shape; AWS's EFA and GCP's RoCE GPU network strong on fabrics the cloud designed.
Ceded where the grade rests. The InfiniBand fabric, ConnectX adapters and BlueField DPUs make the routing, congestion and isolation calls on CoreWeave's topology: vendor decides, visible, not overridable, Ceded. Portability: the fabric, the NVLink domain and CoreWeave VPC are single-vendor surfaces, Ceded.
Arrays, storage servers and software, front-end protocols: where the data sits
CoreWeave's own S3-compatible object service; LOTA caches on GPU/CPU nodes for up to 7 GB/s per GPU, cross-region/cross-cloud reach, no egress/request fees, >75% lower cost; versioning, lifecycle, read-after-write consistency, security policies. The S3 API is its own chip. The service, LOTA caching, lifecycle and policies, is CoreWeave's and doesn't lift to another S3 store: Ceded.
POSIX-compliant shared filesystem for multi-node training synchronization; snapshots, async deletion. Performance, not governance. Reached through Kubernetes persistent volume claims, and only "from within the cluster where it's deployed," per CoreWeave's documentation, which names no client protocol. No door: the service is CoreWeave's, Ceded.
Node-local NVMe scratch on GPU and CPU nodes: most GPU nodes use an 8-drive RAID10, smaller nodes RAID1. Encrypted with a key held only in memory, so data doesn't survive a reboot.
A capacity-reserved product CoreWeave provisions: single-tenant VAST clusters co-located with the customer's GPUs, multi-protocol access, VAST CSI drivers for Kubernetes, and customer-configurable snapshot policies. The protocols are their own chip; VAST's engine and CoreWeave's operation of it don't lift: Ceded.
The S3 API, which independent object stores implement. Workloads confined to the supported common S3 operations move by changing endpoints, credentials and provider-specific configuration; the data, policies and unsupported service features migrate or adapt. Delegated. The service and LOTA are the CAIOS chip, Ceded.
NFS and S3 on the single-tenant VAST clusters, which independent implementations share: hosts and applications re-point to another server or target speaking the same protocols, and the data and provider-specific policies migrate with it. Delegated. VAST's engine stays in the Dedicated VAST Storage chip, Ceded.
Assessment pending
CoreWeave AI Object Storage (CAIOS) is CoreWeave's own S3-compatible service, with LOTA caching data on GPU and CPU nodes, no egress or request fees, versioning and lifecycle. CoreWeave's public benchmark puts it at 368 GiB/s across 20 H200 nodes, 2.3 GiB/s per GPU. Distributed File Storage gives multi-node training a POSIX shared filesystem, node-local NVMe gives scratch, and Dedicated VAST Storage puts single-tenant VAST clusters beside the customer's GPUs. The buyer gets storage built to keep GPUs fed. The architect's concern is that the handle is CoreWeave's. CAIOS decides placement and replication, and LOTA decides what to cache. Calibration: AWS and Azure read strong on managed Lustre with a per-file layout handle; WEKA and VAST strong on the same function sold as software or appliances.
Ceded where the grade rests. CAIOS's engine decides placement and replication and LOTA decides what to cache, while lifecycle and versioning are configuration, not overrides: vendor decides, visible, not overridable, Ceded. Portability: the S3, POSIX and NFS doors on CAIOS, Distributed File Storage and Dedicated VAST are multi-vendor standards, Delegated; local NVMe goes with the node, Retained.
Confidence flag: the product page's 'up to 7 GB/s per GPU' has no published method and isn't relied on.
The data itself, organized and governed: the Governance Catalog that Layer 2C queries
Single-tenant Dedicated VAST Storage comes with "advanced data services such as VAST Catalog, DataBase, DataEngine, and cross-cluster replication," and CoreWeave documents "Direct VMS access for user management, QoS policies, quotas, snapshots, SSO, and audit logging." CoreWeave-delivered and capacity-reserved; the governance surface is VAST's: Ceded. Defaulted-away-from for most workloads.
CoreWeave's own S3-compatible object service; LOTA caches on GPU/CPU nodes for up to 7 GB/s per GPU, cross-region/cross-cloud reach, no egress/request fees, >75% lower cost; versioning, lifecycle, read-after-write consistency, security policies. Open S3 interface: the customer can leave by re-pointing workloads. The storage backend is CoreWeave's implementation detail, not part of the authority call. A managed CoreWeave service behind the multi-vendor S3 standard: object opinions lift to any S3 platform, so Delegated, not Retained (Retained is reserved for an open substrate the enterprise operates).
Assessment pending
CoreWeave’s 1A functions are the security policies on CoreWeave AI Object Storage, which decide who may use which buckets, and the data services of the Dedicated tier. That tier is Dedicated VAST Storage, a single-tenant VAST cluster in the same data center as the GPUs, sold and provisioned by CoreWeave. It carries VAST Catalog, DataBase, DataEngine, Global Access and SyncEngine. The Catalog indexes the S3 tags and user-metadata keys the enterprise selects as their own columns, so a reasoning plane can ask what the data is. The object store itself holds the bytes at 0C. The architect’s concern is that the governed path is the exception: CoreWeave’s docs name the default tiers as the starting point for most AI workloads, and Dedicated VAST isn’t self-serve. A tier on the same paper is a price, not a gate. Strong. Calibration: Cisco and Supermicro read strong on the same Catalog on their paper; WEKA and Dell read moderate on metadata-only indexes.
The Catalog’s classification is the tags the enterprise applies, and it executes what was configured without inference: code decides, visible, overridable, Retained. Portability: the Dedicated tier’s VAST services are captive to VAST through CoreWeave’s paper, Ceded; CAIOS sits behind the S3 standard, Delegated.
Open: whether the tenant configures the Catalog’s indexed tag keys itself or through CoreWeave.
Low-latency retrieval for RAG — vector/hybrid search, context windows
Assessment pending
No native vector database, hybrid search, or managed RAG context service. W&B Weave, now part of CoreWeave Forge, provides tracing and evaluation for agent and LLM behavior, not retrieval. Tensorizer accelerates model loading, not context assembly. The enterprise brings its own retrieval stack (pgvector, Milvus, Weaviate, etc.) and runs it on CoreWeave compute. The same boundary that governs 1A governs here: a capability counts only if CoreWeave exposes it as a service you buy and they SLA. The underlying storage platform on the dedicated tier may have similarity/indexing services, but CoreWeave does not surface a retrieval product, so there is nothing for the customer to consume as a CoreWeave 1B capability. An underlay capability that is not exposed to the customer is not a CoreWeave capability. It is a gap. Calibrates with NVIDIA's 1B gap: CoreWeave accelerates retrieval workloads at Layer 0/2B but does not provide the retrieval capability itself. Function remains the enterprise's: gap, authority Absent.
None to borrow. The retrieval stack is whatever the enterprise brings and runs on CoreWeave compute. The reading is Absent: nothing offered, nothing inherited.
Boundary rule: scored on what CoreWeave exposes and SLAs, not on what the storage substrate can technically do. CoreWeave sells storage tiers, not a retrieval product, so this is a gap regardless of substrate.
Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering
Assessment pending
LOTA moves bytes fast and across clouds, and AI Object Storage gives a single dataset global reach without replication. But fast data transport is not a data pipeline. There is no ETL/ELT, no transformation framework, no lineage tracking, and no cost-aware movement orchestration product. The enterprise composes this from open tooling (Airflow, Ray Data, dlt, Spark) on CoreWeave compute. Same boundary as 1A and 1B: the dedicated tier's data-engine can do pipeline-style work, but CoreWeave does not expose an ETL/pipeline/lineage product the customer can buy and hold CoreWeave to. An underlay capability CoreWeave does not surface as a service is not a CoreWeave capability. Gap. Data movement ≠ data pipelines. Cross-cloud reach is a Layer 0/1A throughput property, not a Layer 1C pipeline capability. Function remains the enterprise's: gap, authority Absent.
None to borrow. Fast transport is not a pipeline; the pipeline is the enterprise's, composed from open tooling. The reading is Absent: nothing offered, nothing inherited.
Named, not scored: Model Distillation (Forge Post-Training) builds training datasets from production traffic captured through its proxy, lets the enterprise select, remove and relabel examples with a stronger model, and trains candidate models on them. That's trainer-input preparation with a captive destination, which would read moderate under the captive-prep ruling (September 11, 2026). It's in private preview ('Request access from the Post-Training page in Forge') and carries no GA date, so it isn't a watch item.
GPU scheduling, quotas, RBAC, fair-share scheduling, utilization optimization
Managed, CNCF-conformant Kubernetes on bare metal with HPC networking, consumed as a CoreWeave-operated service: Delegated per the managed-service-behind-a-standard-interface rule (the EKS, AKS, GKE and OKE treatment). Manifests port to any conformant Kubernetes.
Proprietary cluster health, straggler detection, silent-fault mitigation, and node lifecycle management; ~50% fewer interruptions claimed. Operational intelligence layer captive to CoreWeave.
Open-source Slurm integrated as a Kubernetes scheduler: login, compute and controller nodes as Pods, with preemption across Slurm and Kubernetes workloads. Slurm definitions port to any Slurm environment; SUNK Anywhere extends to non-CoreWeave and on-premises clusters. Consumed as a CoreWeave-operated service: Delegated.
SUNK topology-aware scheduling tuned to GB200 rack-scale NVLink/InfiniBand layouts; Mission Control detects GPU stragglers and silent hardware faults.
This is CoreWeave's signature layer and the most consequential authority call in the row. CKS (CoreWeave Kubernetes Service) plus SUNK (Slurm on Kubernetes) plus Mission Control deliver differentiated, complete GPU-cluster orchestration: unified Slurm batch scheduling and Kubernetes container orchestration on one cluster, topology-aware placement, preemption logic across both schedulers, automated node lifecycle and straggler mitigation, and self-service cluster provisioning. Strong capability: peer to the hyperscalers' managed orchestration and, by several customer accounts, ahead of it for large training clusters. The authority reading is where CoreWeave diverges from every hyperscaler in this assessment. The hyperscalers' managed orchestration is scored present-and-Ceded because the scheduling opinions (Karpenter, proprietary fair-share) are captive. CoreWeave's orchestration opinions rest on open substrate: Kubernetes (CNCF) and Slurm (open-source, SchedMD), and SUNK Anywhere explicitly runs the same workflows on non-CoreWeave clusters and on-prem 'with very few configuration changes,' confirmed by customers running it across providers. The enterprise can lift its Slurm/K8s scheduling opinions and operate them elsewhere without rebuilding. By the litmus the opinions lift, so the service consumed reads Delegated, the managed-Kubernetes treatment, and the self-operated form under SUNK Anywhere is Retained. It calibrates near the Red Hat standard. Two proprietary slivers sit inside the otherwise-portable layer: Mission Control (the health/straggler-detection and lifecycle service) and the SUNK self-service operator/console are CoreWeave IP. A buyer who depends on Mission Control's operational intelligence specifically inherits a Ceded dependency, but the core scheduling abstraction they would carry to another platform is open.
Low, and unusually so for a cloud. Scheduling opinions rest on Kubernetes and Slurm and lift out, per SUNK Anywhere. Mission Control's operational intelligence is the one captive piece; a buyer who depends on it inherits a CoreWeave dependency. The runtime call is placement, and the enterprise holds the documented per-object controls the override rule names: Slurm partitions and scontrol on named nodes under SUNK, Kubernetes node selectors and tolerations on CKS, and topology-aware placement its own schedulers act on; Mission Control's health, straggler, and node-lifecycle decisions stay CoreWeave's. Vendor decides the defaults, visible, overridable on those documented pins, Delegated (re-read September 15, 2026 under the override rule; the WEKA, Dataiku, and Nebius 2A reading).
Pressure-tested against the tidy-story risk: it would be neat to call every cloud's 2A Ceded. CoreWeave genuinely breaks that pattern because it ships the open schedulers as the product rather than hiding a proprietary one behind a managed service. The portable reading is evidence-driven (SUNK Anywhere portability), not generous. Authority re-read September 15, 2026: the v2 split (September 2) had written vendor / Ceded two days before the override rule was ratified on Elastic; documented per-node pins (Slurm scontrol and partitions, Kubernetes node selectors and tolerations) are overrides under that rule, so the reading is Delegated, aligned with WEKA, Dataiku, and Nebius 2A. Mission Control's decisions remain the vendor's.
Model serving, agent execution, inference APIs, distributed inference
Open model serving on CoreWeave-operated managed Kubernetes; Tensorizer accelerates model load from S3. Runtime opinions lift off CoreWeave. Delegated, the managed-service-behind-a-standard-interface reading; self-operating the same open stack elsewhere is the Retained form.
GA through open serving on CKS and through Serverless Inference tool calling, both OpenAI-compatible. The enterprise owns and operates the business logic, APIs, commands and deterministic validators invoked through tool calls: the seam where control passes from instructing the model to executing code outside it. The opinions are the enterprise's and run against a multi-vendor interface, so they lift to another provider with an adapter and re-evaluation, not a rebuild. What the enterprise cedes at this seam is the decision to act: the model chooses whether, when and with which arguments to call, and that judgment is inherited under the serving components. Retained, the customer-tools ruling.
Open-weight models their owners publish, served by CoreWeave behind a multi-vendor interface the enterprise could point at another provider. Delegated, the inference-interface ruling and the Groq and Nebius serverless reading; the models are their owners'. Weave traces of these calls accumulate in Forge and are read on the Weave chip.
The adapter is the enterprise's artifact, trained wherever it chose and uploaded to Forge; CoreWeave loads it onto a shared base model behind the OpenAI-compatible path. Delegated, the Groq LoRA reading with the customer fine-tunes reading; the artifact URI as model name is a client edit, not a rebuild. Lab 024 ran this path: a rank-16 adapter trained off CoreWeave, uploaded through bring-your-own, matched self-hosting on 1,909 of 1,910 conversations on the shared endpoint.
Isolated execution environments for agent tools, evaluations and RL. GA on serverless capacity CoreWeave operates and sets policy for, with access enabled per organization; on the customer's own CKS cluster the customer's administrator enables the runner and configures the sandbox policy. The sandbox API and control plane are CoreWeave's either way, so the opinions don't lift. Ceded.
Experiment tracking, model and dataset versioning, artifact lineage, aliases, collections, access roles and lifecycle automations, hosted in Forge or deployed as W&B Dedicated Cloud or Self-Managed. The artifact files download; the experiment history and lineage around them are the captive value. Ceded, read with the model-lifecycle peers (Databricks MLflow, Snowflake ML Model Registry); self-managed deployment is operational control, not authority.
Agent and LLM tracing, evaluation framework, scorers, leaderboards and production monitoring; the MCP server lets coding agents query and act on the W&B plane; ARIA, available only in the multi-tenant cloud, analyzes runs and launches experiments in its own sandbox. They see, score and improve agent behavior; none authorizes, blocks or routes an agent's action at request time, which is why they're read here and not at 2C. Ceded. Not scored within this chip under the GA evidence table: ARIA ("ARIA enters public preview today, with a roadmap focused on deeper autonomous research capabilities").
The model-building platform beneath Monolith's engineering-test modules, which its own FAQ calls 'a development platform with model architectures ready to be trained using your data.' Read here as model-building tooling, which earns no Layer 3 grade; the modules carry Layer 3. Models export only to other notebooks and teams inside the platform. Ceded. Not scored within this chip under the GA evidence table: REST API (No public owner page names the REST API; the support article describing it returned 403 and the CoreWeave Monolith docs index lists no API page.).
Serving and training run on CoreWeave's NVIDIA fleet. Open engines (vLLM under KServe, the Serverless Inference catalog) carry no NVIDIA AI Enterprise requirement; Dedicated Inference's dynamo-vllm runtime, still alpha, would add NVIDIA Dynamo on the serving path.
Strong, complete runtime capability across serving and agent execution. CKS runs open serving stacks (KServe, Kubeflow, vLLM) on CoreWeave-operated Kubernetes, and Tensorizer streams serialized models from S3 or HTTPS for fast cold start. Serverless Inference serves a catalog of open-weight models through an OpenAI-compatible API with tool calling, structured outputs, JSON mode, reasoning output, streaming and prefix caching, which is what an enterprise's own agent loop needs from the model behind it. It also serves the enterprise's own LoRA adapters: an adapter trained anywhere is uploaded as a versioned artifact and called by its artifact URI through the same chat completions path, on the shared base model, billed per token. CoreWeave Sandboxes give agents, evaluations and training jobs isolated execution on serverless capacity or on the customer's own CKS cluster. Since September 30, 2026 the Weights & Biases products sit inside CoreWeave Forge, the development layer that also carries the former OpenPipe and Marimo products. The GA parts that matter here are W&B Models (experiment tracking), CoreWeave Registry (versioned models and datasets with lineage and aliases), W&B Weave (tracing and evaluation), the W&B MCP server, and ARIA, a research agent that analyzes runs and launches experiments in its own sandbox. Forge is sold cloud-agnostic: its hosted service runs on Google Cloud, and W&B Dedicated Cloud and Self-Managed deployments are documented, though ARIA runs only in the multi-tenant cloud. A team can use it without renting a CoreWeave GPU. Monolith's core platform, the no-code notebooks and model training beneath its engineering-test modules, is model-building tooling and is read here too; the modules themselves carry Layer 3. The buyer gets a runtime that's open where it serves and a development layer that ties training, evaluation and serving into one loop. The architect's concern is where the opinions accumulate. Serving sits behind the OpenAI-compatible interface and lifts to any provider that implements it, and the enterprise's adapters are its own files. The experiment history, registry lineage, evaluation datasets and scorers, and the improvement loop ARIA drives accumulate in Forge's namespace. That's the decoupled capture: the visible layer is open, and the layer that compounds isn't. Self-Managed deployment changes who operates it, not whether it lifts. Calibration: Groq and Nebius read their serverless OpenAI-compatible catalogs Delegated and Groq reads customer LoRA adapters Delegated; Databricks and Snowflake read their model registries Ceded; NVIDIA holds strong on NIM and Dynamo with a Ceded runtime. CoreWeave holds strong with the serving path Delegated and the Forge plane Ceded.
Split by what you use. The model decides whether and how to call a tool, but the loop runs in the enterprise's own code against an OpenAI-compatible endpoint, where a deterministic gate before any effect is the enterprise's to write: model decides, visible, overridable, Delegated. Open serving on CKS and the Serverless Inference catalog lift to another provider behind the same interface, and an adapter the enterprise trained goes with them. One Forge trained goes too, after conversion work: Lab 024's Forge-trained Gemma 4 adapter downloaded as a standard file, but stock vLLM wouldn't load it until its fused expert tensors and module paths were translated. That's a gap across MoE LoRA tooling, not Forge's alone. What doesn't lift is Forge: years of experiment history, registry lineage and aliases, Weave evaluations and scorers, and the improvement loop ARIA drives accumulate in a proprietary namespace while everything beneath them stays portable.
Named, not scored (docs badges): Serverless RL and Serverless SFT are in public preview ('Serverless RL and Serverless SFT are in public preview'; training is free during the preview, and the training API paths are /v1/preview/); Model Distillation is in private preview ('Request access from the Post-Training page in Forge'); Dedicated Inference (bring-your-own-weights deployments on vllm or dynamo-vllm behind a gateway with authentication and body, header or path routing) is governed by its API reference, which versions the API v1alpha1 and says 'APIs may change before general availability', over the product overview, which carries no badge; RL Rollouts on Dedicated Inference is preview per the Forge launch release; Notebooks (Marimo) is public preview; W&B Skills (wandb-primary, wandb-autoresearch, weave-instrument, agentlens-tracing-instrument and the rest) are each labeled 'experimental' in the wandb/skills repository; Agent Lens is preview per the Forge launch blog, and its docs carry no badge. None carries a GA date, so none is a watch item. Sandboxes are GA with access enabled per organization; select availability scores. Lab 024, 'Fine-tune the interpreter, then find out what it does to the queue' (October 20, 2026, https://labs.layer2c.com/labs/finetune-interpreter), is cited as lab-derived evidence and mapped to the canon's requirements; the cell is graded on the instrument's own rules. Its bring-your-own result backs the customer-adapter chip. Its finding on the Forge-trained adapter qualifies the exit: the file downloads, and running it elsewhere took conversion. One more finding is a reliability fact, not an authority one: called by its address on the shared endpoint, the Forge-trained adapter returned base-model output, 8 or 9 of 10 answers identical to base, with HTTP 200 and no warning. It sits on the preview training path, so it's named, not scored, and no grade, chip or authority reading moves. Public evidence that moves the cell: GA of Serverless RL and SFT would add a Ceded training service with the adapter exit named (the Nebius fine-tuning reading); GA of Dedicated Inference would add a provisioned-serving chip. The press release's 'open, portable formats' for Registry describes the artifact files, which download; lineage, collections, aliases and automations don't, so Registry holds Ceded. Pointer, not evidence: CoreWeave's AI Field Day 9 session (October 2026). Out of the W&B Weave + W&B MCP Server + ARIA chip under the GA evidence table (October 24, 2026): ARIA ("ARIA enters public preview today, with a roadmap focused on deeper autonomous research capabilities"). Out of the Monolith Core Platform chip under the GA evidence table (October 24, 2026): REST API (No public owner page names the REST API; the support article describing it returned 403 and the CoreWeave Monolith docs index lists no API page.).
Policy-driven placement and resource coordination — the Autonomy Layer
Assessment pending
CoreWeave Forge's improvement loop is real and productized: W&B Weave traces and evaluates agent behavior against custom scorers, the W&B MCP server lets coding agents act on that data, ARIA analyzes runs and launches experiments, and Serverless Inference and Sandboxes run what the loop produces. Serverless RL and SFT close the loop into training but are in public preview. But Layer 2C grades on action, and nothing in the loop acts. It observes agent behavior, scores it, and feeds improvements back through the runtime; it never authorizes, blocks, routes, or orchestrates an agent's action at request time. The governance it exercises is over which agent version improves and gets promoted, a lifecycle decision read at 2B with the model-registry peers. Every 2C moderate on the instrument carries at least one component that acts at runtime (a gateway, a policy engine, an identity whose permissions are enforced per call, an orchestrator), and the rows that score observability and evaluation at 2C pair them with one. An improvement loop with one partial observability leg and no action governance sits below that line: gap. Three request-time surfaces sit near the line and none carries the cell. Dedicated Inference's gateway authenticates and routes requests (body, header or path) across deployments, but its API is v1alpha1 and its docs document no authorization beyond the token and no audit. Model Distillation's proxy shifts traffic weights between model versions, which is routing, not reasoning, and is in private preview. Agent Lens tags traces with LLM judges after the fact and is in preview. The enterprise retains policy-driven placement and a general action-authorization plane, or sources them elsewhere. Routing is not reasoning, and improvement is not placement: no policy engine answers 'given data residency, cost, latency, and compliance, run this inference on B300 in region X versus region Y at request time.' The physical placement underneath is SUNK/Kubernetes scheduling. The live per-inference placement gap is universal across this assessment, not specific to CoreWeave; it is noted, not penalized as a unique defect.
None scored, so the reading is Absent. The improvement loop is real and captive, and it is scored at 2B, where it performs its function; the reasoning plane stays the enterprise's responsibility, or another vendor's.
Pressure-tested 'routing is not reasoning': the Forge improvement loop is genuinely agentic but operates on the model/agent-quality axis, not the request-placement or action-authorization axis. You can't prompt your way to deterministic output: the controls here answer whether an action is legal, never whether the outcome was right. That deterministic outcome-validator is missing instrument-wide, and like live placement it is noted as universal rather than charged to one vendor. Evidence that would move the cell: doc-confirmed Weave guardrails that block or modify an agent's output at request time through deterministic code scorers, a gateway-shaped control. A GA Dedicated Inference gateway with documented per-deployment authorization and audit would be a gateway-shaped candidate to test against the Nutanix line.
AI-powered business capabilities — business logic, workflow automation
CoreWeave's first-party modules for test engineers, sold and supported on CoreWeave's paper, running on Monolith's core platform. Models export only to other notebooks and teams inside the platform, so the trained models and campaign configuration don't lift; the test data does. Ceded.
Assessment pending
CoreWeave sells first-party business software in one vertical: Monolith, acquired in October 2025 and documented under CoreWeave's docs and support. It's built for test engineers in industrial and manufacturing work. Three purpose-built modules carry the grade. Test Plan Optimisation is the Next Test Recommender and NTR Optimisation: models trained on past tests rank the candidate tests worth running next, or the tests that reach a set of targets, to cut the size of a test campaign. Test Data Validation is anomaly detection on test data, including MF4 measurement data from test rigs, flagging runs that don't match learned behavior. System Calibration is targeted and min/max optimisation: set output targets and find the input configurations that meet them. Eligible notebooks can run on a schedule as Apps (v1.10), though Apps don't support notebooks that contain model training steps. The buyer gets a business outcome, fewer physical tests and faster calibration, from software a test engineer runs without a data science team. Underneath the modules sits Monolith's core platform, which its own FAQ calls 'a development platform with model architectures ready to be trained using your data': no-code notebooks that load, explore and transform data and train and evaluate models. That's model-building tooling, and Layer 3 credits first-party business applications, so it gets no Layer 3 credit. The grade rests on the modules alone. The architect's concern is scope and exit. The modules are several fixed-function workflows inside one vertical, engineering test and validation; a business process outside it gets nothing here. That's a fixed-function slice, not a general value plane. The trained models stay inside the platform: Export Model publishes a model to other notebooks and teams, and the docs say it 'does not export models for use outside the Monolith platform.' Everything else CoreWeave sells above the runtime is a developer tool. Forge (Weights & Biases Models, Registry, Weave, ARIA, HiveMind's coding-session dashboard) serves the people who build AI and is read at 2B, the same reading (software-only builders earn no Layer 3 grade) that keeps Broadcom's Spring and Red Hat's Quarkus off their rows' value planes. CoreWeave carries no ISV application catalog on its paper. Calibration: Cloudera reads moderate on two narrow GA applications (AI Visual and AI Annotation); Dataiku and Databricks read strong on first-party business applications across several functions. Three modules confined to one engineering vertical sit at moderate.
The test engineer inherits Monolith's judgment about which tests matter and which configurations meet a target. The models rank candidates, but the engineer picks the recommender, strategy, candidate list, targets and batch size, exports the plan, and runs the tests outside the platform: model decides, visible, overridable, Delegated. What doesn't leave is the modeling. Trained models and the notebook and campaign configuration around them stay in Monolith; the test data itself goes in and comes out through uploads, exports and the REST API, so a team that moves rebuilds its models on another tool from data it already holds.
Monolith's documentation is on docs.coreweave.com with support at a CoreWeave address; release notes run through v1.10, which added scheduled Apps, test-plan output from Next Test Recommender Evaluation, and a 30,000-point plot limit. CoreWeave announced the acquisition on October 6, 2025. HiveMind (a dashboard of AI coding-session activity and spend across Claude Code, Cursor, Codex and Gemini CLI) is a developer tool, which earns no Layer 3 grade. Monolith's site names the three modules (Test Data Validation, Test Plan Optimisation, System Calibration); the docs carry them as steps (anomaly detection, Next Test Recommender and NTR Optimisation, targeted and min/max optimisation). The core platform's notebooks and model training are model-building tooling, which earns no Layer 3 grade. Evidence that would move the cell: a second first-party application in another business function, or Monolith model export to an open format.
CoreWeave docs (docs.coreweave.com, read October 14 and 15, 2026: Forge home and platform, Serverless Inference and bring-your-own LoRA, Dedicated Inference overview and API reference, Post-Training, Serverless Training, Model Distillation, Sandboxes, Registry, ARIA, Agent Lens, Notebooks, Monolith AI), CoreWeave Forge launch release (September 30, 2026), Monolith acquisition announcement (October 6, 2025), monolithai.com product pages and FAQ, wandb/skills repository. CoreWeave Platform and Storage docs, NVIDIA GTC 2026 (HGX B300 GA, Vera Rubin NVL72 H2 2026), SUNK / CKS / Mission Control product pages and docs, CoreWeave AI Object Storage (CAIOS) + LOTA, Distributed File Storage, Dedicated storage tiers (VAST/WEKA/DDN/IBM Spectrum Scale/Pure), CoreWeave Sandboxes, Weights & Biases acquisition (closed 2025) and unified agentic AI launch (May 2026: Serverless RL, CoreWeave Inference, W&B Weave, W&B Skills), NVIDIA $2B investment (Jan 2026), SEC filings, analyst coverage. v1.1 added Dedicated storage tier + Sandboxes (CoreWeave AR, May 29 2026). v1.2 corrects the 1A authority reasoning: the architectural guarantee is CoreWeave's SLA on a CoreWeave service: the storage substrate (VAST/WEKA/etc.) is an implementation detail invisible to the customer and is removed from the DAPM call, consistent with not scoring a hyperscaler's object store on its drive supplier. v1.4 (July 12, 2026, /reconcile): statusLabels moved to capability vocabulary; CKS+SUNK (2A) and CKS open serving (2B) Retained→Delegated: CoreWeave-operated managed services behind standard interfaces take the EKS-class treatment; Retained is reserved for substrates the customer operates (SUNK Anywhere self-host noted as that form). v1.10: 2A authority re-read from Ceded to Delegated under the override rule (September 4, 2026), on the cross-row finding from the Nebius review; no capability or DAPM change. v1.11 (/reconcile, October 5, 2026): Layer 3 moderate to gap because Layer 3 credits first-party business applications (W&B is a first-party developer platform, not a business application, the VMware/Spring ruling); W&B Models + Registry and Weave + Skills moved to 2B as Ceded components with the decoupled-capture reading; 2C held at gap, re-reasoned on the action line (no component authorizes, blocks, routes, or orchestrates at runtime) in place of the Nutanix and VMware calibration, both of which have since moved to moderate. /reconcile (October 5, 2026): IBM and Red Hat are now separate rows; citation retargeted to the Red Hat row, no grade moves. /reconcile (October 5, 2026): Layer 0 runtime rule (ruled September 28 and October 4, 2026). GPU compute split: HGX nodes Ceded to Retained from the customer's seat (the rented-capacity reasoning retired), GB200/GB300 rack-scale Ceded on the integrated-system rule. Grade unchanged. /reconcile (October 5, 2026): authority read against product docs: layer0 visible true. Grades and components unchanged. v1.15 (October 15, 2026): CoreWeave Forge rename pass (Weights & Biases, OpenPipe and Marimo products now under Forge). 2B: the CoreWeave Inference and Serverless RL chip retired; Serverless Inference (Delegated) and customer LoRA adapters (Delegated) scored on the inference-interface ruling; Serverless RL and SFT (public preview), Model Distillation (private preview), Dedicated Inference (v1alpha1 API), Agent Lens and Notebooks (preview) and W&B Skills (experimental) named, not scored; ARIA joins the Weave chip; Monolith core platform added Ceded. Layer 3 gap to moderate on Monolith's engineering-test modules (Ceded; model decides, Delegated). 1C held at gap with Model Distillation named. 2C held at gap. Stale Retained wording in the summary, 2A, 1B and 1C corrected to the scored readings. ChatGPT peer-checks on 2B and Layer 3, eight claims upheld (reviews/coreweave-2b-chatgpt.json, reviews/coreweave-layer3-chatgpt.json). Pointer: CoreWeave's AI Field Day 9 session (October 2026). v1.16 (Layer 0 sub-layers, October 16, 2026): Layer 0 split into 0A Compute, 0B Network Fabric and 0C Storage Substrate by runtime decision (Keith, October 16, 2026); storage left 1A for 0C, and 1A, now Data Foundation & Governance, is graded on the catalog that classifies the data. 1A moderate to strong; 0A strong, 0B strong, 0C strong; summary edits (summary worksheet, Keith, October 16, 2026). v1.17 (October 19, 2026, /reconcile): plain-language pass: methodology rule numbers in the prose and audit notes replaced with the reasoning they stood for; no grade, chip or authority reading changed. v1.18 (October 19, 2026, /reconcile voice pass): em-dashes in the prose replaced with periods, colons, commas or parentheses; wording, grades, chips and authority readings unchanged. v1.19 (October 21, 2026): Lab 024 (labs.layer2c.com/labs/finetune-interpreter, October 20, 2026) cited at 2B as lab-derived evidence (Keith, October 21, 2026): the bring-your-own adapter path confirmed on the customer-adapter chip, the Forge-trained adapter's conversion work named in the exit reading, and its silent base-model fallback on the shared endpoint named in the notes. No grade, chip or authority reading changed. v1.20 (October 23, 2026, /reconcile): 0A's rack-scale chip scores Vera Rubin NVL72 (verarubin-4x-e, limited availability for select customers, GA with gating) and cites Lenovo's NVL-class racks in place of Dell's unscored XE9812; CPU nodes come in as a Retained chip; a freshest-generations claim comes out; 0B's calibration cites GCP's RoCE GPU network in place of Virgo. Found by the 0A compute research. Grade and authority unchanged. v1.21 (October 23, 2026, /reconcile): Layer 1 research pass. 1A: rewritten (the chip named "governance services" without a product; CoreWeave documents it as Dedicated VAST Storage's data services). Found by the Layer 1 slot cut. Grade and cell authority unchanged. v1.22 (October 23, 2026, storage door pass): The S3 API and Dedicated VAST's NFS and S3 are doors; the managed services read Ceded. Grade unchanged. v1.23 (October 24, 2026, /reconcile): GA evidence recorded on 2 of 2 Layer 1A chips under the GA evidence table version 2. Grade unchanged. v1.24 (October 24, 2026, /reconcile): GA evidence recorded on 3 of 3 Layer 0B chips under the GA evidence table version 2. Grade unchanged. v1.25 (October 24, 2026, /reconcile): GA evidence recorded on 3 of 3 Layer 0A chips under the GA evidence table version 2. Grade unchanged. v1.26 (October 24, 2026, /reconcile): GA evidence recorded on 6 of 6 Layer 0C chips under the GA evidence table version 2. Grade unchanged. v1.27 (October 24, 2026, /reconcile): GA evidence recorded on 2 of 2 Layer 2A chips under the GA evidence table version 2. Grade unchanged. v1.28 (October 24, 2026, /reconcile): GA evidence recorded on 6 of 8 Layer 2B chips under the GA evidence table version 2. Grade unchanged. v1.29 (October 24, 2026, /reconcile): GA evidence recorded on 1 of 1 Layer 3 chips under the GA evidence table version 2. Grade unchanged. v1.30 (October 24, 2026, /reconcile): GA evidence table version 2.1 applied: 3 chips recorded or narrowed. Grade unchanged. v1.31 (October 24, 2026, /reconcile): Layer 2 bundle split: CKS + SUNK split into CoreWeave Kubernetes Service and SUNK. Grade unchanged. v1.32 (October 27, 2026): each component now carries a durable offering id; nothing else changed.