NVIDIA is the only vendor in this assessment series that appears inside every other vendor's assessment. Dell's Layer 2A GPU orchestration is NVIDIA Run:ai. HPE's Layer 2B runtime is NVIDIA AI Enterprise. VMware's GPU integration is NVIDIA vGPU Manager. AWS, Google Cloud, and Azure all run NVIDIA GPUs alongside their own silicon. VAST embeds NVIDIA GPUs, NICs, DPUs, and switches into its data platform. Mapping NVIDIA as a standalone vendor inverts the perspective: instead of asking 'where does Dell cede authority to NVIDIA,' the question becomes 'where does NVIDIA claim authority, and from whom?'
The 4+1 mapping reveals NVIDIA as a vendor with deep authority at 0A, 0B, 2A and 2B, and emerging ambitions at Layer 2C. NVIDIA designs the accelerator silicon that every other vendor depends on (0A), provides the GPU orchestration platform that on-prem vendors brand as their own (Layer 2A via Run:ai), and controls the inference runtime and model lifecycle stack that sits between the enterprise's infrastructure and its AI applications (Layer 2B via NIM, NeMo, Dynamo, TensorRT-LLM). At Layers 1A through 1C, NVIDIA is an accelerator: it makes other vendors' storage and data pipelines faster without providing those capabilities directly.
The structural tension is between NVIDIA as a silicon supplier and NVIDIA as a platform vendor. When NVIDIA was only selling GPUs, its interests aligned with every OEM and hyperscaler: more GPU adoption meant more revenue for everyone. As NVIDIA extends into GPU orchestration (Run:ai), inference runtime (NIM/Dynamo), agent governance (OpenShell/NemoClaw), and cloud infrastructure (DGX Cloud), it competes with the same customers who buy its silicon. Dell's AI Factory runs NVIDIA software. But DGX Cloud is NVIDIA competing with Dell for the same enterprise workload.
The DAPM classification for NVIDIA is inverted from every other assessment: the enterprise consuming NVIDIA through an OEM (Dell, HPE, VMware) has already Ceded authority to the OEM, which has Ceded authority to NVIDIA. The enterprise consuming NVIDIA directly (DGX Cloud, NIM API) Cedes authority to NVIDIA without an intermediary. The enterprise self-hosting NVIDIA open-source software (Dynamo, OpenShell, Nemotron) Retains authority, but still runs on NVIDIA silicon. NVIDIA is the only vendor where every deployment path, at every layer, eventually depends on NVIDIA hardware.
More than half of NVIDIA's engineers work on software. That statistic from NVIDIA's FY2026 annual report is the key to understanding the 4+1 mapping: NVIDIA is a software company that happens to sell the hardware its software requires. The assessment series has been documenting where NVIDIA's software authority appears inside other vendors' stacks. This assessment makes that authority explicit.
Layer-by-layer status: Layer 0A (The Accelerator Frontier: Blackwell, Vera Rubin, Grace and DGX), Layer 0B (The AI Fabric Frontier: NVLink, Quantum InfiniBand, Spectrum-X), Layer 0C (No Storage on NVIDIA's Paper), Layer 1A (Accelerator Only), Layer 1B (Acceleration + Model Enablement), Layer 1C (Gap: single pre-GA capability), Layer 2A (NVIDIA Authority via Run:ai), Layer 2B (NVIDIA Authority: Inference + Agent Runtime), Layer 2C (Runtime Governance Only: Not a Reasoning Plane), Layer 3 (+1) (No Business Applications; Nemotron 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.34 - 4+1 v3: Layer 0 Sub-Layers.
NVIDIA is the only vendor in this assessment series that appears inside every other vendor's assessment. Dell's Layer 2A GPU orchestration is NVIDIA Run:ai. HPE's Layer 2B runtime is NVIDIA AI Enterprise. VMware's GPU integration is NVIDIA vGPU Manager. AWS, Google Cloud, and Azure all run NVIDIA GPUs alongside their own silicon. VAST embeds NVIDIA GPUs, NICs, DPUs, and switches into its data platform. Mapping NVIDIA as a standalone vendor inverts the perspective: instead of asking 'where does Dell cede authority to NVIDIA,' the question becomes 'where does NVIDIA claim authority, and from whom?'
The 4+1 mapping reveals NVIDIA as a vendor with deep authority at 0A, 0B, 2A and 2B, and emerging ambitions at Layer 2C. NVIDIA designs the accelerator silicon that every other vendor depends on (0A), provides the GPU orchestration platform that on-prem vendors brand as their own (Layer 2A via Run:ai), and controls the inference runtime and model lifecycle stack that sits between the enterprise's infrastructure and its AI applications (Layer 2B via NIM, NeMo, Dynamo, TensorRT-LLM). At Layers 1A through 1C, NVIDIA is an accelerator: it makes other vendors' storage and data pipelines faster without providing those capabilities directly.
The structural tension is between NVIDIA as a silicon supplier and NVIDIA as a platform vendor. When NVIDIA was only selling GPUs, its interests aligned with every OEM and hyperscaler: more GPU adoption meant more revenue for everyone. As NVIDIA extends into GPU orchestration (Run:ai), inference runtime (NIM/Dynamo), agent governance (OpenShell/NemoClaw), and cloud infrastructure (DGX Cloud), it competes with the same customers who buy its silicon. Dell's AI Factory runs NVIDIA software. But DGX Cloud is NVIDIA competing with Dell for the same enterprise workload.
The DAPM classification for NVIDIA is inverted from every other assessment: the enterprise consuming NVIDIA through an OEM (Dell, HPE, VMware) has already Ceded authority to the OEM, which has Ceded authority to NVIDIA. The enterprise consuming NVIDIA directly (DGX Cloud, NIM API) Cedes authority to NVIDIA without an intermediary. The enterprise self-hosting NVIDIA open-source software (Dynamo, OpenShell, Nemotron) Retains authority, but still runs on NVIDIA silicon. NVIDIA is the only vendor where every deployment path, at every layer, eventually depends on NVIDIA hardware.
More than half of NVIDIA's engineers work on software. That statistic from NVIDIA's FY2026 annual report is the key to understanding the 4+1 mapping: NVIDIA is a software company that happens to sell the hardware its software requires. The assessment series has been documenting where NVIDIA's software authority appears inside other vendors' stacks. This assessment makes that authority explicit.
CPUs, accelerators, servers, integrated systems, OS and hypervisor, physical plant
Blackwell B200/B300/GB200 (current generation). Vera Rubin NVL72 ("Available Now" on NVIDIA's product page, with a datasheet). Dell builds PowerEdge around it. HPE builds ProLiant and Cray around it. AWS offers it as P5/P6 instances. Azure offers it as ND-series. Google offers it alongside TPUs. VAST embeds it in CNode-X. Reached through an open runtime, the workload's opinions live in framework code that also runs on AMD Instinct, Intel Gaudi, or a TPU, so the hardware stays swappable: Retained under the Layer 0 runtime rule.
Workloads written against CUDA, custom kernels, or TensorRT-LLM engines run only on NVIDIA hardware, and leaving means rewriting them: Ceded under the Layer 0 runtime rule. Most enterprises hold both paths at once, which is why the silicon is recorded as a split rather than one reading.
DGX SuperPOD, NVIDIA's "Full-stack blueprint for gigascale AI infrastructure": pre-configured DGX systems with NVIDIA's software stack pre-installed, for on-prem and hybrid. Competes directly with Dell PowerEdge, HPE ProLiant, and OEM AI server configurations. NVIDIA sells the assembled system, not just the components.
NVIDIA now describes DGX Cloud as "NVIDIA’s internal cloud environment for building and operating AI at scale." The customer offer is a fully managed AI training platform on AWS, Azure, Google Cloud and OCI, sold by private offer on each marketplace. The enterprise reaches NVIDIA infrastructure through a hyperscaler substrate: Ceding to both NVIDIA (software and GPU) and the hyperscaler (facility and network).
NVIDIA's Arm data center CPU. The Grace CPU Superchip joins two Grace dies over NVLink-C2C for 144 Neoverse V2 cores, and Grace C1 is a single-socket server platform. It's also the host CPU inside GB200 and GB300 NVL72. NVIDIA says existing AArch64 binaries, compilers and operating systems run on it unchanged.
A liquid-cooled rack of 72 Blackwell or Blackwell Ultra GPUs and 36 Grace CPUs in one fifth-generation NVLink domain, with ConnectX-8 SuperNICs scaling out over Quantum-X800 InfiniBand or Spectrum-X Ethernet, and managed with Mission Control. Sold through OEM and ODM partners and as DGX GB300. Facet at 0B for the NVLink switch fabric.
BlueField in DPU or zero-trust mode, running infrastructure services apart from the host: OVS-DOCA switching offload, SR-IOV and scalable functions, the DOCA Virtio-net and SNAP device emulation services. Documented in DOCA 3.5.0.
The operator that "uses the operator framework within Kubernetes to automate the management" of the NVIDIA drivers, container runtime and device plugin that provision GPUs to workloads. Its source is "licensed under Apache 2.0." Retained, the open GPU operator reading.
Licensed vGPU software whose Linux vGPU Manager runs on "Citrix Hypervisor, Linux with KVM, Red Hat Enterprise Linux with KVM, Ubuntu, and VMware vSphere," supported until March 2027. Delegated, the vGPU reading: the same NVIDIA software slices GPUs under whichever hypervisor the enterprise runs.
DGX Spark on the NVIDIA GB10 Grace Blackwell Superchip, sold on the NVIDIA Marketplace and through channel partners. DGX Station on the GB300 Grace Blackwell Ultra Desktop Superchip isn't on NVIDIA's paper: partners build and sell it, so it's a device category read on their rows, Dell's Pro Max GB300 among them. Commodity deskside substrate, read like Lenovo's ThinkStation PGX: two sellers of one design read the same, and the CUDA dependency is read on the silicon chips.
Assessment pending
Layer 0 is where NVIDIA's authority starts. Blackwell and Vera Rubin GPUs, Grace CPUs, GB200 and GB300 NVL72 racks, and DGX systems on premises and as DGX Cloud set the frontier every other row calibrates against. Nearly every vendor on the instrument depends on this silicon; AWS, Google, AMD and Intel are the exceptions with accelerators of their own. The buyer gets the accelerator most of the instrument is built on, and the software that puts it in front of workloads: the GPU Operator on Kubernetes and vGPU under the hypervisor. The architect's concern is which runtime the workload adopts. Through PyTorch, vLLM or SGLang the GPUs stay swappable; CUDA kernels and TensorRT-LLM engines bind the workload to NVIDIA. DGX also puts NVIDIA in competition with the OEMs and clouds that resell its silicon. Calibration: AMD reads strong as the second source.
Retained where the grade rests. The GPUs and DGX nodes the enterprise owns make no runtime call on NVIDIA's behalf: enterprise decides, visible, overridable, Retained. Portability splits by runtime on the owner's row: open runtimes and the GPU Operator Retained, vGPU Delegated across hypervisors, CUDA Ceded, DGX SuperPOD and the NVL72 racks Ceded as integrated systems, and DGX Spark and Station Retained as deskside systems.
Watch-list: the Vera CPU (NVIDIA's page still offers 'Email Me When Available'). Lab-measured (July 2026): the xeon-rematch lab ran a deterministic batch-repair protocol on owned DGX Spark (GB10) capacity; a 12B model cleared 60 of 117 bug-fix attempts (51.3%), with zero validator false passes across 585 scored attempts instrument-wide. Not separate chips (October 16, 2026): HGX B300 and B200 baseboards fold into the two runtime-split silicon chips (G5), and MIG reads with the silicon (G4).
Hands-on builds on real hardware that test where authority actually holds at this layer.
Lab 002 rerun off NVIDIA end to end: the workflow is portable and CUDA is a default, not a requirement; what actually gates the path is who will sell you the silicon, and whether your acceptance gate measures what you think it does.
A 30B coder model on one box clears 18 of 22 gate-verified repairs. A 31B general model cleared 11. Seven parameters apart, same hardware, same gate, and what separates them is training for tools rather than size. The self-hosted floor is real and lower than expected. The bill just isn't in dollars: 18 of 22 took 11.4 hours of owned hardware against 40 minutes and $3.14 for all 22 on a hosted mini.
Open weights on capacity I already carry clear 17 of 22 repairs for nothing, and the gate names the five they miss. Renting more hardware for the rest is slower and dearer than the API. The minimum that finishes the job is a mini model in an agentic harness, at $3.14. Two Opus generations finish the same 22 for four times that.
One control architecture across 70 repairs. Within that single harness a frontier model added nothing as the loop's controller and lifted recovery from 14 to 20 as the worker. The deterministic validator still determines done, and the tier that matters sits in the worker seat, not the control seat.
A smaller model on idle capacity cleared real verifiable work under the same deterministic validator; in 585 scored attempts no validator pass failed the held-out checks.
Fine-tuning captured voice and bounded behavior, not judgment; one paragraph of standing positions in the system prompt beat two fine-tuning rounds.
The control plane held where patterns were owned and encoded, and failed where the model became the author of correctness. The question is who may author the patterns and done-criteria.
About 5% of tasks benefit from same-tier repair; the control point is the deterministic validator plus escalation policy, not the loop.
For a custom model you own, cloud token pricing disappears and becomes a rented floor; against a floor the owned box wins, and the managed path takes the weights.
The managed data plane is cheap and fast; the cost it hides is the chunking judgment it takes from you. Borrow the plumbing, keep your own chunking.
Interconnects, switching and routing, network virtualization
"NVLink is a 3 TB/s bidirectional, direct GPU-to-GPU interconnect," and the switch connects NVLinks "to provide all-to-all GPU communication," per NVIDIA's NVLink page, in domains of 8 (Hopper) to 72 (NVL72). Captive to the systems it ships in, Ceded.
The NVLink, InfiniBand and Spectrum-X fabric a DGX SuperPOD ships with. The B300 reference architecture lays it out as separate networks: a twin-planar Spectrum-X compute fabric, a storage fabric on SN5600 Ethernet or Quantum InfiniBand switches, and an in-band management network on SN5600D switches. DGX Station and Spark carry no cluster fabric. Integrated-system rule applies at this facet.
The GPU cluster fabric DGX Cloud is delivered on, inside the host cloud. Integrated-system rule applies at this facet.
Quantum-X800 is a 144-port 800 Gb/s InfiniBand switch with SHARP v4 in-network computing, adaptive routing and telemetry-based congestion control, and "a dedicated port supporting the Unified Fabric Manager (UFM)." InfiniBand and UFM are NVIDIA's: Ceded.
NVIDIA's adapters: the ConnectX-7 manual "describes NVIDIA® ConnectX®-7 InfiniBand and Ethernet adapter cards," and ConnectX-8 offers "support for both InfiniBand and Ethernet networking at up to 800 gigabits per second (Gb/s)." One adapter runs either plant. HPE integrates ConnectX into ProLiant, and VAST uses ConnectX for NVMe-over-Fabrics. Spectrum-X's adaptive routing and congestion control ride the SuperNIC, so the opinions don't lift: Ceded.
"The NVIDIA BlueField-3 DPU is a 400 Gb/s infrastructure compute platform," programmed through DOCA, which "unlocks the potential of the NVIDIA® BlueField® platform." Offload written to DOCA doesn't lift to another DPU: Ceded. NIXL, NVIDIA's inference data-movement library, reads above Layer 0.
SN5000 and SN6000 Ethernet switches for the Spectrum-X AI back end, which NVIDIA calls "end-to-end, AI-optimized Ethernet," paired with ConnectX and BlueField SuperNICs for adaptive routing and congestion control. On Cumulus the opinions are NVIDIA's and don't lift: Ceded. The SONiC path is its own chip.
The same SN5000 and SN6000 switches for the Spectrum-X AI back end, where NVIDIA documents "support for open Ethernet stacks (SONiC)." Configuration built on SONiC lifts to another SONiC switch: Delegated, the open-NOS reading.
Assessment pending
NVIDIA sells every part of the AI fabric. NVLink and NVSwitch scale up inside the rack, and Quantum-X800 InfiniBand and Spectrum-X Ethernet switches scale out. ConnectX SuperNICs and BlueField DPUs sit at the host, with UFM to manage it all. It's the fabric most OEMs resell under their own brands. The buyer gets an end-to-end fabric tuned for collective traffic. The architect's concern is lock-in at the network. InfiniBand and Spectrum-X opinions don't move to another vendor's switches without rebuilding. Calibration: HPE's Slingshot and AWS's EFA read strong on fabrics of their own.
Ceded where the grade rests. NVIDIA's fabric manager decides NVLink and InfiniBand routing at runtime, visible through UFM, with no per-decision override: vendor decides, visible, not overridable, Ceded. Portability: the switches, the NVLink domain and the DGX fabrics read Ceded.
Open for /reconcile: Spectrum-X on SONiC may read Delegated under the standard-interface test, and NIXL, inside the networking chip, may belong at 1C under the DDN ruling.
Arrays, storage servers and software, front-end protocols: where the data sits
Assessment pending
NVIDIA sells no storage. BlueField DPUs can offload NVMe over Fabrics for other vendors' storage. The AI Data Platform is a reference design storage vendors build to. Neither is a storage substrate on NVIDIA's paper. Calibration: AMD and Intel read gap here too.
Absent: nothing offered and nothing inherited at 0C.
Named, not scored: the NVIDIA AI Data Platform reference design and STX, which raise the floor for every storage vendor without being one.
The data itself, organized and governed: the Governance Catalog that Layer 2C queries
Assessment pending
NVIDIA provides no storage, no data governance, and no data platform. Zero components at this layer. NVIDIA accelerates other vendors' storage with GPU libraries (cuVS for vector search, RAPIDS for data processing) and networking hardware (BlueField DPUs, ConnectX NICs), but those are acceleration functions assessed at their functional layers (1B for retrieval, 1C for data processing, Layer 0 for networking silicon). The storage platforms, governance catalogs, and data architectures are entirely owned by other vendors: Dell (PowerScale, ObjectScale, MetadataIQ), HPE (Alletra, Data Fabric), VAST (DataStore, DataBase, Catalog), AWS (S3, Glue, Lake Formation), Google (BigQuery, Knowledge Catalog), Azure (Blob, Fabric, Purview). The absence of NVIDIA-owned storage or governance is structurally significant for Layer 2C: a Reasoning Plane needs governance metadata: which data is sensitive, which models are approved, which compliance requirements apply. NVIDIA has no Layer 1A metadata to feed into a Layer 2C reasoning plane. Every other vendor's 2C ambition is anchored in governance metadata from 1A. NVIDIA's emerging Layer 2C (OpenShell/NemoClaw) operates without governance context because NVIDIA doesn't own the data layer.
None. NVIDIA has no data layer authority to lend or borrow. The enterprise's storage and governance judgment comes entirely from the storage vendor.
The STX Architecture observation from the Dell assessment applies here: STX is available to every storage vendor. It does not differentiate any OEM's storage offering: it raises the floor for all of them. NVIDIA's Layer 1A role is to make the data layer faster, not to provide or govern it.
Low-latency retrieval for RAG — vector/hybrid search, context windows
GPU-accelerated vector similarity search library. 12x faster vector indexing. Used by Dell (MetadataIQ integration), VAST (CNode-X vector search), and storage vendors for retrieval acceleration. NVIDIA provides the search acceleration; the platform vendor provides the retrieval infrastructure and index.
Embedding and reranking NIM microservices the enterprise licenses under NVIDIA AI Enterprise and operates, integrated into Dell's Data Search Engine (PowerScale connector), HPE's retrieval stack, and VMware's AI Enterprise RAG Stack. NVIDIA AI Enterprise coverage is per microservice: NVIDIA's NeMo Retriever Library overview says the library, its container image, and its Helm charts are "not supported under NVIDIA AI Enterprise (NVAIE)," and that NIM coverage "does not extend to the NeMo Retriever Library or its end-to-end extraction workflow." The operated microservices and their opinions are NVIDIA's: Ceded. The standard endpoints in front of them are their own chip.
Pre-built inference microservices for text and multimodal embedding. Used by VAST's InsightEngine, Dell's retrieval pipeline, and hyperscaler RAG services. NVIDIA provides the embedding models; the platform vendor provides the retrieval infrastructure. Embeddings are model-captive even behind a standard-shaped API: the stored vectors are useless without the same model at query time and no second vendor serves the same embedding space. Ceded on the embeddings carve-out.
Per NVIDIA's documentation, "All NeMo Retriever Embedding NIM Docker containers expose an API compatible with OpenAI's API standard." Applications built against the endpoint re-point to another OpenAI-compatible embedding service, and changing the model means re-embedding the corpus. Delegated. The operated microservices are the NeMo Retriever chip, Ceded.
Assessment pending
NVIDIA provides retrieval acceleration and embedding models but not retrieval infrastructure. The retrieval engines (Azure AI Search, OpenSearch, Elasticsearch, VAST InsightEngine, Google Vertex AI Search) are owned by other vendors. NVIDIA makes retrieval faster and provides the embedding models that make vector search work, but the enterprise's retrieval architecture is determined by the platform vendor. NeMo Retriever's embedding and rerank microservices are a meaningful capability that multiple OEMs brand as part of their offerings. The pipeline around them is reference code: the NeMo Retriever Library and the RAG and AI-Q Blueprints sit outside NVIDIA AI Enterprise support, so the cell scores the microservices and cuVS, not the pipeline. When Dell advertises 'GPU-accelerated hybrid search,' the GPU acceleration is NVIDIA's. The enterprise's retrieval quality depends on NVIDIA's embedding model quality, a borrowed judgment that is rarely made explicit.
Moderate. NeMo Retriever embedding models determine retrieval quality. The enterprise inherits NVIDIA's embedding model training decisions, architecture choices, and optimization priorities. This borrowed judgment is invisible: the enterprise interacts with Dell's search engine or VAST's InsightEngine, not with NVIDIA's embeddings directly.
The embedding model dependency is worth tracking across the assessment series. Multiple vendors (Dell, HPE, VAST, VMware) use NVIDIA NIM embedding models for their RAG pipelines. If NVIDIA changes embedding model architecture, quality, or licensing, it affects every vendor's Layer 1B simultaneously, a shared dependency that no single vendor controls. 1B dependency audit (October 24, 2026): the RAG Blueprint (release 2.6.0, May 30, 2026) is "a reference solution," AI-Q is "provided 'as is'," and neither is on the NVIDIA AI Enterprise application software list. The latest embedding (2.4) and rerank (2.3) NIM releases carry no Production Branch label; older ones do. The blueprints went to notes on every row that scored them (SUSE, VMware, Nutanix, WEKA, Lenovo).
Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering
Assessment pending
Deployable today, this is a gap: NVIDIA's only Layer 1C capability, CMX (KV-cache offload via BlueField-4), is pre-GA (see watch-list). The analysis below describes CMX architecture; it is not an option an architect can deploy today. NVIDIA does not provide data pipeline orchestration (Data Factory, Dataloop, DataEngine, Airflow). Its Layer 1C presence is a single capability: KV cache management via CMX. CMX is architecturally significant because it addresses a data movement problem unique to AI inference: KV cache growing beyond GPU memory. This is a Layer 1C function (data movement) that directly affects Layer 2B performance (inference latency). Dell has validated it (19x TTFT improvement on PowerScale); HPE and VAST are expected integrations. The enterprise's KV cache strategy becomes a borrowed judgment from NVIDIA's CMX design decisions once adopted. NVIDIA also provides GPU-accelerated compute libraries (RAPIDS, cuDF) used within other vendors' data pipelines, but these are computation acceleration, not data movement. They make processing faster without providing pipeline orchestration, data lineage, or movement logic. They are assessed at the layers where they functionally operate (compute acceleration at Layer 0, retrieval acceleration at Layer 1B) rather than at Layer 1C.
Moderate for CMX: an architectural decision about KV cache management that affects inference performance and is harder to substitute once adopted. The enterprise inherits NVIDIA's decisions about cache eviction policy, offload thresholds, and storage tier targeting.
The KV cache tiering gap identified in the Azure assessment is relevant here: Azure has no CMX integration. Dell has validated it. HPE is expected. VAST's CNode-X architecture collocates cache and compute, potentially eliminating the need for CMX-style offload. The KV cache management approach varies by vendor: NVIDIA's CMX is one solution, not the only one. Watch-list (pending GA, not scored): NVIDIA CMX (Context Memory Extension, KV-cache offload, BlueField-4), not yet GA. It was NVIDIA’s only Layer 1C component; with it pre-GA, NVIDIA ships no data-movement capability today, so the layer is a gap. Decision authority: nothing ships at this layer, so nobody on NVIDIA's side decides: Absent (gap-layer narrowing, October 4, 2026).
GPU scheduling, quotas, RBAC, fair-share scheduling, utilization optimization
GPU orchestration and workload management platform. Kubernetes-native. Dynamic GPU pooling across hybrid environments. Fractional GPU sharing (the KAI GPU Fractioning Operator). Fair-share scheduling with team-level quotas. Multi-cluster management from a unified control plane. Now part of NVIDIA AI Enterprise ($4,500/GPU/year standalone, included with DGX). Run:ai is the Layer 2A authority that Dell brands as part of AI Factory, HPE brands as part of Private Cloud AI, and VMware integrates through NVIDIA AI Enterprise. NVIDIA open-sourced the platform under Apache 2.0 ("NVIDIA Run:ai Is Fully Open Source"; github.com/dsx-ai-factory/run-ai, release 3.0.20, October 11, 2026), beside KAI Scheduler: open source the enterprise possesses and operates, Retained. The NVIDIA AI Enterprise subscription is support, a price, not a gate. The OEM sells the relationship; the roadmap is NVIDIA's. GPU-level infrastructure (GPU Operator for driver/plugin lifecycle, MIG for hardware partitioning) provides the substrate Run:ai orchestrates: invisible plumbing, not standalone orchestration tools.
Assessment pending
Layer 2A is where NVIDIA's platform ambition creates the most direct tension with its OEM partners. Run:ai is the most capable GPU-specific orchestration platform available: fractional GPU sharing, multi-cluster management, and fair-share scheduling, now open source under Apache 2.0. But Run:ai is NVIDIA's product, not the OEM's. When Dell markets 'AI Factory with NVIDIA,' the GPU scheduling intelligence is Run:ai: NVIDIA's roadmap, on open source the enterprise can run and fork. Dell provides the hardware, the rack integration, and the customer relationship. NVIDIA provides the scheduling brain. If NVIDIA changes Run:ai's architecture, licensing, or feature set, Dell's AI Factory Layer 2A changes with it, without Dell's input. The same dynamic applies to HPE (Private Cloud AI includes NVIDIA AI Enterprise with Run:ai) and VMware (VCF integrates NVIDIA AI Enterprise). Three OEMs, one scheduling authority. The hyperscalers avoid this dependency: AWS built Karpenter, Google built GKE Autopilot + Fluid Compute, Azure contributed DRA to upstream Kubernetes. Each hyperscaler owns its GPU scheduling intelligence. On-prem vendors do not. They consume NVIDIA's. Run:ai is itself open source now, with KAI Scheduler and the KAI GPU Fractioning Operator as its open projects and Kueue and DRA beside them. The enterprise evaluating GPU orchestration choices is evaluating a NVIDIA proprietary vs. open-source trade-off: better capability (Run:ai) vs. more authority (open-source). Capability and deployment are separate readings. The grade states what an architect can deploy on this vendor's paper; it does not assert that a given customer consumes it. This cell inverts the usual shape and is worth reading carefully. Run:ai is most often consumed inside another vendor's stack rather than bought directly, which is why other rows on this instrument record their 2A as Run:ai. Many enterprises never adopt it at all, scheduling GPUs with Slurm or native Kubernetes through the GPU Operator. The capability is strong and NVIDIA's authority over it is real; whether it occupies a given customer's 2A depends on a purchase most of them make through someone else, or do not make.
High. Run:ai's scheduling decisions (which team gets which GPU, how fractional sharing is allocated, when over-quota borrowing is permitted) are NVIDIA's judgment. The enterprise configures policies; NVIDIA's scheduler executes them. If Run:ai makes a scheduling decision that impacts training job completion time or inference latency, that's NVIDIA's borrowed judgment affecting business outcomes. NVIDIA AI Enterprise licensing adds commercial borrowed judgment: the enterprise's production deployment timeline depends on NVIDIA's licensing terms, pricing changes, and certification cycles.
The Run:ai acquisition (2024) is the most significant NVIDIA software acquisition for the 4+1 model. Before Run:ai, NVIDIA provided silicon and libraries. After Run:ai, NVIDIA provides the orchestration plane that sits between the enterprise and its own GPUs. The enterprise doesn't interact with GPUs directly. It interacts through Run:ai's scheduling layer. The open-source Kubernetes GPU scheduling landscape (DRA, Kueue, KAI Scheduler) is evolving rapidly. Microsoft contributed DRA to upstream Kubernetes at KubeCon 2026. NVIDIA's answer to open-source GPU scheduling was to open-source Run:ai itself (Apache 2.0, 2026), which moves the platform from Ceded to Retained on the possess-and-operate line. Re-read October 24, 2026 (Keith): Run:ai is open source under Apache 2.0 ("NVIDIA Run:ai Is Fully Open Source"), so the chip reads Retained. The decision-authority reading (the scheduler decides placement, visible, overridable) is unchanged.
Model serving, agent execution, inference APIs, distributed inference
NIM serves the OpenAI-compatible API, and application opinions built against it (prompts, tool schemas, integration code) lift to vLLM or any compatible endpoint by repointing the client: Delegated on the inference-interface ruling. Free for prototyping on DGX Cloud (build.nvidia.com).
Pre-built, optimized inference containers for 100+ models; production requires an AI Enterprise license. NIM is the inference runtime multiple OEMs and hyperscalers brand into their platforms: AWS Bedrock, Azure Foundry, Dell on PowerEdge. Proprietary containers on an NVIDIA AI Enterprise license with no source; the TensorRT-LLM engine builds, profiles, and NIM Operator configuration the enterprise accumulates don't lift to another runtime. A surface beyond the interface: Ceded to NVIDIA, the SUSE, Dataiku, and WEKA reading.
GA through NIM's OpenAI-compatible API. 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 component above. Added instrument-wide on September 2, 2026 (M4): the seam exists on every runtime that hands control to portable customer code, and a real Retained position is scored, not narrated.
Open-source (Apache 2.0) distributed inference serving framework. GA March 2026. Disaggregated prefill and decode. KV-aware routing to GPUs with best cache match. KVBM for memory management. NIXL for GPU-to-GPU data movement. Grove for scaling. 7x performance boost on Blackwell. Adopted by AWS, Azure, GCP, OCI, CoreWeave, and dozens of inference providers. NVIDIA positions Dynamo as 'the operating system of AI factories.' Open-source but NVIDIA-optimized: runs best on NVIDIA hardware.
End-to-end model lifecycle management: data curation, model customization and evaluation, guardrailing and observability. NeMo Guardrails for content safety. NeMo Evaluator for model assessment. NeMo Data Designer for training data preparation (integrated into VAST's TuningEngine). The model lifecycle stack that operates above inference and below applications.
Programmable content safety framework inline with inference. Controls model output, topic boundaries, and factual grounding during model serving. Deployed as part of NIM containers or standalone. At Layer 2B, Guardrails functions as runtime content filtering: it controls what the model says during inference. The same capability serves a Layer 2C governance function when applied as policy enforcement for agent behavior.
Post-trained on Llama, distilled from DeepSeek-R1. Deployment-ready for AI agents. Available through NIM API (build.nvidia.com) and as downloadable containers. Nemotron models are NVIDIA's answer to the model layer: open models optimized for NVIDIA hardware. Competes with OpenAI, Anthropic, Google, and Meta at the model layer while providing the hardware those competitors run on. Open weights the enterprise runs on any serving stack: Retained, the Mistral open-weight precedent. The model still makes the runtime call inside whatever it powers, which this layer's authority reading carries at the model boundary.
Assessment pending
(GA-gate) NemoClaw/OpenShell, referenced below as part of the stack, is alpha (see watch-list); the strong score rests on NIM and Dynamo (GA). Layer 2B is NVIDIA's deepest software authority and the layer where the platform ambition is most visible. NIM, Dynamo, NeMo, NeMo Guardrails, and NemoClaw/OpenShell constitute the complete inference, model lifecycle, and agent runtime stack. NeMo Guardrails and NemoClaw/OpenShell appear at both Layer 2B and Layer 2C because they serve dual architectural functions. At 2B they are runtime capabilities: content filtering inline with inference, agent execution environment. At 2C they are governance capabilities: policy enforcement for agent behavior, sandbox constraints on agent access. The same code, two architectural purposes. This dual-layer presence is itself evidence of NVIDIA's platform transition: a components company's software stays within one layer; a platform company's software spans layers. The open-source strategy is deliberate: Dynamo (Apache 2.0) and NemoClaw/OpenShell (Apache 2.0) are open-source, meaning the enterprise Retains the code. But both are optimized for NVIDIA hardware and NVIDIA's CUDA ecosystem. Running Dynamo on AMD or Intel GPUs is theoretically possible but practically disadvantaged. The open-source license provides code portability; the hardware optimization provides silicon lock-in. NIM is the more significant authority claim: it's closed-source, NVIDIA-only, and requires an AI Enterprise license for production. The enterprise using NIM to serve models has Ceded inference runtime authority to NVIDIA. The alternative (vLLM, SGLang, or other open-source serving frameworks) is slower but Retained. The Dell assessment's Layer 2B finding applies directly: Dell does not appear to own the core agent runtime, model-serving runtime, guardrail framework, or distributed inference framework. Those are NVIDIA's. This assessment confirms that observation from NVIDIA's perspective. Capability and deployment are separate readings, and this cell inverts the usual shape the same way 2A does. NIM and the surrounding runtime are most often consumed inside another vendor's stack rather than bought directly, which is why other rows on this instrument record their 2B runtime as NVIDIA AI Enterprise. Plenty of enterprises never adopt the NVIDIA runtime at all and serve models on vLLM or SGLang against the same silicon. The capability is strong and the authority over it is real; whether it occupies a given customer's 2B usually depends on a decision made by their platform vendor rather than by them. The Nemotron model strategy is the interesting Layer 3 finding: NVIDIA competes with the AI model providers (OpenAI, Anthropic, Google, Meta) whose models run on NVIDIA hardware. If Nemotron achieves quality parity with proprietary models, enterprises can run inference on NVIDIA hardware with NVIDIA models: a fully vertically integrated stack from silicon to model. No other silicon vendor has this: Intel doesn't have frontier models, AMD doesn't have frontier models, AWS Trainium serves other providers' models. The NIM API funnel is NVIDIA's developer moat: free prototyping creates adoption → adoption creates switching cost → production deployment requires AI Enterprise license on NVIDIA hardware. The funnel is silicon-to-model-to-lock-in.
High for NIM (closed-source, NVIDIA-controlled inference optimization decisions). Low for Dynamo (open-source, enterprise can fork and modify). Moderate for NeMo (model lifecycle decisions, including training data curation, evaluation metrics, guardrail policies, are NVIDIA's defaults that the enterprise inherits unless explicitly overridden). The inference optimization decisions in NIM and TensorRT-LLM directly affect model output quality, latency, and cost. Quantization choices, batching strategies, and KV cache management are NVIDIA's engineering decisions that the enterprise consumes without visibility. If an NIM container produces different outputs than a vLLM deployment of the same model, the enterprise may not know which is 'correct.' Moderate for Nemotron: alignment, training data, and safety decisions are NVIDIA's. The model-to-silicon borrowed judgment is unique to NVIDIA: when the enterprise uses Nemotron on NVIDIA GPUs, both the model and the hardware are NVIDIA's. The enterprise borrows NVIDIA's judgment at every layer of the inference path. No other vendor has this: even Google (Gemini on TPU) separates the model team (DeepMind) from the silicon team.
Dynamo 1.0 GA (March 2026) is NVIDIA's strongest Layer 2B play. Positioning it as 'the operating system of AI factories' is explicitly a platform claim. Combined with Run:ai at Layer 2A and NIM at Layer 2B, NVIDIA controls the infrastructure orchestration, the inference optimization, and the model serving runtime: three layers of the enterprise's AI stack that sit between the hardware (which NVIDIA also provides) and the application (which the enterprise builds). The NemoClaw/OpenShell alpha status is important context: Futurum Research noted that NemoClaw addresses 'the deployment end of the agent trust chain well' but urged enterprises 'not to treat it as a complete governance solution.' Security and accountability need to be embedded throughout the development lifecycle, not just at runtime. This is the gap between NVIDIA's runtime governance (OpenShell) and Microsoft's lifecycle governance (Entra Agent ID + Agent Governance Toolkit). Watch-list (pending GA, not scored): NemoClaw + OpenShell agent runtime: open-source (Apache 2.0), alpha. Described in the gap narrative. The NVIDIA-as-model-provider dynamic creates an unusual competitive position: NVIDIA wants enterprises to adopt Nemotron (NVIDIA model revenue) AND wants enterprises to run OpenAI/Anthropic/Meta models on NVIDIA GPUs (NVIDIA hardware revenue). Both outcomes benefit NVIDIA, but they benefit NVIDIA in different ways. If Nemotron succeeds too well, it reduces the model diversity that drives GPU demand from multiple model providers. Watch-list (not scored): KumoRFM, from the 2026 Kumo AI acquisition, scores here beside Nemotron when NVIDIA documentation sells it as a product. The Hugging Face acquisition is pending close (first half of 2027); the row is re-read at close.
Hands-on builds on real hardware that test where authority actually holds at this layer.
Lab 002 rerun off NVIDIA end to end: the workflow is portable and CUDA is a default, not a requirement; what actually gates the path is who will sell you the silicon, and whether your acceptance gate measures what you think it does.
A smaller model on idle capacity cleared real verifiable work under the same deterministic validator; in 585 scored attempts no validator pass failed the held-out checks.
Fine-tuning captured voice and bounded behavior, not judgment; one paragraph of standing positions in the system prompt beat two fine-tuning rounds.
For a custom model you own, cloud token pricing disappears and becomes a rented floor; against a floor the owned box wins, and the managed path takes the weights.
The managed data plane is cheap and fast; the cost it hides is the chunking judgment it takes from you. Borrow the plumbing, keep your own chunking.
Policy-driven placement and resource coordination — the Autonomy Layer
Assessment pending
Applying the 'Routing Is Not Reasoning' test from the VMware assessment: OpenShell provides runtime sandbox governance: it controls WHAT agents can access (filesystem, network, processes). NeMo Guardrails control WHAT models can say (content filtering, topic boundaries). Neither provides policy-driven decisions about WHERE compute runs relative to data, WHICH model serves WHICH request, or HOW cost/compliance/latency are arbitrated. OpenShell is agent runtime security. NeMo Guardrails is model output safety. Neither is a Reasoning Plane. NVIDIA's Layer 2C gap is structural: NVIDIA does not own storage (Layer 1A), data governance (Purview, Lake Formation, Knowledge Catalog), or enterprise identity (Entra, IAM). A Reasoning Plane needs governance metadata: which data is sensitive, which models are approved, which compliance requirements apply. NVIDIA has no data governance to query because it has no data layer. The consequence: NVIDIA's Layer 2C will always depend on another vendor's governance metadata. OpenShell can enforce sandbox policies, but it cannot make placement decisions informed by data classification, compliance status, or cost targets, because that information lives in Purview, Lake Formation, PolicyEngine, or MetadataIQ, none of which NVIDIA owns. This is the fundamental structural limitation of NVIDIA's platform ambition: NVIDIA can build runtime governance (2B/2C boundary) but cannot build a full Reasoning Plane (2C) because it lacks the data governance foundation (1A) that a Reasoning Plane queries.
Low for OpenShell (open-source, enterprise controls the policies). Low for NeMo Guardrails (configurable by the enterprise). The governance logic is transparent: the enterprise defines what agents can and cannot do. The missing borrowed judgment is the more significant finding: NVIDIA's Layer 2C cannot borrow data governance judgment from itself because it doesn't have a data governance layer. It must borrow from Dell (MetadataIQ), HPE (Data Fabric), VAST (Catalog), AWS (Lake Formation), Google (Knowledge Catalog), or Azure (Purview). NVIDIA's governance is runtime-only; other vendors' governance is data-informed.
The Futurum Research observation is the right framing: OpenShell addresses the 'deployment end of the agent trust chain' but enterprises should not treat it as a complete governance solution. Security and accountability need to be embedded throughout the development lifecycle. Compare to other vendors' Layer 2C: • Microsoft: identity + governance lifecycle (Entra Agent ID + AGT), the broadest governance scope • Google: model-integrated orchestration (Agent Platform), the deepest platform integration • AWS: policy + evaluation + registry (AgentCore), the most modular approach • VAST: data platform governance (PolicyEngine + Polaris), the most data-informed approach • NVIDIA: runtime sandbox (OpenShell), the narrowest scope, addressing only execution-time security NVIDIA's Layer 2C is necessary but not sufficient. It complements other vendors' governance. It doesn't replace it. Instrument note: live Infrastructure-2C (a policy engine deciding at request time where inference runs relative to the data, which model serves the request, and how cost, latency, and compliance are arbitrated) does not ship from any vendor on this instrument. It is recorded here as a universal finding about the market, not as a charge against this vendor. 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.
Hands-on builds on real hardware that test where authority actually holds at this layer.
Open weights on capacity I already carry clear 17 of 22 repairs for nothing, and the gate names the five they miss. Renting more hardware for the rest is slower and dearer than the API. The minimum that finishes the job is a mini model in an agentic harness, at $3.14. Two Opus generations finish the same 22 for four times that.
One control architecture across 70 repairs. Within that single harness a frontier model added nothing as the loop's controller and lifted recovery from 14 to 20 as the worker. The deterministic validator still determines done, and the tier that matters sits in the worker seat, not the control seat.
A smaller model on idle capacity cleared real verifiable work under the same deterministic validator; in 585 scored attempts no validator pass failed the held-out checks.
The control plane held where patterns were owned and encoded, and failed where the model became the author of correctness. The question is who may author the patterns and done-criteria.
About 5% of tasks benefit from same-tier repair; the control point is the deterministic validator plus escalation policy, not the loop.
For a custom model you own, cloud token pricing disappears and becomes a rented floor; against a floor the owned box wins, and the managed path takes the weights.
The managed data plane is cheap and fast; the cost it hides is the chunking judgment it takes from you. Borrow the plumbing, keep your own chunking.
AI-powered business capabilities — business logic, workflow automation
Assessment pending
Gap: the Layer 3 grade rests on first-party business applications the buyer runs, and NVIDIA builds none. Its one former Layer 3 component, the Nemotron open-model family, is a model, and the instrument reads models at 2B (Mistral's open weights, the gpt-oss precedent); Nemotron and the silicon-to-model finding sit there. NVIDIA also provides application enablement that falls below the Layer 3 threshold: Blueprints (pre-built reference patterns for PDF extraction, digital twins, RAG pipelines, AI-Q agent task decomposition, deployed through Dell, HPE, VMware, and hyperscaler marketplaces) and NIM API endpoints (build.nvidia.com: free API access to 100+ models, 1,000 free inference credits, GPU sandbox instances). Blueprints are reference architectures, not applications: the enterprise builds from them, not on them. NIM API is a developer on-ramp and go-to-market funnel, not an application platform. Kumo AI, acquired in 2026, adds KumoRFM, a relational foundation model for predictions over enterprise tables. It is a model for the teams that build predictive applications, not an application, and it is watch-listed at 2B until it ships as a documented product on NVIDIA paper. The pending Hugging Face acquisition (agreed September 3, 2026, expected to close in the first half of 2027) adds no Layer 3 capability either: Hugging Face's own row reads gap here.
None scored, so the reading is Absent: NVIDIA offers nothing at this layer's function, and its Blueprints are reference architectures the enterprise builds from. The model judgment the enterprise borrows through Nemotron is read at 2B.
A first-party business application on NVIDIA paper is the evidence that would move the cell.
GTC 2025, GTC 2026, Dynamo 1.0 GA, NemoClaw/OpenShell announcement, Run:ai acquisition, DGX Cloud, NVIDIA AI Enterprise, NIM GA, analyst coverage, SEC FY2026 annual report Inference-interface reconciliation (July 23, 2026): the completions-interface ruling (OpenAI v1.0) and its Messages-API extension (Anthropic v1.0) applied: model access consumed through a genuine multi-vendor standard inference interface is Delegated; proprietary surfaces beyond the interface remain Ceded. NIM re-chipped Ceded→Delegated (OpenAI-compatible serving; drift vs. the Nutanix row resolved). /reconcile (September 1, 2026): shared 2C findings stated explicitly (live-placement universality). /reconcile (September 1, 2026): the availability-not-occupancy reading applied at 2A: the grade states deployable capability on this vendor's paper and no longer reads as though the vendor's layer is automatically the customer's. /reconcile (September 1, 2026): availability, not occupancy, applied at 2B: the runtime is most often consumed inside another vendor's stack, and the cell no longer reads as though it occupies the customer's layer by default. /reconcile (October 5, 2026): Layer 3 moderate to gap (no first-party business application; a model is not one); Nemotron Open Models moved to 2B as a Retained component with the silicon-to-model and NIM-funnel findings. Acquisitions checked: Kumo AI (closed 2026, a relational foundation model, watch-listed at 2B) and Hugging Face (pending, H1 2027) add no Layer 3 capability. /reconcile (October 5, 2026): Layer 0 runtime rule (ruled September 28 and October 4, 2026). GPU silicon split by adopted runtime: the open-runtime path Retained, the CUDA path Ceded. Grade unchanged. /reconcile (October 5, 2026): NIM column (ruled October 4, 2026: the endpoint in front is Delegated, the NIM containers the enterprise operates are Ceded to NVIDIA). 2B NIM split: the OpenAI-compatible endpoint Delegated, the NIM containers Ceded. 1B NIM Embedding Models Delegated to Ceded on the embeddings carve-out (July 23, 2026), which the chip had missed. Grade unchanged. /reconcile (October 5, 2026): 1C authority column (rulings of September 15 and October 4, 2026). 1C authority vendor / Delegated to Absent: NVIDIA ships nothing at the layer, and tooling the enterprise brings is the enterprise's. Grade and components unchanged. /reconcile (October 5, 2026): authority read against product docs: layer0 visible true; layer2a visible true. Grades and components unchanged. /reconcile (October 5, 2026): Layer 0 authority holds vendor / Ceded on the fabric half (UFM routing), the owned-hardware ruling's vendor half; DGX nodes noted as enterprise-run. Reading unchanged. v1.17 (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. 0A strong, 0B strong, 0C gap; summary edits (summary worksheet, Keith, October 16, 2026). v1.18 (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.19 (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.20 (October 22, 2026, /reconcile): 0B networking chip names ConnectX-8 as a SuperNIC, as NVIDIA does, and the DGX facet records the B300 SuperPOD reference architecture's separate compute, storage and in-band management networks. Found by the 0B fabric research. Grade and authority unchanged. v1.21 (October 23, 2026, /reconcile): the 0A open-runtime chip carries Vera Rubin NVL72 on NVIDIA's product page and datasheet instead of "deploying at hyperscalers," and drops two sweeping claims; DGX Cloud's detail follows NVIDIA's current description (its internal environment, sold to customers by private offer on four marketplaces); the NVIDIA GPU Operator (Retained, Apache 2.0) and vGPU software (Delegated across hypervisors) come in as accelerator-enablement chips; the gap's market-position line comes out. Found by the 0A compute research. Grade and authority unchanged. v1.22 (October 23, 2026, /reconcile): 0A splits DGX Spark and DGX Station (Retained, deskside) from DGX SuperPOD (Ceded, integrated system). The deskside systems read like Dell's Pro Max GB300, Lenovo's ThinkStation PGX and Supermicro's Super AI Station on the same superchips, since two sellers of one design read the same. Found by 0A peer calibration; ruled October 23, 2026 (Keith), with the integrated-system rule narrowed to rack-scale DGX. Grade and cell authority unchanged. v1.23 (October 23, 2026, /reconcile): the 0A deskside chip is DGX Spark alone. DGX Station is ordered through partners, so NVIDIA doesn't sell it; it reads on the OEM rows that do, Dell's Pro Max GB300 among them. Found by the Layer 0 sniff read; ruled October 23, 2026 (Keith). Grade and cell authority unchanged. v1.24 (October 23, 2026, /reconcile): 0B: One chip carried NVLink, NICs, DPUs and the switches (which sit on their own chip). 0B: InfiniBand and Ethernet switch lines were one chip. Found by the Layer 0 data pass after the sniff read. Grade and cell authority unchanged. v1.25 (October 23, 2026, Layer 1 calibration): NeMo Retriever splits into its standard endpoints and the operated microservices. Grade unchanged. v1.26 (October 24, 2026, /reconcile): 1B NeMo Retriever chip corrected to the embedding and rerank microservices: the NeMo Retriever Library and the RAG and AI-Q Blueprints sit outside NVIDIA AI Enterprise support. Found in the 1B dependency audit under the headend standard. Grade unchanged. v1.27 (October 24, 2026, /reconcile): GA evidence recorded on 4 of 4 Layer 1B chips under the GA evidence table. Grade unchanged. v1.28 (October 24, 2026, /reconcile): Layer 1B GA evidence migrated to the GA evidence table version 2. Grade unchanged. v1.29 (October 24, 2026, /reconcile): GA evidence recorded on 8 of 8 Layer 0B chips under the GA evidence table version 2. Grade unchanged. v1.30 (October 24, 2026, /reconcile): GA evidence recorded on 10 of 10 Layer 0A chips under the GA evidence table version 2. Grade unchanged. v1.31 (October 24, 2026, /reconcile): GA evidence recorded on 1 of 1 Layer 2A chips under the GA evidence table version 2. Grade unchanged. v1.32 (October 24, 2026, /reconcile): GA evidence recorded on 7 of 7 Layer 2B chips under the GA evidence table version 2. Grade unchanged. v1.33 (October 24, 2026, /reconcile): 2A Run:ai reads Retained: NVIDIA open-sourced it under Apache 2.0. Grade unchanged. v1.34 (October 27, 2026): each component now carries a durable offering id; nothing else changed.