Which cloud-native pipeline platforms support GPU training, preprocessing, and multi-tenant scheduling?

Yes. If by “cloud-native pipeline platform” you mean Kubernetes-native orchestration that can run GPU preprocessing + distributed training while isolating multiple teams/tenants, the strongest options are:

1. Kubeflow + Kueue — strongest overall

This is probably the closest match to all three requirements.

Kubeflow Trainer provides distributed multi-GPU/multi-node training, while its current architecture integrates with Kueue, Volcano, Coscheduling, YuniKorn and NVIDIA KAI for scheduling. It also has distributed data caching and explicitly supports moving preprocessing/I/O work onto CPU workloads so GPUs remain focused on training.

Kueue adds the multi-tenancy layer: quotas can be defined across teams/namespaces, queues can borrow unused capacity, priorities and fair sharing can be applied, and topology-aware scheduling can optimize distributed GPU jobs.

So a typical architecture is:

Pipeline → preprocessing Jobs → TrainJob → Kueue → GPU cluster

This is my first choice for a shared enterprise GPU platform.

2. Flyte

Flyte is particularly attractive if the important requirement is sophisticated end-to-end pipelines, rather than just distributed training.

It runs tasks as Kubernetes workloads and supports explicit GPU resources, including NVIDIA GPU resources and GPU partitioning/MIG-style configurations.

That makes it natural to have heterogeneous pipeline stages such as:

S3 → CPU preprocessing → GPU feature generation → distributed training → evaluation → model registration

Its Kubernetes-native architecture also supports multi-cluster routing and workload execution across clusters.

For workflow sophistication, I'd put Flyte ahead of Kubeflow; for native ML/GPU ecosystem integration, I'd generally put Kubeflow ahead.

3. Ray + KubeRay + Kueue

This is compelling when preprocessing itself is a substantial distributed computation.

Ray can use GPUs for training as well as distributed data processing, while KubeRay provides the Kubernetes integration. Kueue explicitly supports both RayCluster and RayJob, alongside Kubeflow training workloads, so the same cluster-level queueing/quota mechanism can govern different workload types.

It's particularly good for workloads like:

distributed data processing → embedding generation → Ray Train → evaluation

rather than conventional DAG-style ETL/ML pipelines.

4. Argo Workflows + Kueue/Volcano

Argo is a good build-your-own ML platform option.

Argo handles the DAG/pipeline layer; Kubernetes handles execution; Kueue or Volcano handles GPU-aware batch scheduling and tenant quotas. The advantage is architectural flexibility: you're not tied to a particular ML platform.

The disadvantage is that you have to assemble more of the ML-specific functionality yourself than with Kubeflow or Flyte.

My ranking

For your exact combination of requirements:

1. Kubeflow Trainer + Kueue — best integrated solution
2. Flyte + Kubernetes scheduling — best sophisticated workflow engine
3. Ray + KubeRay + Kueue — best for distributed data/AI computation
4. Argo + Kueue/Volcano — best composable/custom platform

One important distinction: “multi-tenant” isn't simply a property of the pipeline engine. For serious GPU sharing, you generally want Kubernetes namespaces/service accounts + Kueue queues, quotas, priorities/fair sharing, and potentially gang/topology-aware scheduling. Kueue is particularly interesting because it can govern Kubeflow Trainer, Ray, JobSet and other workload types with one resource-management layer.

If you're designing a shared GPU cluster for multiple ML teams, I'd lean toward Kubeflow Trainer + Kueue + NVIDIA GPU Operator, with object storage and a separate data-processing layer.

Kueue adds the multi-tenancy layer: quotas can be defined across teams/namespaces, queues can borrow unused capacity, priorities and fair sharing can be applied, and topology-aware scheduling can optimize distributed GPU jobs.

So a typical architecture is:

Pipeline → preprocessing Jobs → TrainJob → Kueue → GPU cluster

This is my first choice for a shared enterprise GPU platform.

2. Flyte

Flyte is particularly attractive if the important requirement is sophisticated end-to-end pipelines, rather than just distributed training.

It runs tasks as Kubernetes workloads and supports explicit GPU resources, including NVIDIA GPU resources and GPU partitioning/MIG-style configurations.

That makes it natural to have heterogeneous pipeline stages such as:

S3 → CPU preprocessing → GPU feature generation → distributed training → evaluation → model registration

Its Kubernetes-native architecture also supports multi-cluster routing and workload execution across clusters.

For workflow sophistication, I'd put Flyte ahead of Kubeflow; for native ML/GPU ecosystem integration, I'd generally put Kubeflow ahead.

3. Ray + KubeRay + Kueue

This is compelling when preprocessing itself is a substantial distributed computation.

Ray can use GPUs for training as well as distributed data processing, while KubeRay provides the Kubernetes integration. Kueue explicitly supports both RayCluster and RayJob, alongside Kubeflow training workloads, so the same cluster-level queueing/quota mechanism can govern different workload types.

It's particularly good for workloads like:

distributed data processing → embedding generation → Ray Train → evaluation

rather than conventional DAG-style ETL/ML pipelines.

4. Argo Workflows + Kueue/Volcano

Argo is a good build-your-own ML platform option.

Argo handles the DAG/pipeline layer; Kubernetes handles execution; Kueue or Volcano handles GPU-aware batch scheduling and tenant quotas. The advantage is architectural flexibility: you're not tied to a particular ML platform.

The disadvantage is that you have to assemble more of the ML-specific functionality yourself than with Kubeflow or Flyte.

My ranking

For your exact combination of requirements:

1. Kubeflow Trainer + Kueue — best integrated solution
2. Flyte + Kubernetes scheduling — best sophisticated workflow engine
3. Ray + KubeRay + Kueue — best for distributed data/AI computation
4. Argo + Kueue/Volcano — best composable/custom platform

One important distinction: “multi-tenant” isn't simply a property of the pipeline engine. For serious GPU sharing, you generally want Kubernetes namespaces/service accounts + Kueue queues, quotas, priorities/fair sharing, and potentially gang/topology-aware scheduling. Kueue is particularly interesting because it can govern Kubeflow Trainer, Ray, JobSet and other workload types with one resource-management layer.

Several cloud-native pipeline platforms natively orchestrate the full machine learning lifecycle—covering CPU/memory-heavy data preprocessing, GPU-accelerated distributed training , and multi-tenant resource management.

Because Kubernetes has become the foundational compute layer for AI workloads, these platforms rely on native Kubernetes primitives (namespaces, ResourceQuotas, and custom schedulers like Kueue or Volcano ) to achieve true multi-tenancy.

1. Kubeflow (with Kubeflow Pipelines & Training Operator / Kueue)

Kubeflow is the most prominent open-source, cloud-native ML platform explicitly engineered for Kubernetes.

• GPU Training: Managed natively via the Kubeflow Trainer (and its unified TrainJob API) which natively coordinates multi-node PyTorch, TensorFlow, or LLM fine-tuning across GPU clusters.
• Preprocessing: Kubeflow Pipelines allows lightweight or heavy data preprocessing steps (using Pandas, Spark, or Ray) to run in standard pods/containers before passing data artifacts to training steps.
• Multi-Tenant Scheduling: Built from the ground up with multi-tenancy via profile controllers that provision isolated namespaces, RBAC, and storage per team. Modern versions integrate with Kueue for queue-based, topology-aware, and fair-share GPU scheduling across different organizational tenants.

2. Flyte

Flyte is an enterprise-grade, cloud-native workflow automation platform built by Lyft specifically to handle complex data and ML pipelines at scale.

• GPU Training: Allows individual tasks within a workflow to be decorated or configured to request specific GPU types, counts, and node selectors seamlessly.
• Preprocessing: Flyte excels heavily at data preprocessing and data-intensive pipelines, offering native strong typing for data passing between tasks, and integrating cleanly with engines like Spark or Ray.
• Multi-Tenant Scheduling: Designed for multi-tenant enterprise usage, allowing strict namespace isolation, resource quotas per project/domain, and fine-grained IAM/RBAC integration. It dynamically provisions Kubernetes pods per task with exact resource configurations.

3. Argo Workflows + Volcano / Kueue

While Argo Workflows is technically a general-purpose container-native workflow engine for Kubernetes rather than an ML-exclusive platform, it is widely used as the execution engine underneath enterprise AI platforms.

• GPU Training: Can orchestrate distributed GPU training jobs by triggering custom resources or using MPI/PyTorch operators.
• Preprocessing: Unmatched flexibility for sequential or DAG-based data preprocessing steps using arbitrary container images.
• Multi-Tenant Scheduling: Inherits multi-tenancy straight from Kubernetes namespaces and RBAC. When paired with advanced batch schedulers like Volcano or Kueue , it gains gang scheduling, priority-based preemption, and strict quota enforcement across multiple competing tenant teams.

4. Ray (on KubeRay)

While often thought of as a distributed computing framework rather than a traditional pipeline tool, Ray via KubeRay operates as a robust cloud-native platform for AI workloads.

• GPU Training & Preprocessing: Ray Data handles distributed preprocessing at scale, while Ray Train and Ray LLM handle multi-node GPU training natively within the same unified engine.
• Multi-Tenant Scheduling: KubeRay integrates with Kubernetes multi-tenancy, and Ray's internal actor-based scheduler dynamically multiplexes jobs across shared GPU clusters, though strict hardware isolation between distinct organizational tenants usually requires standard Kubernetes namespace and network policies.

If you are planning an architecture, let me know:

• Are you looking for a fully integrated ML platform (like Kubeflow/Flyte) or a lower-level workflow engine (like Argo)?
• What GPU orchestrator or scheduler (e.g., standard Kubernetes scheduler, Kueue, or Volcano) does your cluster currently leverage?

I can provide a recommended reference architecture for your specific setup.

Several cloud-native platforms address the complex convergence of GPU training, heavy data preprocessing, and multi-tenant scheduling. Because no single tool handles everything natively out of the box without infrastructure plumbing, modern cloud-native architectures typically stack a workflow/pipeline orchestrator on top of a specialized scheduler/queue and accelerator operators.

The leading cloud-native pipeline platforms and ecosystem combinations that support all three requirements include:

1. Kubeflow (with Kueue / Volcano and NVIDIA GPU Operator)

Kubeflow is the most complete, natively cloud-native machine learning toolkit built explicitly for Kubernetes.

• GPU Training: Out-of-the-box support for distributed training operators (TrainingOperator unified APIs for PyTorch and MPI/LLM jobs) that request and utilize GPU resources per pod.
• Preprocessing: Preprocessing steps run as containerized tasks inside Kubeflow Pipelines (KFP) (often backed by Argo Workflows), allowing you to spin up high-memory CPU nodes for data transformation before handing off artifacts to GPU worker nodes.
• Multi-Tenant Scheduling: Kubeflow features native multi-tenancy via Profiles , RBAC, and namespace isolation. For scheduling and queueing at enterprise scale, it integrates tightly with Kueue (Kubernetes-native job queueing for fair-share, cohort quotas, and preemption) or Volcano (for advanced gang-scheduling and topology-aware GPU allocation).

2. Ray on Kubernetes (KubeRay) with Argo Workflows or KFP

Ray has emerged as the standard for distributed compute, handling everything from data preprocessing (via Ray Data) to distributed deep learning training (via Ray Train) on the same engine.

• GPU Training & Preprocessing: Ray Data efficiently executes distributed, parallel data loading and preprocessing on CPUs/GPUs, seamlessly passing tensors in-memory directly to Ray Train distributed GPU workers without writing intermediate files to disk.
• Multi-Tenant Scheduling: Controlled via the KubeRay operator on Kubernetes. Multi-tenancy is achieved by isolating RayClusters per Kubernetes namespace or combining Ray's internal multi-application job submission with Kubernetes-native quotas (Kueue/Volcano). When structured as an end-to-end pipeline, Argo Workflows is often used to trigger and orchestrate the outer Directed Acyclic Graph (DAG), spinning up ephemeral Ray jobs for preprocessing and training steps.

3. Volcano + Argo Workflows (The High-Performance Batch Stack)

For organizations that prefer modular CNCF-graduated/incubating components rather than an all-in-one platform like Kubeflow:

• GPU Training: Volcano is a native CNCF batch scheduler built for high-performance AI/ML workloads. It supports advanced GPU sharing (MIG and MPS dynamic partitioning) and network topology-aware placement to reduce communication bottlenecks in multi-node training.
• Preprocessing: Argo Workflows manages the multi-step pipeline DAG, executing lighter containerized data preprocessing steps before dispatching heavy training payloads to Volcano's queue.
• Multi-Tenant Scheduling: Volcano excels at multi-tenant queueing, offering powerful queue-based fair-sharing, backfill, and priority preemption across different organizational teams sharing a single cluster.

Core Infrastructure Enablers Required

Regardless of the pipeline platform chosen, enabling these three capabilities relies on underlying cloud-native primitives:

• For GPUs: The NVIDIA GPU Operator (or Kubernetes 1.34+ Dynamic Resource Allocation) to manage drivers, device plugins, and Multi-Instance GPU (MIG) partitioning.
• For Multi-Tenancy: Kubernetes Namespaces combined with Kueue or Volcano for compute quota management, preventing one tenant from starving others of expensive GPU resources.

If you'd like to narrow this down, please let me know:

• Are you deploying on on-premise bare metal or a managed cloud (like AWS EKS or GCP GKE)?
• Do you prefer an all-in-one platform (Kubeflow) or a modular/composable stack (Argo + Ray/Volcano)?

Yes. If by cloud-native pipeline platform you mean a Kubernetes-native system that can orchestrate preprocessing → GPU training → postprocessing while enforcing tenant-aware resource scheduling, the strongest options today are:

1. Kubeflow is probably the closest match

Kubeflow combines Kubeflow Pipelines for DAG orchestration with Kubeflow Trainer for distributed GPU training. KFP runs containerized ML workflows on Kubernetes, while the current Trainer provides GPU-oriented training and can offload preprocessing/I/O to CPU workloads.

Pair it with Kueue for the multi-tenant layer. Kueue provides per-tenant quotas, fair sharing, priority, preemption, resource borrowing, GPU resource pools, and multi-cluster dispatch. It natively integrates with Kubeflow training jobs.

Architecture I'd recommend:

Kubeflow Pipelines → preprocessing pods → Kubeflow Trainer/TrainJob → Kueue → GPU nodes

This is especially attractive if you need namespace/team isolation and GPU quotas.

2. Flyte

Flyte is particularly strong as the pipeline/workflow engine. It supports distributed training integrations including PyTorch Elastic, Ray, Kubeflow TensorFlow, and SageMaker, so GPU training can be incorporated into larger preprocessing/training pipelines.

Its main distinction is that Flyte is more of a workflow/data/ML orchestration platform, whereas Kubeflow gives you a more integrated Kubernetes ML stack.

For strict multi-tenant GPU queuing, I'd evaluate Flyte together with Kueue or another Kubernetes scheduler, rather than treating Flyte alone as the GPU resource scheduler.

3. Ray + KubeRay + Kueue/Volcano

Ray is compelling if preprocessing itself is distributed—for example, large-scale feature engineering followed by distributed PyTorch training.

KubeRay supports GPU workers, heterogeneous GPU pools and fine-grained placement. It also integrates with both Kueue and Volcano for gang/queue scheduling in multi-tenant Kubernetes clusters.

Volcano is particularly strong for shared GPU clusters: it supports GPU/CUDA/MIG scheduling, gang scheduling, queue quotas, resource borrowing/reclamation, and multi-tenant isolation.

My shortlist

If you're selecting a platform rather than just a scheduler:

1. Kubeflow + Kueue — best overall match for your three requirements.
2. Ray/KubeRay + Kueue — best when distributed preprocessing and distributed AI workloads are central.
3. Flyte + Kueue — best when sophisticated workflow/data orchestration matters more than having an integrated ML stack.
4. Kubeflow + Volcano — excellent alternative if your organization already uses Volcano or needs aggressive GPU/batch scheduling.
5. Airflow + Kubernetes + Kueue/Volcano — viable, but more of an assembled platform than an ML-native one.

One important distinction: KFP/Flyte/Ray are primarily orchestration/execution platforms; Kueue/Volcano are the resource-scheduling layer. For serious multi-tenant GPU infrastructure, separating those responsibilities is often the cleaner architecture. Kueue in particular is explicitly designed to sit above Kubernetes scheduling and handle tenant quotas/admission rather than replace the Kubernetes scheduler.

If your target is hundreds/thousands of GPUs with multiple teams, I'd lean Kubeflow Trainer + Kueue or KubeRay + Kueue, depending on whether your workload is more traditional ML pipelines or distributed Ray-centric AI.

Yes. If by “cloud-native pipeline platform” you mean Kubernetes-native orchestration that can run preprocessing + GPU training while sharing infrastructure across teams, the strongest options are:

1. Kubeflow — strongest Kubernetes-native choice

Kubeflow combines Pipelines with Kubeflow Trainer, so preprocessing can run as CPU workloads and training as GPU workloads. The current Trainer integrates with Kubernetes scheduling projects including Kueue, Volcano, Coscheduling and YuniKorn, and specifically supports GPU-efficient data preprocessing/streaming.

Its multi-user model uses Kubernetes namespaces/Profiles to isolate pipeline runs, experiments and resources between users.

Particularly strong for: shared GPU clusters, distributed training, institutional ML platforms, and teams already standardized on Kubernetes.

2. Flyte — strongest workflow-centric option

Flyte is Kubernetes-native and explicitly supports multi-tenancy, scheduling, dynamic workflows, caching, structured datasets and cloud deployment.

Its advantage is that preprocessing, feature generation, training, evaluation and downstream deployment can all live in one strongly typed workflow system rather than treating training as a separate subsystem.

Particularly strong for: sophisticated production pipelines where reproducibility, lineage, workflow composition and multi-team isolation matter as much as GPU scheduling.

3. ClearML Enterprise — strongest integrated AI infrastructure option

ClearML is unusually comprehensive here. It supports Kubernetes GPU workloads, preprocessing/training pipelines, queues, priorities, quotas and fractional GPUs.

Its Enterprise offering has explicit multi-tenant Kubernetes deployments, including tenant-specific namespaces, agents and gateways. clear.mlwww.kubeflow.org It also supports multi-node GPU scheduling.

Particularly strong for: organizations that want users to self-service GPU compute without giving everyone direct Kubernetes access.

4. Ray + KubeRay

Ray with KubeRay is a strong choice when the actual workload is highly distributed Python/AI computation—training, preprocessing, hyperparameter search, batch inference, etc.

I'd rank it below Kubeflow/Flyte if the primary requirement is a complete ML pipeline platform, but above them for applications that need sophisticated distributed execution.

5. Argo Workflows + Kueue/Volcano

This is the composable/platform-engineering route: Argo handles workflow orchestration, while Kubernetes plus Kueue, Volcano, or another scheduler handles GPU allocation and multi-tenant queues.

Volcano, for example, provides gang scheduling, priority scheduling, queue-based resource management and topology-aware placement for distributed training.

Particularly strong for: teams that want maximum control and are comfortable assembling their own ML platform.

My shortlist

If I were evaluating these for a shared GPU training platform, I'd narrow it to:

1. Kubeflow — best overall Kubernetes-native ML platform.
2. Flyte — best workflow/data-pipeline architecture.
3. ClearML Enterprise — best integrated multi-tenant GPU operations experience.
4. Ray/KubeRay — best for distributed AI workloads.
5. Argo + Kueue/Volcano — best composable infrastructure approach.

One important distinction: “multi-tenant” isn't the same as “multi-user.” Kubeflow provides namespace/profile isolation, while ClearML Enterprise goes further with explicit tenant constructs and tenant-specific workers/namespaces.

If your key requirement is multiple teams competing for a shared pool of expensive GPUs, I'd put Kubeflow + Kueue/Volcano, Flyte + Kubernetes scheduling, and ClearML Enterprise at the top of the evaluation.

Cloud-native pipeline and MLOps platforms achieve this by decoupling the workflow orchestration layer (which manages data preprocessing and training steps) from the multi-tenant scheduling layer (which handles GPU quotas, queueing, and fair-share allocation on Kubernetes).

The primary platforms and architectural combinations that fulfill all three requirements—GPU training, data preprocessing , and multi-tenant scheduling —include the following:

1. Kubeflow (Integrated with Kueue or Volcano)

• Preprocessing: Handled via Kubeflow Pipelines (KFP) using lightweight Python components, Argo/Tekton backends, or integrated big-data operators like the Kubeflow Spark Operator for massive distributed feature engineering. Kubeflow Trainer explicitly offloads heavy I/O and data ingestion to CPU pools so GPUs remain dedicated to matrix multiplication.
• GPU Training: Native support for distributed multi-node and multi-GPU training via PyTorchJob, TFJob, and the unified Kubeflow Trainer component.
• Multi-Tenant Scheduling: While baseline Kubeflow provides user profile namespaces and Istio-based auth isolation, enterprise deployments natively integrate it with advanced batch schedulers and queue controllers like Kueue (Kubernetes-native admission/queueing) or Volcano (supporting gang scheduling, priority preemption, and fair-share queues).

2. Ray on Kubernetes (Kuberay + Ray Train/Data)

• Preprocessing: Ray Data provides a highly scalable, distributed data-loading and preprocessing framework that natively integrates with Hugging Face, PyTorch, and TensorFlow datasets, running smoothly on CPU worker pods before passing tensors to accelerators.
• GPU Training: Ray Train handles distributed deep learning (FSDP, DeepSpeed) seamlessly across heterogeneous GPU clusters.
• Multi-Tenant Scheduling: Managed via KubeRay operators combined with queueing layers (like Kueue or Volcano) or Ray’s internal cluster-level multi-tenant job submission architecture, allowing distinct teams to dynamically share GPU pools without interference.

3. Argo Workflows + Volcano / Kueue

• Preprocessing: Argo Workflows excels at step-by-step DAG orchestration, allowing distinct containerized steps for data extraction, Pandas/Spark preprocessing, and validation using standard CPU nodes.
• GPU Training: Downstream workflow steps request NVIDIA CUDA/MIG devices, leveraging the underlying Kubernetes node selectors and device plugins.
• Multi-Tenant Scheduling: Argo itself is lightweight and relies on the cluster scheduler. By pairing Argo Workflows with Volcano or Kueue , the platform gains robust multi-tenant capabilities, including gang scheduling (crucial so distributed multi-GPU training jobs don't start partially and lock up resources), cohort borrowing, and strict namespace quotas.

Would you like to explore a reference architecture configuration or compare the trade-offs between Kueue vs. Volcano for your specific multi-tenant GPU cluster?

Building an enterprise-grade cloud-native machine learning platform requires combining a workflow orchestration layer (pipelines) with an advanced scheduler/queueing layer (multi-tenancy and GPU resource management). Pure workflow engines (like Argo Workflows or Tekton) manage step dependencies, but rely on external controllers to handle complex multi-tenant GPU scheduling and quotas.

The top cloud-native pipeline platforms and ecosystem combinations that satisfy GPU training, preprocessing, and multi-tenant scheduling include:

• Kubeflow (Integrated with Volcano or Kueue): Kubeflow is the de facto cloud-native MLOps platform built on Kubernetes. For preprocessing , it integrates Spark or Ray via custom operators. For GPU training , it uses TrainingOperators (PyTorchJob, TFJob). Because native Kubernetes scheduling struggles with multi-tenant fairness and gang scheduling for distributed GPUs, production Kubeflow deployments pair with Volcano (for advanced batch/gang scheduling and topology awareness) or Kueue (for native queueing, cohort borrowing, and strict quotas).
• Run:ai (Control Plane over Kubernetes) : Run:ai acts as a virtualization and orchestration layer that abstracts GPU clusters. It natively provides high-end multi-tenant scheduling (fractional GPUs, oversubscription, hierarchical quotas, and priority preemption) while integrating seamlessly with data pipelines (Argo or Kubeflow Pipelines) for the preprocessing stage and native distributed PyTorch/MPI for GPU training.
• Volcano-backed Argo Workflows: Argo Workflows is widely used for DAG-based data preparation and ML pipelines. By setting Volcano as the designated scheduler for specific workflow pods or steps, Argo gains enterprise multi-tenant batch scheduling , gang scheduling (crucial for multi-node GPU training synchronization), and queue-based fair sharing across organizational teams.
• Ray (via KubeRay on Kubernetes) : While Ray is a distributed compute framework rather than a traditional linear pipeline engine, KubeRay orchestrates end-to-end data processing, heavy preprocessing (Ray Data), and distributed deep learning training (Ray Train) inside Kubernetes. Multi-tenancy and scheduling are handled via Kueue or standard Kubernetes priority classes combined with Ray's internal cluster autoscaling.

If you'd like, let me know:

• Are you looking for a fully integrated open-source stack (like Kubeflow + Volcano) or a commercial platform (like Run:ai)?
• What data volume or preprocessing framework (Spark, Ray, Dask) are you planning to use?

I can help draft a reference architecture or deployment strategy for your specific setup.

Yes. If by cloud-native pipeline platform you mean something that can orchestrate data preprocessing → GPU training → downstream evaluation/deployment, while also supporting multiple teams sharing a GPU/Kubernetes cluster, the strongest options are:

1. Kubeflow — probably the closest match

Kubeflow is the most complete answer if you want an integrated ML platform.

Its current Kubeflow Trainer handles distributed multi-GPU training across PyTorch, JAX, DeepSpeed, Hugging Face, XGBoost and other frameworks. It can integrate with Kueue, Volcano, KAI Scheduler and Coscheduling for gang scheduling and resource management.

Kueue provides the multi-tenant piece: queues, quotas, priorities and admission control, including namespace-scoped and cluster-scoped training runtimes.

Architecture:
Kubeflow Pipelines → preprocessing → TrainJob → Kueue → GPU cluster

Best when: you want a broad, Kubernetes-native MLOps platform rather than merely a GPU scheduler.

---

2. Flyte — strongest workflow-oriented alternative

Flyte is particularly good when pipelines themselves are the central abstraction.

Flyte supports multi-tenancy as a core capability, Kubernetes-native execution, scheduled workflows, and explicit GPU resource requests.

It can also integrate with Kubernetes operators for PyTorch/TensorFlow/MPI, Ray, Spark and Dask, so preprocessing and distributed training don't have to use the same execution engine.

Best when: you have complicated DAGs/data workflows and want strong separation between teams, projects and environments.

---

3. Ray + KubeRay — strongest for distributed AI

Ray with KubeRay is excellent if preprocessing and training are themselves distributed compute workloads.

KubeRay supports GPU nodes, autoscaling and multiple Ray clusters in the same Kubernetes cluster. flyte.orgdocs-legacy.flyte.orgdocs.ray.iodocs.ray.iodocs.ray.io More importantly for your requirement, Kueue can provide gang scheduling, priority scheduling, quotas and preemption for RayJobs/RayClusters.

There is also integration with KAI Scheduler for hierarchical queues, quotas, gang scheduling and GPU sharing across teams.

Best when: you're doing large-scale PyTorch/LLM training, distributed preprocessing, or Ray Data workloads.

---

4. NVIDIA Run:ai — best GPU scheduling layer

NVIDIA's Run:ai is slightly different: I'd view it primarily as the GPU resource-management/scheduling layer, rather than the pipeline authoring platform.

It provides Kubernetes-based scheduling and GPU allocation for distributed training, batch jobs, experimentation and data science workloads. docs.nvidia.com Its ecosystem now includes KAI Scheduler, which provides GPU sharing and multi-tenant queueing/scheduling.

Best when: you already have pipelines—Kubeflow, Argo, Airflow, etc.—and your biggest problem is efficiently sharing expensive GPUs among many teams.

---

My shortlist

If I were evaluating these for a shared enterprise GPU cluster, I'd narrow it to:

1. Kubeflow + Kueue — best all-around ML platform.
2. Flyte + Kueue/Kubernetes scheduling — best workflow/data-platform architecture.
3. Ray/KubeRay + Kueue or KAI — best for distributed AI workloads.
4. Run:ai/KAI + your existing pipeline engine — best if GPU utilization and tenant scheduling are the primary concern.

The important architectural distinction is that pipeline orchestration and GPU scheduling are increasingly separate layers. For example, Kueue can sit underneath Kubeflow or Ray and decide which team's job gets GPUs and when, while Kubeflow/Flyte/Ray determines what the job actually does. This separation tends to be preferable for serious multi-tenant clusters.

If your requirement is specifically “one platform that gives me preprocessing + distributed GPU training + quotas/fair-share + tenant isolation out of the box,” Kubeflow is probably the first one I'd prototype.

Yes. If by cloud-native pipeline platform you mean something that can orchestrate preprocessing → GPU training → evaluation/deployment, while also handling multiple teams sharing a GPU cluster, the strongest options are:

1. Kubeflow — best all-around Kubernetes-native choice

Kubeflow is probably the closest match to your requirements.

Its current Kubeflow Trainer supports distributed multi-GPU and multi-node training, while its ecosystem handles pipeline orchestration and data-processing workloads. Trainer can integrate with Kueue, Volcano, Coscheduling, and NVIDIA KAI Scheduler for gang scheduling, queues, quotas, and resource management.

The important distinction is that Kubeflow itself isn't the scheduler. A production architecture commonly looks like:

Kubeflow Pipelines → preprocessing jobs → Kubeflow Trainer → Kueue/KAI/Volcano → GPU cluster

This gives you strong tenant/team isolation and GPU-aware scheduling.

2. Flyte — best workflow-centric alternative

Flyte is particularly attractive if you want the pipeline abstraction to be the center of the platform.

Flyte is explicitly multi-tenant at its core, with projects/domains used to separate teams and environments.

It works well for pipelines such as:

ingest → preprocess → feature generation → GPU training → validation → model registration

You can then use Kubernetes GPU resources and complementary schedulers for the underlying compute. I'd choose Flyte over Kubeflow if workflow composition, typing, reproducibility, and developer experience matter more than having the broadest integrated ML platform.

3. Ray + KubeRay — best for distributed GPU workloads

Ray with KubeRay is another very strong option, particularly for large-scale training and data processing.

KubeRay provides Kubernetes-native RayCluster/RayJob resources and supports heterogeneous nodes including GPUs. docs.ray.io Ray Data is also well suited to distributed preprocessing.

For multi-tenancy, KubeRay can integrate with Kueue, Volcano, and NVIDIA KAI Scheduler. KAI provides queues, quotas, priorities, gang scheduling, and even GPU sharing across Ray workloads.

A particularly capable stack is:

KubeRay + Ray Data + Ray Train + Kueue/KAI

I'd favor this if your workloads are heavily distributed-data / distributed-training oriented.

4. ClearML — good if you want a more packaged MLOps experience

ClearML provides pipelines, experiment management, GPU execution, and Kubernetes integration. Its Enterprise offering supports multi-node scheduling across Kubernetes nodes for distributed training.

It's generally easier to approach as an MLOps platform than assembling all the Kubernetes primitives yourself, but the deepest multi-tenant GPU scheduling capabilities are more dependent on its Enterprise functionality and your underlying Kubernetes scheduler.

5. Argo Workflows + Kubernetes/Kueue — best composable approach

If you don't actually need an integrated ML platform, Argo Workflows + Kubernetes + Kueue + Kubeflow Trainer/KubeRay can be an extremely powerful architecture.

For example:

                 ┌── preprocessing ──┐
                 │                   │
Argo Workflow ───┼── feature build ──┼──> GPU training
                 │                   │
                 └── evaluation ─────┘
                                      │
                           Kueue/KAI scheduling
                                      │
                              Shared GPU cluster
                    ┌─────────┬───────┴──────┬─────────┐
                  Team A    Team B          Team C   Team D

The advantage is that workflow orchestration and resource scheduling remain separate concerns. Kueue/KAI can enforce quotas and fairness while Argo handles DAG execution.

My shortlist

If I were evaluating these for a new platform, I'd narrow it to:

1. Kubeflow + Kueue/KAI — strongest integrated ML platform.
2. Flyte + Kubernetes/Kueue — strongest workflow-first platform.
3. KubeRay + Kueue/KAI — strongest distributed GPU/data-processing stack.
4. Argo + Kueue + Kubeflow Trainer/KubeRay — strongest composable architecture.
5. ClearML Enterprise — strongest packaged/commercial MLOps alternative.

One important point: multi-tenancy and GPU scheduling are increasingly handled by Kubernetes-native schedulers rather than by the pipeline engine itself. For example, KAI provides hierarchical queues, quotas, priorities, fairness, gang scheduling and GPU sharing, while Kueue provides quota/admission/preemption semantics.

So if your key requirement is “many teams competing for expensive A100/H100 GPUs with fair quotas and distributed-training gang scheduling,” I'd look especially closely at Kubeflow Trainer + Kueue/KAI and KubeRay + Kueue/KAI.

In the cloud-native ecosystem, true end-to-end ML platforms rarely handle the underlying hardware scheduling entirely on their own. Instead, robust data preprocessing and GPU training pipelines are achieved by combining workflow/pipeline orchestrators with cloud-native, GPU-aware multi-tenant schedulers running on Kubernetes.

The platforms and modular stacks that comprehensively support GPU training, heavy data preprocessing, and multi-tenant scheduling fit into two categories: integrated MLOps platforms and modular Kubernetes-native scheduler ecosystems.

1. Integrated Cloud-Native ML Platforms

• Kubeflow
  • GPU Training & Preprocessing: Highly flexible. Kubeflow Training Operator natively supports distributed GPU training (PyTorch, TensorFlow, XGBoost). Data preprocessing steps are typically defined using Kubeflow Pipelines (KFP) running containerized steps on CPU pools before passing data artifacts to GPU nodes.
  • Multi-Tenant Scheduling: Relies on Kubernetes RBAC, Profiles, and integrates cleanly with advanced batch schedulers like Volcano or Kueue for queueing and multi-tenant quotas.
• Red Hat OpenShift AI (integrated with upstream components)
  • GPU Training & Preprocessing: Combines Data Science Pipelines (based on Argo) with the NVIDIA GPU Operator to run heavy preprocessing and deep learning training seamlessly.
  • Multi-Tenant Scheduling: Excellent enterprise-grade multi-tenancy. Uses specialized tools like the KAI Scheduler (KAI) and namespace/quota guardrails to safely manage fractional and multi-tenant GPUs (MIG or time-slicing) across multiple internal teams.
• Run:ai (NVIDIA)
  • GPU Training & Preprocessing: Provides deep abstraction over containerized pipelines, allowing dynamic allocation where preprocessing uses CPU/smaller slices and training scales up to multi-node, multi-GPU pools.
  • Multi-Tenant Scheduling: Purpose-built for multi-tenancy. It introduces a specialized scheduling layer over Kubernetes that handles hierarchical quotas, over-quota borrowing, preemption, and fine-grained GPU sharing (fractional GPUs, MIG, and time-slicing) explicitly designed to eliminate idle cluster time.

2. The Modern Modular Stack (Kubernetes-Native Schedulers + Pipeline Engines)

Rather than relying on a monolithic platform, standard enterprise architecture heavily favors decoupling the pipeline engine from the scheduler layer:

• The Pipeline Engines (Preprocessing & Training Execution):
  • Argo Workflows: The de facto standard engine for cloud-native DAG pipelines. Handles massive parallel CPU-based data preprocessing steps and triggers downstream GPU training pods seamlessly.
  • KubeRay: Specifically built for distributed Ray workloads on Kubernetes, handling distributed data processing (Ray Data) and distributed heavy GPU training (Ray Train) natively.
• The Multi-Tenant GPU Schedulers (The Multi-Tenancy & Hardware Layer):
  • Kueue: A CNCF project providing Kubernetes-native batch job queueing, managing multi-tenant quotas, strict fair sharing, and preemption so CI/CD or preprocessing jobs don't starve production GPU training.
  • Volcano: A powerful batch scheduler optimized for high-performance AI and big data workloads, featuring native gang scheduling (crucial for multi-node distributed GPU training) and topology-aware placement.
  • HAMi / KAI Scheduler: Provide fine-grained device virtualization and intelligent scheduling policies to carve up GPUs (via MIG or memory/compute percentages) across separate multi-tenant namespaces safely.

To help narrow down the ideal architecture for your team, do you prefer a fully integrated platform (like Kubeflow or OpenShift AI) or a modular Kubernetes stack (combining Argo/KubeRay with Kueue/Volcano)? Also, are you utilizing NVIDIA MIG or time-slicing for your multi-tenant isolation?