VAST is the most architecturally distinct vendor in this assessment series because it deliberately collapses traditionally separate infrastructure layers into a single platform. The VAST AI Operating System unifies storage (DataStore), metadata and vector database (DataBase + Catalog), global namespace (DataSpace), serverless compute (DataEngine), retrieval (InsightEngine), agent runtime (AgentEngine), governance (PolicyEngine), and model lifecycle (TuningEngine) under one authority boundary. Where Dell assembles 5–7 partner technologies to span Layers 1A through 2B, VAST provides a vertically integrated alternative with no inter-layer seams.
VAST is making the most aggressive middle-out bid for Layer 2C of any infrastructure vendor: Polaris (placement abstraction) and DataSpace (namespace) ship today, with PolicyEngine (inline policy enforcement) and TuningEngine designed to close the loop. But the policy-reasoning engine is announced for End of 2026, not shipping - today VAST ships placement abstraction without the reasoning plane, which is routing, not reasoning. So for an architect building now, VAST Layer 2C is a gap with a credible, dated roadmap: the clearest building-toward-it story in the series, not yet a deployable control plane.
The DAPM trade-off is stark: VAST eliminates seams by collapsing authority into one vendor. The enterprise gains architectural coherence and eliminates integration risk. But the entire data plane, retrieval plane, agent runtime, AND emerging governance plane become a single Ceded dependency. If you run VAST, you run VAST for everything. There is no substitutability at any individual layer.
The $30B valuation, $4B+ in bookings, $500M+ CARR, and 1,000+ enterprise deployments validate market traction. The CoreWeave anchor ($1.17B commercial agreement) validates hyperscale credibility. The CNode-X partnership with NVIDIA (GPU-accelerated servers through Cisco and Supermicro OEMs) validates compute integration. But the product-market fit question for the 4+1 model is whether enterprises will accept total data-plane vendor dependency in exchange for architectural simplicity.
VAST is building the thing the 4+1 model says is missing. Whether the enterprise will buy it from a storage vendor is the open question.
Layer-by-layer status: Layer 0A (No GA Compute on VAST's Paper; CNode-X Watch-Listed), Layer 0B (VAST-Supplied Cluster Switches for the NVMe-oF Back End), Layer 0C (DASE: Shared-Everything Flash Over NVMe-oF, on VAST Nodes, EBoxes or Cloud Instances), Layer 1A (VAST Catalog, DataBase and Element-Level Security on One Element Store), Layer 1B (VAST Strength), Layer 1C (VAST Strength), Layer 2A (Partial), Layer 2B (VAST Strength: AgentEngine (GA)), Layer 2C (Gap: placement abstraction, not a reasoning plane), Layer 3 (+1) (No Applications on VAST Paper; Partnerships Only).
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.
VAST is the most architecturally distinct vendor in this assessment series because it deliberately collapses traditionally separate infrastructure layers into a single platform. The VAST AI Operating System unifies storage (DataStore), metadata and vector database (DataBase + Catalog), global namespace (DataSpace), serverless compute (DataEngine), retrieval (InsightEngine), agent runtime (AgentEngine), governance (PolicyEngine), and model lifecycle (TuningEngine) under one authority boundary. Where Dell assembles 5–7 partner technologies to span Layers 1A through 2B, VAST provides a vertically integrated alternative with no inter-layer seams.
VAST is making the most aggressive middle-out bid for Layer 2C of any infrastructure vendor: Polaris (placement abstraction) and DataSpace (namespace) ship today, with PolicyEngine (inline policy enforcement) and TuningEngine designed to close the loop. But the policy-reasoning engine is announced for End of 2026, not shipping - today VAST ships placement abstraction without the reasoning plane, which is routing, not reasoning. So for an architect building now, VAST Layer 2C is a gap with a credible, dated roadmap: the clearest building-toward-it story in the series, not yet a deployable control plane.
The DAPM trade-off is stark: VAST eliminates seams by collapsing authority into one vendor. The enterprise gains architectural coherence and eliminates integration risk. But the entire data plane, retrieval plane, agent runtime, AND emerging governance plane become a single Ceded dependency. If you run VAST, you run VAST for everything. There is no substitutability at any individual layer.
The $30B valuation, $4B+ in bookings, $500M+ CARR, and 1,000+ enterprise deployments validate market traction. The CoreWeave anchor ($1.17B commercial agreement) validates hyperscale credibility. The CNode-X partnership with NVIDIA (GPU-accelerated servers through Cisco and Supermicro OEMs) validates compute integration. But the product-market fit question for the 4+1 model is whether enterprises will accept total data-plane vendor dependency in exchange for architectural simplicity.
VAST is building the thing the 4+1 model says is missing. Whether the enterprise will buy it from a storage vendor is the open question.
CPUs, accelerators, servers, integrated systems, OS and hypervisor, physical plant
GPUs for vector search, data manipulation, inference and analytics inside the VAST platform, unscored until CNode-X is GA.
VAST sells no GA compute. CNode-X, the configuration with RTX PRO 6000 Blackwell GPUs inside the data platform, has no GA document on VAST's docs portal. VAST's own pages describe it as forward-looking, and Supermicro's release says launching. The CNodes in a cluster run VAST's storage software and read at 0C. Calibration: WEKA, DDN, NetApp and Everpure read gap here too; Dell and HPE sell storage and compute together.
Nothing offered and nothing inherited from VAST at 0A today: Absent.
Watch-listed under the GA gate (/reconcile item 5, October 16, 2026): CNode-X and its 0A GPU facet. Named, not scored: HPE and Lenovo CNode-X configurations, 'in progress'.
Interconnects, switching and routing, network virtualization
The switching and transport half of the NVMe-over-Fabrics Network chip: the RDMA NICs, DPUs and switches connecting CNodes to DNodes. Not scored within this chip under the GA evidence table: ConnectX-8 (VAST's KB documents ConnectX-7 and BlueField-3 hardware but no ConnectX-8 part on VAST's paper.).
MLAG switch pairs for the NVMe-oF back end, bought through VAST supply channels and covered by Gemini support
RDMA adapters in every CNode and DPUs for storage-side offload: the physical path DASE runs on.
The SN-series switches VAST supplies run NVIDIA Spectrum silicon on Cumulus.
VAST sells the back-end fabric its clusters need. MLAG switch pairs for the NVMe-oF back end ship on VAST SKUs: NVIDIA SN3700, SN4600, SN5400 and SN5610 on Cumulus, and Arista 7050DX4 and 7060DX5 on EOS. They're bought through VAST supply channels and covered by Gemini support. ConnectX-7/8 NICs and BlueField-3 DPUs carry the RDMA path from every CNode to every SSD, the physical layer behind DASE's shared-everything model. VAST also supports tested customer-supplied switches from Arista, Cisco, Aruba, NVIDIA and Juniper. The architect's concern is reach. It's a storage back-end interconnect only, not an AI fabric. Calibration: NetApp reads moderate on the same shape; WEKA, DDN and Everpure read gap; Dell reads strong on an AI fabric it sells.
Ceded where the grade rests. The fabric's routing and congestion control are the NVIDIA switches' and ConnectX's own, and the enterprise configures the fabric but doesn't override per-flow decisions: vendor decides, visible, not overridable, Ceded. Portability: NVIDIA SN-series on Cumulus and Arista on EOS read Ceded to their owners through VAST's paper under channel substitution, the NetApp reading; a SONiC path would read Delegated.
Out of the Back-End RDMA Fabric chip under the GA evidence table (October 24, 2026): ConnectX-8 (VAST's KB documents ConnectX-7 and BlueField-3 hardware but no ConnectX-8 part on VAST's paper.).
Arrays, storage servers and software, front-end protocols: where the data sits
Disaggregated Shared-Everything: separates stateless compute (CNodes) from persistent storage (DNodes/DBoxes) over an NVMe-over-Fabrics network. Every CNode mounts every SSD in the cluster at boot time: no node ‘owns’ any particular data. Eliminates east-west chatter between nodes, shard coordination, and per-node metadata bottlenecks. ACID transactional semantics via global Element Store. Scales linearly from TB to EB. This is VAST’s core IP and the foundation for every layer above. Proprietary VAST architecture: opinions captive, no open exit.
Process all user requests: file/object serving (NFS, S3), database queries, erasure coding, data reduction, vector search. Fully stateless, containerized VAST software. Add CNodes to scale performance independently from capacity. Can run on dedicated servers or as containers within EBoxes. ConnectX-7/8 network adapters for 200GbE+ RDMA connectivity. Proprietary VAST architecture: opinions captive, no open exit.
NVMe-oF storage shelves connecting SCM and hyperscale flash SSDs to the NVMe fabric. DBoxes are fully redundant (no single point of failure): redundant DNodes, NICs, fans, power. DNode containers route NVMe commands between SSDs and CNodes. Add DBoxes to scale capacity independently from performance. Proprietary VAST architecture: opinions captive, no open exit.
Converged form factor: runs CNode + DNode containers on the same industry-standard x86 server. Introduced in VAST 5.2. Each EBox runs three containers (1 CNode, 2 redundant DNodes). Enables deployment on hyperscaler server configs, cloud VM instances, and OEM servers (Cisco, Supermicro). The CNode in an EBox does NOT own the SSDs in that EBox: all SSDs are equally accessible by all CNodes across the cluster. Proprietary VAST architecture: opinions captive, no open exit.
High-bandwidth RDMA networking (200GbE+ via NVIDIA ConnectX-7/8) connecting all CNodes to all DNodes/SSDs. BlueField-3 DPUs + Spectrum-X switches for zero-copy data paths. This is the fabric that makes ‘shared everything’ possible: every compute node sees the entire storage namespace over NVMe-oF.
High-performance file, object, and block storage on all-flash NVMe. Universal Storage heritage: no separate engines for file vs. object vs. block. NFS v3/v4.1, SMB 2.1/3.1, S3 REST API. An Element is not an NFS file or an S3 object. It’s a superset of all of them. Write a file as an object, read it as SMB, read it over NFS: same underlying data, no copies, no translation layers. Protocol-independent storage with protocol-dependent access.
Buckets and objects behind the S3 API, which independent stores implement. VAST documents its S3 service as supporting a subset of the AWS S3 API's actions, with signature versions 2 and 4. Delegated, the StorageGRID, ObjectScale and IBM Cloud Object Storage reading: object opinions lift to another S3 store within the supported subset. The Element Store behind it stays in the DataStore chip.
The storage half of the Element Store: the namespace, the key-value engine, and its snapshots, clones and replication with ACID semantics.
The protection half of VAST's built-in security: inline encryption at rest and immutable snapshots. Ceded, as the chip reads.
VAST cluster software on cloud instances, single-instance or clustered (eight z3-highmem-88 nodes minimum on GCP), erasure coded across at least eight failure domains
NFS v3/v4.1 and SMB 2.1/3.1, 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. The Element Store behind them stays in the DataStore chip, Ceded, as behind the S3 door.
Every CNode reaches the SSDs through ConnectX-7/8 adapters, scored at 0B. The storage software runs without GPUs on standard CNodes and EBoxes.
VAST designs the storage architecture and the nodes it runs on. DASE (Disaggregated Shared-Everything) separates stateless CNodes from persistent DNodes and DBoxes over an NVMe-over-Fabrics network. Every CNode mounts every SSD in the cluster at boot, so no node owns any particular data. EBox runs CNode and DNode containers on one industry-standard x86 server, and VAST on Cloud deploys the cluster software into the enterprise's GCP project or AWS account. DataStore serves file, object and block from one Element Store: write a file as an object, read it over NFS, with no copies. Snapshots, clones, replication, encryption at rest and immutable snapshots sit in the same engine. The buyer gets one namespace with ACID semantics from terabytes to exabytes. The architect's concern is that every opinion here is VAST's, with no open exit. Calibration: WEKA, DDN and NetApp read strong on the same function.
Ceded where the grade rests. DASE and the Element Store place, protect and reduce data across every SSD in the cluster with no per-object placement the enterprise reverses: vendor decides, visible, not overridable, Ceded. Portability: DASE, the nodes, EBox, DataStore and VAST on Cloud read Ceded; the NVMe-oF protocol and the S3 interface read Delegated.
Named, not scored: the Gemini procurement model (certified hardware supplied at cost, VAST software as a capacity-based subscription, compatibility guaranteed for up to 10 years). The instances under VAST on Cloud read on the clouds' rows. Named, not scored (October 23, 2026): block volumes presented to Linux and ESXi hosts over NVMe/TCP, documented in VAST's knowledge base without a GA statement; the door takes NVMe/TCP when a release note shows GA.
The data itself, organized and governed: the Governance Catalog that Layer 2C queries
Purpose-built database for AI: structured data (EDW tables), contextual metadata, vectors for similarity search, real-time streams (Kafka-compatible), catalogs, and logs. Vectors live alongside structured records in a single query path. Supports open formats like Parquet. Handles tables alongside unstructured data in the same transactional system.
Indexes metadata attributes of all data on cluster: files, objects, directories. Queryable via Web UI, VMS API, CLI, or connected third-party query engines. Built from snapshots: administrators choose S3 tag keys and user-metadata keys to index, and each becomes its own column (tag_<key>), with all tags also held in user_tags. That carries classification the enterprise applies as queryable fields, scoped per tenant. The discovery surface that downstream engines (InsightEngine, PolicyEngine) consume.
Low-level key-value store on B-tree data structure underlying all services. Organizes physical storage into a global namespace holding Elements (files/objects, tables, block volumes/LUNs). Every Element is automatically enriched with metadata, security data, and data reduction data. Provides Element-level access control, encryption, snapshots, clones, and replication. ACID transactional semantics with decentralized locks at file/object/table level. No eventual-consistency pitfalls: if an update is committed, subsequent queries see it.
Inline encryption (at rest and in transit). Immutable snapshots (critical for ransomware recovery and audit trails). MFA. Granular access control at Element level. U.S. Government STIG-aligned security configuration. HIPAA, SOC 2, GDPR-ready compliance posture. CrowdStrike integration monitors data access, admin activity, and workload behavior continuously: security embedded at the data layer, not overlaid. Security governance follows data end-to-end: access controls on source files propagate automatically through embeddings to inference outputs. Not scored within this chip under the GA evidence table: MFA ("VAST VMS supports Single Sign-On (SSO) authentication using SAML-based Identity Providers (IdP).").
GPU-accelerated vector indexing and search. Integrated directly into VAST DataBase on CNode-X rather than as an external accelerator. Enhances performance but is not required for core storage or database operations: VAST DataStore/DataBase run without GPUs on standard CNodes/EBoxes.
VAST’s 1A is the part of the platform that knows what the data is and who may reach it. The Catalog, DataBase and Element-level security run on the same Element Store. The Catalog is built from snapshots, and the S3 tags and user-metadata keys an administrator selects each become their own column, queryable through the API, the CLI and third-party engines. That carries the enterprise’s classification as fields a reasoning plane can filter on. The PolicyEngine reads the metadata the platform manages, with no API boundary between where the data lives and where governance decisions are made. Access controls on source files propagate through embeddings to inference outputs. DataStore, the storage engine, encryption and immutable snapshots hold and protect the bytes, 0C functions. The architect’s concern is coupling: choosing VAST for 1A also chooses VAST for 1B and 1C. Calibration: NetApp reads strong on sensitivity inferred per file; WEKA and Dell read moderate on metadata-only indexes.
The tags are the enterprise’s, and the Catalog and Element-level access control execute what it configured, without inference: code decides, visible, overridable, Retained. Portability: the Catalog, DataBase and Element Store are VAST’s alone, Ceded.
Confidence: the Catalog’s classification is the tags the enterprise applies, indexed per snapshot, so it’s as current as the last snapshot. The source chip’s ‘automated classification based on multi-protocol access patterns’ isn’t in the docs and is corrected at migration. Out of the Security & Compliance chip under the GA evidence table (October 24, 2026): MFA ("VAST VMS supports Single Sign-On (SSO) authentication using SAML-based Identity Providers (IdP).").
Low-latency retrieval for RAG — vector/hybrid search, context windows
Framework for building, managing, and automating real-time AI pipelines. Built on DataEngine using event-driven triggers and serverless functions. Processes data the moment it lands: automated chunking, embedding (via NVIDIA NIM), and storage in DataBase’s native vector store. Eliminates traditional batch processing delays: near-instant availability for AI retrieval and inference. Described as the first solution to securely ingest, process, and retrieve all enterprise data (files, objects, tables, streams) in real time. Model agnostic: compatible with any model using the OpenAI API spec. Generally available: VAST's October 1, 2024 release committed InsightEngine to general availability "in early 2025," and its March 18, 2025 GTC release "announced the availability of VAST InsightEngine," starting on NVIDIA DGX systems: an availability announcement that fulfills a dated GA commitment.
Built directly into VAST DataBase on DASE architecture. No sharding, no memory-bound indexes. Scales linearly by adding stateless compute nodes: throughput grows without data reorganization. Vectors, metadata, and raw content live side-by-side in the Element Store. Single query path for vector search + SQL filters + metadata predicates + joins. A video RAG workflow can retrieve semantically relevant clips while filtering by time range, camera ID, location, or policy, in a single execution path. Scales from millions to trillions of vectors with consistent performance.
InsightEngine ties the permissions of vector database rows to the permissions of source data. RAG requests only return embeddings and chunks for data the requesting user is authorized to access. This is not a bolt-on ACL check. It’s structural because vectors inherit the security model of their source Elements. Access controls propagate from source files through embeddings to inference outputs.
Ingests data from enterprise systems (Google Drive, Jira, Confluence, S3 buckets, file systems) while preserving identity and access semantics. The answer to ‘what about my non-VAST data?’: brings external enterprise data into the VAST namespace with governance intact. Maintains durable searchable index and triggers enrichment pipelines automatically on ingestion.
InsightEngine triggers NVIDIA NIM embedding agents as data is written. Embeddings stored in DataBase within milliseconds. NIM provides the embedding intelligence; VAST provides the pipeline automation and storage. Model agnostic: NIM is the default but any OpenAI-compatible model works.
GPU-accelerated vector indexing and search integrated into DataBase via CNode-X. Enhances search speed but the retrieval logic, permission model, and pipeline orchestration are all VAST’s.
Layer 1B is where the architectural difference between VAST and Dell is sharpest, and where the 4+1 model’s layer boundaries are most challenged. Dell’s Layer 1B is a three-party dependency: Dell (PowerScale/ObjectScale storage + MetadataIQ metadata), Elastic (Elasticsearch 9.4 search intelligence), and NVIDIA (cuVS acceleration). Three authority boundaries, three integration seams, three vendors to coordinate for a single retrieval pipeline. VAST’s Layer 1B is a single-authority system: InsightEngine (pipeline), Vector Search (retrieval), DataBase (vector + structured storage), and Catalog (discovery): all VAST IP running on the same Element Store. NVIDIA provides embedding models (NIM) and search acceleration (cuVS) but the retrieval logic, permission propagation, and pipeline orchestration are entirely VAST’s. The ‘data decay’ concept from VAST’s engineering is relevant to the 4+1 model: the gap between what the data IS and what the system BELIEVES the data to be widens over time in batch-indexed systems. InsightEngine addresses this by triggering embedding generation the moment new data is written: embeddings are always current with source data. Dell’s incremental indexing (ingesting only updated files) addresses the same problem but across system boundaries: MetadataIQ indexes PowerScale/ObjectScale, then the Data Search Engine re-indexes based on metadata changes. VAST’s approach is structurally tighter because the trigger, the embedding, and the vector storage share the same platform. The permission-aware retrieval is the most significant security finding at Layer 1B. Vector database rows inherit permissions from source data Elements. RAG queries only return authorized content. This is structural security (same Element Store, same permission model) rather than an overlay check. Dell’s retrieval through Elastic does not natively propagate PowerScale/ObjectScale permissions into search results. That’s a separate integration concern. SyncEngine’s enterprise data ingestion (Google Drive, Jira, Confluence) with preserved identity and access semantics is VAST’s answer to the heterogeneous enterprise. But it’s also an honest constraint: enterprise data that doesn’t enter the VAST namespace isn’t retrievable through InsightEngine. Dell’s Elastic-based search can potentially index data from more sources without requiring ingestion into Dell storage. The 4+1 Layer 1B question: does VAST expose retrieval quality observability (recall@k, latency percentiles, cache hit rates) that a Layer 2C could use for placement decisions? VAST’s integrated architecture makes this more feasible than Dell’s (InsightEngine and PolicyEngine share the same platform), but published materials don’t detail retrieval quality metrics as a first-class observable. The pipeline automation and real-time embedding are well documented; the retrieval quality feedback loop is not.
Low. VAST owns the retrieval logic (InsightEngine + Vector Search), the storage substrate (DataStore + Element Store), the metadata catalog (Catalog + DataBase), and the permission model (Element-level security propagated to vector rows). NVIDIA provides embedding models (NIM) and search acceleration (cuVS) but neither is required for the core retrieval function to work: InsightEngine is model agnostic and Vector Search runs on standard CNodes without GPU acceleration. Compare to Dell’s Layer 1B: Dell’s retrieval quality depends on Elastic (search intelligence), NVIDIA (acceleration), and Dell (storage + metadata). If Elastic changes Elasticsearch licensing or features, Dell’s retrieval story changes. VAST has no equivalent third-party dependency at Layer 1B. The DAPM classification is Ceded to VAST: the enterprise doesn’t own the retrieval engine. But the authority is unified in one vendor rather than split across three. For the enterprise architect, this means one vendor relationship to manage for retrieval instead of three, but total dependency on that one vendor.
The single-query-path architecture (vector search + SQL + metadata predicates + joins in one execution path) remains the most significant Layer 1B capability in this assessment series. No other vendor provides this without stitching together separate systems. The model-agnostic design is worth emphasizing: InsightEngine works with NVIDIA NIM by default but supports any model compatible with the OpenAI API spec. This means VAST’s Layer 1B retrieval pipeline is not locked to NVIDIA’s embedding models, unlike the Layer 2B runtime where NemoClaw/OpenShell creates a stronger NVIDIA dependency in Dell’s stack. The real-time embedding trigger (process data the moment it lands) vs. Dell’s incremental indexing (index only updated files) represents two approaches to the data currency problem. VAST’s is architecturally tighter but also more compute-intensive: every write triggers an embedding pipeline. Dell’s is more conservative on compute but introduces metadata lag. For agentic AI workloads where agents make decisions based on current data, VAST’s approach is architecturally more appropriate. For cost-constrained environments where batch indexing is acceptable, Dell’s approach is more efficient. VAST Catalog "indexes metadata attributes of all data on the cluster" (VAST knowledge base) and is scored at 1A as a catalog; its docs don't describe it as a retrieval surface, so it isn't scored at 1B. Re-ruled October 24, 2026 (Keith): strong restored the same day it moved to moderate. InsightEngine's GA evidence is VAST's own: VAST's October 1, 2024 release committed InsightEngine to general availability "in early 2025," and its March 18, 2025 GTC release "announced the availability of VAST InsightEngine," starting on NVIDIA DGX systems: an availability announcement that fulfills a dated GA commitment, and Cisco lists it on its price list with Cisco support. A product guide in the knowledge base isn't required on top of a vendor's GA announcement.
Move/transform data — ETL/ELT, lineage, cost-aware movement, KV cache tiering
Serverless compute layer executing containerized functions, triggers, and analytical engines directly on CNodes. Three core execution modes: (1) Event Triggers via Kafka-compatible Event Broker, (2) Serverless Functions as lightweight Python in stateless containers, (3) Containerized Engines for native VAST and partner workloads. Functions, events, and pipelines defined as Kubernetes custom resources. Completely event-driven, unlike centralized orchestrators (Airflow, Slurm) that poll resources, DataEngine reacts to events at any scale without bottlenecks. Co-located with data: reduces latency, simplifies management, improves security.
Scalable data discovery and migration service within DataEngine. Indexes and synchronizes data from external sources (S3 buckets, file systems, SaaS platforms like Google Drive, Jira, Confluence) into the DataSpace. Maintains durable searchable index. Triggers enrichment pipelines automatically as new data is onboarded. Preserves identity and access semantics from source systems.
Native Kafka-compatible streaming ingestion built into the platform (not an external dependency). Stores message topics as VAST Tables for global ordering and real-time SQL querying of live streams. Events are immediately accessible as tables in the DataBase. Detects S3 object creation, tagging, and deletion events and triggers downstream workflows. Decoupled design: functions are never hardwired to data sources: the broker ensures events flow to the right consumer. The Kafka protocol surface in front of it is its own chip.
Command-line interface (vastde) for managing functions, pipelines, triggers, compute clusters, container registries. Python SDK with DataEngine context object for function development. Multiple output formats (human-readable, JSON, YAML), dry-run mode, integrated monitoring with built-in access to logs and traces. Low-code interface also available for non-developers.
The Kafka protocol has independent implementations: code and definitions written to it move to another compatible implementation within the features both support, the data moves by export, replication or rewrite, and the provider's control-plane configuration and operational state don't lift. Delegated. Standard producer and consumer clients within VAST's documented Kafka subset re-point to another Kafka; transactions, idempotent producers, wire compression and offset replication aren't supported, and topics, offsets and broker configuration don't lift. The service behind it is its own chip, Ceded.
GPU-accelerated data manipulation for pipeline processing. Integrated into DataEngine on CNode-X configurations. Accelerates the transformation and enrichment stages of data pipelines.
CNode-X integrates NVIDIA libraries directly into DataEngine services. 44% faster queries, 80% lower costs per VAST claims. GPU acceleration is additive: DataEngine runs on standard CNodes without GPUs; CNode-X adds performance.
Embedding model execution triggered by DataEngine events. NIM provides the embedding intelligence for the InsightEngine pipeline stage. Model agnostic: any OpenAI API-compatible model works.
(GA-gate) TuningEngine in the lifecycle span below is End of 2026 (see watch-list); the layer strength is the shipping DataEngine, SyncEngine, and Event Broker. VAST’s DataEngine is the most architecturally integrated Layer 1C in this assessment series. The gap analysis requires comparing three dimensions: orchestration model, data movement, and lifecycle completeness. Orchestration model: DataEngine is completely event-driven using Kubernetes custom resources. Dell’s Dataloop is a no-code/low-code engine acquired from a startup. Apache Airflow and Slurm (common alternatives) use centralized orchestrators that poll resources. DataEngine’s event-driven model avoids the scaling bottlenecks of centralized orchestration: it reacts to events rather than scheduling them. This is a meaningful architectural advantage for continuous AI pipelines where data flows never stop. Data movement: DataEngine executes co-located with data on CNodes. Dell’s Dataloop orchestrates across API boundaries between separate storage (PowerScale), search (Elastic), and compute (NVIDIA) systems. The practical difference: VAST’s pipelines don’t move data between systems because storage and compute share the same platform. Dell’s pipelines necessarily move data between PowerScale/ObjectScale and the GPU cluster. Dell’s KV Cache offload (NVIDIA CMX, 19x TTFT improvement) is a sophisticated answer to this data movement problem, but it’s solving a problem that VAST’s architecture doesn’t have. Lifecycle completeness: DataEngine + SyncEngine + Event Broker + InsightEngine + AgentEngine + TuningEngine spans from data ingestion through embedding through agent execution through model improvement. Dell spans from data orchestration (Dataloop) through search (Elastic) through analytics (Starburst), but the agent runtime (NemoClaw) and model lifecycle are separate NVIDIA-owned layers. VAST’s lifecycle is more complete but less proven. Dell’s lifecycle has more mature individual components but more seams. The composability architecture is worth noting for the 4+1 model: VAST’s layers (SyncEngine → DataEngine → InsightEngine → DataBase → AgentEngine) compose as pipeline stages within a single platform. The 4+1 model defines these as separate layers (1A, 1B, 1C, 2B). VAST’s architecture challenges the layer separation by making the boundaries internal to one platform rather than external between systems. The layers still exist functionally, but the authority boundaries don’t: VAST owns all of them.
Low. DataEngine, SyncEngine, Event Broker, composability architecture, and the DataEngine CLI/SDK are all VAST IP. TuningEngine (end of 2026) will be VAST IP. NVIDIA provides GPU acceleration (cuDF, CUDA, NIM) but the orchestration logic, event processing, pipeline management, and lifecycle coordination are entirely VAST’s. Compare to Dell’s Layer 1C: Dell owns the Dataloop orchestration engine (Retained, its strongest software move) but depends on NVIDIA for acceleration (cuDF, CMX for KV cache), Starburst for analytics, and NVIDIA Blueprints/NIMs for pipeline templates. Dell’s Layer 1C has four authority boundaries: Dell (Dataloop), NVIDIA (acceleration + templates), Starburst (analytics), and the customer (pipeline configuration). VAST’s Layer 1C has one: VAST. The Kubernetes foundation is a shared dependency: both Dell and VAST depend on K8s. But VAST embeds K8s custom resources into its platform (functions, events, pipelines as CRDs), while Dell depends on external K8s distributions (Red Hat OpenShift AI, Canonical Ubuntu). VAST’s K8s dependency is internal; Dell’s is external. Decision authority reads code / Retained under the override rule (ratified September 4, 2026): DataEngine executes the functions, pipelines, and triggers the enterprise writes through the CLI and SDK and exercises no judgment about what moves or how it's transformed; where that execution lands on CNodes is a 2A fact. Portability stays Ceded, because the functions run nowhere else.
The DataEngine CLI (vastde) and Python SDK represent a developer experience that Dell’s Dataloop doesn’t yet match in published documentation. The CLI manages functions, pipelines, triggers, compute clusters, and container registries with dry-run mode and integrated observability. Dell’s Dataloop is positioned as no-code/low-code, targeting data engineers. VAST’s DataEngine targets both low-code users and developers/MLOps engineers with full Python SDK access. Different audience emphasis. The built-in observability (logs, traces within the same UI, without external Grafana or tracing infrastructure) is an operational differentiator. Dell’s observability for data pipelines depends on partner tools and external monitoring stacks. The TuningEngine + PolicyEngine combination represents VAST’s ‘thinking machine’ vision: systems that observe, reason, act, evaluate, and improve automatically. This is the most ambitious lifecycle claim from any vendor in this assessment series. Dell’s equivalent would require assembling Dataloop (orchestration) + NVIDIA NeMo (model training) + NemoClaw (agent execution) + manual feedback loops: four systems from three vendors with no automated improvement loop. Watch-list (pending GA, not scored): VAST TuningEngine: model-tuning automation, End of 2026. 1C strength stands on DataEngine/SyncEngine/Event Broker (GA). The composability narrative describes VAST's engines working together; each is its own chip, so the narrative isn't scored separately at 1C.
GPU scheduling, quotas, RBAC, fair-share scheduling, utilization optimization
Global control plane purpose-built for AI data infrastructure spanning public cloud, neocloud, and on-prem. Kubernetes-based architecture with lightweight agent on every VAST node. Intent-driven: administrators define desired state, Polaris coordinates cloud-native services to achieve and maintain it. Automates provisioning, cloud marketplace integration (subscription/entitlement), centralized upgrade orchestration, expansion, and node replacement. Multi-cluster: converts distributed infrastructure into a single operational platform. Available as VAST-managed, partner-managed, or customer-managed.
Enterprise identity integration, role-based access control, and audit logging. Cloud-style operational consistency across hybrid and multicloud environments. Supports sovereign deployments. Multi-tenant by design.
Built-in scheduler and cost-optimizer within DataEngine. Deploys serverless functions on CPU, GPU, and DPU architectures. Manages function lifecycle, container orchestration, and resource allocation. Event-driven scheduling rather than centralized job queuing.
Polaris abstracts INFRASTRUCTURE location (where clusters are deployed and maintained). DataSpace abstracts DATA location (how data is presented across locations via global namespace). Together they provide the ‘where should this run relative to this data’ coordination that is a prerequisite for Layer 2C.
GPU lifecycle management for containerized VAST services running on CNode-X. Manages driver installation, device plugins, monitoring for the GPUs embedded in the data platform.
CNode-X GPUs accelerate DATA PLATFORM services (vectorization, SQL via Sirius/cuDF, vector search via cuVS, inference within InsightEngine). They are NOT general-purpose GPU compute for external training/inference workloads. VAST does not provide Run:ai-equivalent fair-share GPU scheduling because the use case is different: GPU resources serve the platform’s own services, not multi-tenant external workloads competing for GPU time.
Layer 2A is where the architectural models diverge most sharply between Dell and VAST, and where the 4+1 model’s layer definitions need careful application. Dell’s Layer 2A problem: GPU-aware workload scheduling for multi-tenant inference and training. Multiple teams compete for scarce GPU resources. Run:ai provides fair-share scheduling, quotas, and RBAC. Dell has no proprietary capability here. VAST’s Layer 2A reality: GPU resources in CNode-X serve the data platform’s own services (vector search, SQL acceleration, embedding generation, data pipeline processing). These are not multi-tenant external workloads competing for GPU time. They are platform services running on platform-embedded GPUs. The scheduling question is different: VAST’s DataEngine scheduler allocates serverless function execution across CNodes, not GPU time-slices across competing users. Polaris provides genuine Layer 2A capability that Dell lacks entirely: intent-driven, multi-cluster, multi-cloud infrastructure provisioning and lifecycle management. Dell’s OpenManage manages a single rack. Polaris manages a fleet of VAST deployments across geographies, clouds, and on-prem sites as one system. The three management modes (VAST-managed, partner-managed, customer-managed) provide operational flexibility that has no Dell equivalent. However, if the enterprise deploys separate GPU clusters for training/inference (not embedded in VAST), those clusters still need GPU-aware scheduling. VAST doesn’t provide this: the customer would need NVIDIA Run:ai or equivalent for the GPU compute layer that sits alongside (not within) the VAST data platform. In a typical deployment, VAST handles the data plane (storage, retrieval, orchestration), and a separate GPU cluster (Dell PowerEdge, HPE ProLiant, etc. with Run:ai) handles training/inference. Polaris manages the VAST fleet; something else manages the GPU cluster. The Polaris + DataSpace coordination is the most interesting Layer 2A finding: Polaris abstracts infrastructure location while DataSpace abstracts data location. This separation of concerns (managing where infrastructure runs vs. managing where data lives) is exactly the architectural prerequisite for Layer 2C placement reasoning. No other vendor in this assessment separates these abstractions as cleanly.
Low for infrastructure orchestration (Polaris is VAST IP). Moderate for GPU-specific scheduling (depends on NVIDIA GPU Operator for CNode-X, and the customer still needs Run:ai or equivalent for separate GPU clusters). Compare to Dell: Dell’s Layer 2A has HIGH borrowed judgment because all GPU-aware orchestration is NVIDIA-controlled (GPU Operator, Run:ai, AI Enterprise, MIG/MPS). VAST’s Layer 2A has MODERATE borrowed judgment because Polaris handles infrastructure orchestration (VAST IP) while GPU scheduling is a narrower dependency limited to CNode-X management. The key distinction: Dell NEEDS Run:ai because GPU scheduling is the core Layer 2A function in Dell’s architecture. VAST’s Polaris handles the broader infrastructure orchestration function, and GPU scheduling is a specific sub-function for CNode-X hardware management, not the defining Layer 2A capability. Polaris is included in VAST AI OS at no additional charge. Dell’s customers pay separately for NVIDIA Run:ai and AI Enterprise licenses. This pricing distinction reflects the authority distinction: VAST bundles infrastructure orchestration because it owns it; Dell passes through NVIDIA licensing because it doesn’t. Decision authority: Polaris carries the grade (Keith, October 5, 2026) and reconciles the desired state administrators declare. Code decides, visible, overridable, Retained. DataEngine's cost-optimizer picks where functions run with no documented override, but it's depth, not the carrier.
The three management modes (VAST-managed, partner-managed, customer-managed) have DAPM implications: • VAST-managed: fully Ceded (VAST operates the infrastructure) • Partner-managed: Delegated to the partner (CSP, MSP) • Customer-managed: the enterprise operates Polaris but the software is still VAST’s Even in customer-managed mode, the control plane software is VAST IP. The enterprise operates it but doesn’t own it. This is analogous to running VMware vCenter on your own hardware: you operate it, but the software authority belongs to the vendor. Polaris is available now as part of VAST cloud deployments, with expanded multi-cluster orchestration planned in future releases. The ‘expanded multi-cluster orchestration’ roadmap item is worth tracking: this is where Polaris evolves from infrastructure management (Layer 2A) into placement reasoning (Layer 2C). 89% of APAC enterprises deploy workloads across multiple public clouds; 72% operate hybrid cloud models (cited by VAST). This validates Polaris’s multi-cloud orchestration thesis.
Model serving, agent execution, inference APIs, distributed inference
AI agent deployment and orchestration system running natively within the DataEngine. Described as ‘the application management layer of the VAST AI OS, designed specifically for the Agentic AI Era’ and ‘the final piece of the puzzle, rounding out the core services needed to run agentic applications on AI hardware.’ Low-code runtime that simplifies programming and coordinates multi-agent workflows, model invocation, and tool usage. Brings agents to life directly within DataEngine: reasoning occurs where the data lives.
Robust runtime for long-running containerized services. Lifecycle management for agent deployment, scaling, and versioning. Persistent state via execution-scoped or persistent scratch space spanning files, objects, or tables. Secure service discovery for agents to find and communicate with other agents and tools. Support for agents with multiple personas and security credentials. Fault-tolerant backbone with Kafka-backed queuing for durability and ordering.
Model Context Protocol toolbox enabling agents to orchestrate multiple tools and services together for higher-order workflows. Composability lets teams build complex agentic applications without stitching fragile systems. Aligns with the open MCP standard (donated to Linux Foundation Dec 2025). Ceded despite the open protocol: the tools are VAST's, bound to the Element Store and AgentEngine, and the workflows built on them run nowhere else. Standard plug, captive socket.
Each agent call is defined with the user’s identities and permissions. Tools and data are accessed responsibly under the same permission model that governs the underlying Element Store. Multi-tenant operation with strong governance controls. This is structural: agent permissions inherit from the data platform’s security model, not from a bolt-on ACL layer.
Logs and traces every agent action, tool call, and data access. End-to-end observability creates transparency for compliance, stakeholder trust, and performance refinement. Built into the same platform: no external Grafana, tracing systems, or observability infrastructure required.
Every add, move, change, or delete in storage emits an event that feeds into agent workflows via DataEngine. Ties data operations directly to agentic AI actions in real time. Agents can react to data changes as they happen: no polling, no batch triggers.
VAST can serve NVIDIA NIM inference containers on CNode-X infrastructure, providing access to NVIDIA’s model ecosystem. NIM and AgentEngine are not mutually exclusive: NIM provides optimized model serving; AgentEngine provides the orchestration and lifecycle management around it.
Model inference on CNode-X is GPU-accelerated via CUDA. VAST provides the orchestration and governance; NVIDIA provides the compute acceleration. This separation is cleaner than Dell’s stack where NVIDIA owns both orchestration (NemoClaw) and acceleration.
VAST AgentEngine is the most significant Layer 2B finding in the comparative analysis and the starkest architectural contrast with Dell’s approach. Dell’s Layer 2B: Dell does not appear to own the core agent runtime. NemoClaw provides the agent execution stack (NVIDIA). OpenShell provides the sandboxed runtime (NVIDIA). NeMo Guardrails provide safety constraints (NVIDIA). Cohere North provides agent workflow orchestration (ISV partner). DataRobot provides agent lifecycle management (ISV partner). Dell provides hardware, packaging, and professional services. Five authorities for one layer. VAST’s Layer 2B: AgentEngine provides agent deployment, orchestration, runtime, lifecycle management, persistent state, MCP toolbox, permission-aware execution, observability, and data event integration: all within a single platform. One authority for the entire layer. The architectural differentiators: 1. Agents execute where the data lives. In VAST, there is no data movement between storage and inference runtime because they are the same platform. In Dell’s architecture, data flows from PowerScale/ObjectScale through NVIDIA’s inference runtime, crossing authority and system boundaries. 2. Permission-aware by structure. Agent permissions inherit from the Element Store’s security model. Dell’s agent permissions depend on NeMo Guardrails (runtime constraint) and the ISV partner’s governance logic (Cohere North, DataRobot). 3. Real-time data event triggers. Every storage operation emits events that feed into agent workflows. Dell’s agents consume data through retrieval (Elastic search) and pipeline (Dataloop) stages, not through direct data event feeds. 4. Built-in observability. Logs and traces every agent action without external monitoring infrastructure. Dell’s observability depends on partner tools. 5. MCP Toolbox. Native MCP support for agent-to-tool orchestration. Aligns with open standards. Dell’s agentic platform uses ISV-specific tool orchestration (Cohere North, DataRobot SDKs). Maturity is a watch-item, not a capability discount today: AgentEngine is generally available and a complete, owned agent runtime (which is what the score reflects), and proven-ness at enterprise scale may become a differentiator as the agentic market matures. AgentEngine is newer and less proven than NVIDIA’s NemoClaw/OpenShell stack. NVIDIA’s open-source foundation (OpenClaw), broad model support (Nemotron, NIM), and ecosystem validation (Dell, HPE, Lenovo, CSPs) represent a larger installed base. Jensen’s ‘operating system for personal AI’ framing signals NVIDIA’s long-term commitment to the runtime layer. VAST’s AgentEngine must prove equivalent reliability, security, and model compatibility at enterprise scale. The commoditization signal from Augment Code’s 2026 multi-agent orchestration analysis: ‘The runtime layer (tool registries, state management, retry logic) is being commoditized by open standards and hyperscaler investment. Teams building custom implementations will find platform solutions commoditizing that work within 12–18 months.’ This applies to both VAST AgentEngine and NVIDIA NemoClaw: the question is whether the runtime will differentiate or whether the governance layer above it (Layer 2C) becomes the battleground.
Low for agent orchestration, lifecycle, and governance (AgentEngine, MCP Toolbox, permission model, observability are all VAST IP). Moderate for model inference (depends on NVIDIA CUDA acceleration on CNode-X). NIM containers can run on the platform but are not required: AgentEngine is model-agnostic. Compare to Dell: Dell’s Layer 2B borrowed judgment is TOTAL for the runtime (NemoClaw/OpenShell/NIM/Dynamo/AI Enterprise are all NVIDIA) and DELEGATED for orchestration (Cohere North/DataRobot/ClearML). Dell’s one Retained asset is professional services. VAST’s Layer 2B authority structure: VAST owns the runtime, the orchestration, the lifecycle management, the permission model, and the observability. NVIDIA provides inference acceleration. The enterprise Cedes to one vendor (VAST) rather than to three+ vendors (NVIDIA + Cohere + DataRobot + ClearML in Dell’s case). The DAPM summary: both Dell and VAST require the enterprise to Cede Layer 2B authority. The difference is whether you Cede to a fragmented set of authorities (Dell’s model) or to a unified authority (VAST’s model). The 4+1 model doesn’t prescribe which is better: it requires the enterprise architect to make the choice explicitly.
The positioning contrast is telling: NVIDIA says NemoClaw is ‘the operating system for personal AI.’ VAST says AgentEngine is ‘the application management layer of the AI Operating System.’ NVIDIA positions the agent runtime as an OS: the platform everything else runs on. VAST positions it as a layer within a larger OS that includes storage, retrieval, governance, and infrastructure orchestration. The difference: NVIDIA’s vision is runtime-centric (the agent runtime IS the platform). VAST’s vision is data-centric (the data platform includes the agent runtime as one of its services). For the Enterprise AI Control Plane working document: AgentEngine + PolicyEngine (Layer 2C) + the Element Store permission model (Layer 1A) form a coherent governance chain within VAST’s stack. In Dell’s stack, the equivalent governance chain would be: NeMo Guardrails (NVIDIA) + ???(no Layer 2C) + Trust3 AI (partner) + MetadataIQ (Dell): four authorities, one missing layer.
Policy-driven placement and resource coordination — the Autonomy Layer
TuningEngine integrates with NeMo Data Designer for training and fine-tuning Nemotron models. This is NVIDIA’s model training framework accessed through VAST’s tuning pipeline: NVIDIA provides the training technology, VAST provides the orchestration and governance around it.
PolicyEngine, Polaris, and DataSpace are VAST IP. NVIDIA does not provide or control the governance, placement, or policy reasoning layer. The NeMo Data Designer integration is a training tool dependency, not a governance dependency. This is structurally different from Dell, where the closest Layer 2C functions (Dynamo routing, NeMo Guardrails) are NVIDIA-owned.
Deployable today, this is a gap. Polaris (placement abstraction) and DataSpace (namespace) ship, but placement abstraction without a policy-reasoning engine is routing, not reasoning - and PolicyEngine, TuningEngine, and the closed loop are announced for End of 2026, not shipping (see watch-list). What follows describes the architecture VAST is building toward, dated end-2026; it is not an option an architect can deploy today. This is the most significant finding in the comparative assessment. Layer 2C is where the 4+1 model’s thesis is tested most directly: does any vendor provide policy-driven placement decisions across models, data, agents, and infrastructure? Applying the ‘Routing Is Not Reasoning’ test to VAST’s stack: PolicyEngine goes BEYOND constraint enforcement (what NeMo Guardrails does at Layer 2B). Guardrails say ‘the agent cannot do X.’ PolicyEngine says ‘the agent can do X only if conditions Y and Z are met, as determined by AI-derived context, and the action will be logged with tamper-proof traceability.’ This is active policy reasoning, not static constraint enforcement. The pre-execution enforcement model means governance decisions happen BEFORE actions execute, not after, a fundamentally different posture than post-hoc audit. Polaris goes BEYOND infrastructure provisioning (what Kubernetes does at Layer 2A). Polaris doesn’t just deploy clusters. It abstracts infrastructure location so that workloads can be placed based on GPU availability and compliance requirements without changing application behavior. Combined with DataSpace abstracting data location, Polaris + DataSpace provide the multi-variable placement reasoning that the 4+1 model defines as Layer 2C. TuningEngine goes BEYOND model serving (what NemoClaw does at Layer 2B). It manages the continuous improvement of models based on production outcomes, governed by PolicyEngine. This closes the loop from execution through evaluation through improvement through re-governance: no other vendor has this cycle in a single platform. The multi-variable test from the 4+1 model: can the system make placement decisions based on cost + compliance + latency + data residency + model capability simultaneously? • Cost: DataEngine’s built-in cost-optimizer can deploy on CPU/GPU/DPU based on cost • Compliance: PolicyEngine enforces permissions and audit requirements before execution • Latency: DataSpace provides remote data caches for geo-distributed access • Data residency: DataSpace’s per-site consistency management respects data locality • Model capability: TuningEngine manages model versions and fitness for purpose VAST is the only vendor in this series that addresses all five variables, even if the integration between them is not yet fully productized (PolicyEngine and TuningEngine ship end of 2026). Caveats remain critical: • PolicyEngine and TuningEngine are announced, not shipped. GA end of 2026. • Polaris is available but multi-cluster placement orchestration is in ‘expanded capabilities planned in future releases.’ • The ‘AI-derived context’ in PolicyEngine is described but the AI decision-making model is not detailed: how the AI determines permissions from context is a black box. • The closed loop (observe-reason-act-evaluate-improve) is architecturally described but not production-validated at enterprise scale. Compare to Google Cloud: Inference Gateway + DWS + Knowledge Catalog is productized and shipping. Google’s Layer 2C is narrower (inference placement and scheduling) but real. VAST’s is broader (governance + placement + learning) but pre-GA. Compare to Dell: No productized Dell-owned Layer 2C is evident. Dell has the Dell + Intel ‘control plane’ signal but no product. VAST is building what Dell hasn’t started. Compare to Kamiwaza: Policy-driven Inference Mesh + Distributed Data Engine + ReBAC is the most comparable Layer 2C approach: explicit multi-variable policy optimization for inference placement. Kamiwaza and VAST are approaching from different directions (Kamiwaza from inference, VAST from data) toward the same Layer 2C function.
Low: the lowest Layer 2C borrowed judgment score in the assessment series because VAST is the only vendor building a proprietary Layer 2C. PolicyEngine, Polaris, DataSpace, and TuningEngine are all VAST IP. The NVIDIA dependency is limited to NeMo Data Designer for model training within TuningEngine: a training tool, not a governance dependency. Deployable today, the decision-authority reading here is Absent, and not as a compliment: nothing ships that claims the layer, so the enterprise owns the reasoning-plane function because nobody else has. That is the same position every gap cell on the instrument carries. On GA the classification would change, not just the capability. PolicyEngine, Polaris, DataSpace, and TuningEngine are VAST IP with no open exit, so the enterprise would gain governance and cede it to VAST in the same motion. That trade is worth naming ahead of time, because the architect's question at this layer is not whether to have a reasoning plane but who would hold its authority, and a gap and a Ceded control plane are different problems rather than degrees of the same one. VAST’s answer: VAST holds it, as part of a vertically integrated platform where governance, execution, data, and infrastructure are one system. Dell’s non-answer: nobody holds it. Build it yourself or operate without it. Google’s answer: Google holds it, as part of a cloud platform where the enterprise Cedes everything.
Analyst and media framing validates the Layer 2C classification: • Blocks and Files: ‘VAST broadens AI platform push with control plane’, explicitly using control plane language • Moor Insights: Polaris positions VAST as ‘the persistent operational layer for AI’ • theCUBE Research (Strechay): ‘VAST looks at it as going up the stack’ • TipRanks: PolicyEngine + TuningEngine transform the AI OS into a ‘consolidated stack merging data, compute, policy enforcement, and model training into one infrastructure fabric’ • SiliconANGLE: Polaris is ‘complementary to DataSpace: DataSpace focuses on how data is presented across locations; Polaris focuses on how clusters are deployed and maintained’ This validates the Enterprise AI Control Plane working document’s Pattern 4: Storage Vendors Reaching Up. VAST is the most aggressive example. The three-vector convergence: • Dell: bottom-up (infrastructure OEM, hasn’t started Layer 2C, Dell+Intel signal only) • Google: top-down (cloud provider, Inference Gateway + DWS + Knowledge Catalog, productized) • VAST: middle-out (data platform, PolicyEngine + Polaris + DataSpace + TuningEngine, emerging) The Microsoft Agent Governance Toolkit (April 2026) and the AgentGuardian research paper validate that agent governance is becoming a recognized engineering discipline, not just a VAST-specific product category. The 4+1 model’s Layer 2C aligns with this emerging discipline. Watch-list (pending GA, not scored): PolicyEngine, TuningEngine, and the Closed Loop are all End of 2026 - VAST's policy-reasoning 2C is architected and dated but not shipping. Deployable today: Polaris (placement abstraction) plus DataSpace (namespace) - routing and plumbing, not a policy-reasoning plane (routing is not reasoning), so the layer is a gap until PolicyEngine ships. 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.
AI-powered business capabilities — business logic, workflow automation
CNode-X and AgentEngine provide the substrate for running NVIDIA NIM containers, Nemotron models, and NVIDIA Blueprints. VAST’s model-agnostic architecture means NVIDIA models are one option among many, not the mandatory runtime path.
VAST ships no first-party business applications, and its ecosystem is partnership. Cosmos is a program for partners to take VAST to market (resellers, integrators, distributors, cloud and technology partners), not VAST reselling ISVs. TwelveLabs gets a "customer-managed deployment path" on the VAST AI Operating System with no VAST SKU, and CrowdStrike Falcon is "certified and available today" for VAST, with buyers sent to their CrowdStrike representative. Model serving on AgentEngine and CNode-X is read at 2B. Layer 3's grade rests on business applications the enterprise can buy or get supported on the vendor's paper (as ruled October 19, 2026: business applications bought or supported on the vendor's paper). Certification isn't procurement. Calibration: Cisco, Arista and Nokia read moderate on first-party security applications; HPE reads partner on ISV applications customers buy from HPE on the GreenLake Marketplace; Dell, Nutanix, Red Hat, VMware, VAST and Supermicro read gap on the same certification-only shape.
None on VAST's paper. The enterprise buys its applications from the ISVs; VAST's platform covers Layers 1A through 2C beneath them.
Named, not scored: VAST Cosmos Community (partner go-to-market), TwelveLabs (partnership, March 4, 2026), CrowdStrike Falcon certification (September 1, 2026; sold by CrowdStrike).
VAST Forward 2026, VAST AI OS white paper, analyst coverage, published 4+1 model. v1.5 (instrument reconciliation): 2B moderate→strong: AgentEngine is GA (H2 2025) and a complete, owned agent runtime; the prior moderate rested on a maturity/less-proven discount, which is not a capability axis (GA + complete owned runtime = strong, the same bar Databricks 2B cleared). Maturity may become a scored attribute as the agentic market matures. /reconcile (September 1, 2026): retired status vocabulary replaced with gap. /reconcile (September 1, 2026): shared 2C findings stated explicitly (live-placement universality). /reconcile (September 1, 2026): hard-coded peer-grade ledger replaced with a shape-based reading, and the 2C borrowed-judgment corrected: a gap cell is Retained-by-default, and the prose had asserted present-tense Ceded for capability announced for end-2026. /reconcile (September 4, 2026, override rule ratified on the Elastic row): Layer 1C authority Ceded to Retained (code). The engine executes enterprise-written functions and triggers without judgment about the movement itself; the Elastic 1C reading. Portability unchanged. No status changed. /reconcile (October 5, 2026): Layer 3 moderate to partner because Layer 3 credits first-party business applications (no first-party business application; the layer is addressed through the ecosystem). CoreWeave moved from a Layer 3 component to notes (a customer, not a delivery); NVIDIA NIM serving removed from Layer 3, already read at 2B. /reconcile (October 5, 2026): authority visible set from the cell's own text where it settles it: layer1a true, layer2a true. Direction, grades, and components unchanged. /reconcile (October 5, 2026): layer2a authority to code / Retained on the carrier Keith named. Grade and components unchanged. /reconcile (October 5, 2026): authority read against product docs: layer0 visible true. Grades and components unchanged. v1.15 (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 gap, 0B moderate, 0C strong. v1.16 (October 19, 2026, /reconcile partner ruling): Layer 3 partner to gap, authority Absent; the AI ISV program is certification, not procurement on the vendor's paper, and a partner grade needs ISV applications bought or supported on the vendor's paper. (Same pass) 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.17 (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.18 (October 21, 2026, /reconcile): 0C chip added for VAST's S3 interface, Delegated, from reconcile's peer calibration and VAST's S3 implementation overview (kb.vastdata.com, read October 21, 2026: a documented subset of the AWS S3 API). It matches WEKA's, DDN's and Everpure's S3 doors and the StorageGRID, ObjectScale and IBM Cloud Object Storage readings. Grade and cell authority unchanged; the cell rests on DASE and the Element Store. v1.19 (October 22, 2026, /reconcile): 0B back-end fabric chip names Spectrum-4 switches, as VAST's own switch documentation does; Spectrum-X appeared only in a 2025 partnership blog. Found by the 0B fabric research. Grade and authority unchanged. v1.20 (October 23, 2026, /reconcile): Layer 1 research pass. 1B: "VAST Catalog (Discovery Surface)" removed (VAST Catalog "indexes metadata attributes of all data on the cluster"; its docs don't describe it as a retrieval surface). 1C: "Composability Architecture" removed (an architecture narrative composing SyncEngine, DataEngine, InsightEngine, DataBase and AgentEngine, each its own chip; no product of its own). Found by the Layer 1 slot cut. Grade and cell authority unchanged. v1.21 (October 23, 2026, storage door pass): NFS and SMB on VAST DataStore get their own door, beside S3. Grade unchanged. v1.22 (October 23, 2026, Layer 1 managed-services pass): VAST Event Broker gets a door. Grade unchanged. v1.23 (October 24, 2026, /reconcile): 1B moves from strong to moderate: InsightEngine has no product guide in VAST's knowledge base; the cell rests on documented vector search with permission filters and SyncEngine. Found in the 1B dependency audit follow-ups. Grade changed: 1B strong to moderate. v1.24 (October 24, 2026, /reconcile): 1B strong restored: InsightEngine's March 18, 2025 availability release fulfills VAST's dated GA commitment, which qualifies as GA evidence (Keith, October 24, 2026). Grade changed: 1B moderate to strong. v1.25 (October 24, 2026, /reconcile): GA evidence recorded on 4 of 4 Layer 1B chips under the GA evidence table. Grade unchanged. v1.26 (October 24, 2026, /reconcile): Layer 1B GA evidence migrated to the GA evidence table version 2. Grade unchanged. v1.27 (October 24, 2026, /reconcile): GA evidence recorded on 3 of 4 Layer 1A chips under the GA evidence table version 2. Grade unchanged. v1.28 (October 24, 2026, /reconcile): GA evidence recorded on 5 of 5 Layer 1C chips under the GA evidence table version 2. Grade unchanged. v1.29 (October 24, 2026, /reconcile): GA evidence recorded on 1 of 2 Layer 0B chips under the GA evidence table version 2. Grade unchanged. v1.30 (October 24, 2026, /reconcile): GA evidence recorded on 11 of 11 Layer 0C chips under the GA evidence table version 2. Grade unchanged. v1.31 (October 24, 2026, /reconcile): GA evidence recorded on 4 of 4 Layer 2A chips under the GA evidence table version 2. Grade unchanged. v1.32 (October 24, 2026, /reconcile): GA evidence recorded on 6 of 6 Layer 2B chips under the GA evidence table version 2. Grade unchanged. v1.33 (October 24, 2026, /reconcile): GA evidence table version 2.1 applied: 2 chips recorded or narrowed. Grade unchanged. v1.34 (October 27, 2026): each component now carries a durable offering id; nothing else changed.