Support New AI Frameworks Faster Using NVIDIA Workload Map

NVIDIA has published Workload Map, an open source component of its DSX AI Factory Platform, as a Kubernetes custom resource definition (CRD) paired with a Go library that turns framework-specific objects into a uniform structural view. The CRD's resource kind is still Karta, its earlier name. The code sits in the dsx-ai-factory/workload-map repository under the Apache 2.0 license, and NVIDIA says the technology is already used in production within its Run:ai platform.
The problem it targets is familiar to anyone who has built schedulers, controllers, dashboards, or cost tooling for Kubernetes AI workloads. A distributed training job or multi-node inference server is rarely one pod; it is a tree of resources, each with a role, a replica count, a pod template, and a status that depends on the workload type. JobSet, LeaderWorkerSet, PyTorchJob, and other custom resources each encode that shape differently, so a tool must learn each schema before it can interpret or manage it. NVIDIA's argument, drawn from its Run:ai team's own experience, is that this becomes an ongoing roadmap cost: every new framework a customer adopts requires another adapter, which is why support for new workload types tends to arrive only with a release.
The design move is to push workload knowledge out of compiled Go adapters and into YAML. A workload definition declares where pod templates live, how replica counts are computed, how instances are named, and how native status conditions map onto a shared vocabulary. Consumers load the definition and act on it. Definitions can be written, reviewed, and applied to a cluster like any other manifest, and a new framework can be supported by authoring YAML rather than shipping code.
A catalog ships with prebuilt, tested definitions for JobSet, PyTorchJob, RayCluster, RayJob, RayService, KServe, Knative, MPIJob, NVIDIA NIM, LeaderWorkerSet, Milvus, Grove PodCliqueSet, and NVIDIA Dynamo. The library resolves a live object against its definition to extract pod templates, replica counts, status, and metadata, to update pod specs, labels, and annotations across instances, and to expose the hierarchy.
A worked JobSet example shows how the status mapping works. JobSet does not report a plain Running condition, so the shipped definition derives one with a jq expression over .status.replicatedJobsStatus, requiring at least one ready and active Job with none failed, and maps JobSet's native Completed and Failed conditions onto the shared categories consumers already handle. Child component definitions use paths such as .spec.replicatedJobs[].template.spec.template for the pod template and name each instance from .spec.replicatedJobs[].name, giving roles like leader and worker rather than three anonymous Jobs. Scaling is also jq-based: pods per replicated Job equal replicas times parallelism.
The post demonstrates three consumers sharing one JobSet definition. A CLI, installed on macOS or Linux via Homebrew from the dsx-ai-factory/kli tap, reads workloads through the built-in catalog using a kubeconfig and prints the resolved tree with roles, readiness, per-role and total GPU requests, and node placement. That inspection path does not require installing anything into the cluster. KAI Scheduler uses optional gang-scheduling instructions in a definition, naming the pod group and its subgroups, to enforce gang admission and make placement decisions; NVIDIA describes this as a fallback in its pod grouper for workload types lacking a native plugin, with native plugins taking precedence. In Run:ai, a single API call registers the workload type from the same catalog definition, so the platform presents the JobSet as one workload with its 12-GPU total and structure, with no extra code. Adoption extends beyond NVIDIA: Elotl's Nova uses Workload Map to interpret workload structure and resource requirements when choosing a cluster for distributed workloads across clusters.
For developers, the practical consequence is that a tool written against the Workload Map interface can handle any catalog-covered framework without a bespoke parser, and a custom in-house operator can be supported by contributing or adapting a definition. This suggests the approach is best suited to the layer that only needs the structure of a workload — inventory, cost attribution, dashboards, capacity planning, cross-cluster placement, and generic gang scheduling — rather than controllers that need deep framework behavior. A likely trade-off is that jq expression paths and status mappings become part of the contract: a framework that changes its CRD schema in a new version could break a definition until it is updated, so teams may need to pin and test catalog entries as they upgrade operators. Another is dependency on the catalog's coverage; anything outside it still needs a new YAML definition, though that is a far smaller task than writing an adapter. The reliance on jq evaluation also means interpretation carries some runtime cost and expressiveness limits compared with hand-written Go, though NVIDIA positions the library as a fallback where native code exists.
Why it matters: platform teams running mixed Kubernetes AI stacks currently pay an adapter tax for every new framework, and a shared declarative description could move that work from quarterly releases into reviewable manifests. Teams building schedulers, dashboards, and cost or capacity tools are the immediate audience, along with anyone selecting clusters for distributed jobs. My inference is that the real test will be how quickly community definitions keep pace with CRD churn in fast-moving frameworks, since the model's value depends on the catalog staying current.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
NVIDIA DSX AI Factory Platform brings together technologies to help the ecosystem design, build, and operate more efficient AI factories, including open source,...