Kubernetes AI Conformance Is a Listing. Acceptance Is Still Yours to Record.

13 MIN READ
ARCHITECT'S BRIEFExecutive summary for technical decision-makers
Kubernetes AI conformance listing badge beside an empty operator acceptance record
A listing records a reported status. The acceptance record is still blank.

Kubernetes AI conformance gives an operator a listing, not an acceptance record. A listing says a vendor filed a statement against a versioned checklist and that the statement sits in the program’s repository. An acceptance record says the evidence behind that statement is sufficient for a named workload, on a named platform, at a named Kubernetes version. This post reads the 24 submissions filed against Kubernetes v1.35, states what the program establishes about them and what it leaves open, and sets out where the operator’s own test begins.

Everything below is bound to one repository state and one version. The submissions repository, cncf/k8s-ai-conformance, was read at commit c64e5bc (October 29, 2026) and the requirements repository, kubernetes-sigs/ai-conformance, at fd9ba2d (November 3, 2026), both re-checked on November 13, 2026. The v1.36 and v1.37 submissions are out of scope, and so is every platform comparison: the counts are aggregated and no product is named.

What Kubernetes AI Conformance Requires

The Kubernetes AI conformance program began as a Kubernetes working group and now runs as a subproject of Kubernetes SIG Architecture, according to the SIG Architecture write-up of October 29, 2026. Requirements live in one repository and submissions in another. A vendor files a PRODUCT.yaml for a product and a Kubernetes version, and that file carries, for every requirement, a status, a list of evidence references and a notes field.

The v1.35 checklist has twelve requirements: nine MUST and three SHOULD. It covers the Kubernetes layer of AI infrastructure architecture: accelerator access, inference networking, scheduling, observability, security and operator behavior. It says nothing about model quality, GPU supply, fabric or storage.

Table 1: The v1.35 checklist

Requirement IDLevelAreaAsks the platform to
dra_supportMUSTAcceleratorsSupport Dynamic Resource Allocation APIs
driver_runtime_managementSHOULDAcceleratorsProvide a verifiable mechanism for compatible drivers and container runtime configuration
gpu_sharingSHOULDAcceleratorsProvide at least one defined GPU sharing strategy, where the accelerator supports static sharing
virtualized_acceleratorSHOULDAcceleratorsExpose and manage virtualized accelerators such as vGPU, where supported
ai_inferenceMUSTNetworkingSupport Gateway API with an implementation for advanced inference traffic management
gang_schedulingMUSTScheduling and orchestrationAllow installation and operation of at least one gang scheduling solution
cluster_autoscalingMUSTScheduling and orchestrationWhere a cluster autoscaler exists, scale accelerator node groups
pod_autoscalingMUSTScheduling and orchestrationWhere HorizontalPodAutoscaler is supported, make it work for accelerator pods
accelerator_metricsMUSTObservabilityAllow installation of an accelerator metrics solution
ai_service_metricsMUSTObservabilityDiscover and collect workload metrics in a standard format
secure_accelerator_accessMUSTSecurityIsolate and mediate container access to accelerators through Kubernetes resource management
robust_controllerMUSTOperatorShow that at least one complex AI operator with a CRD installs and runs reliably

Levels move between versions, so the checklist is a versioned artifact. In the version files in kubernetes-sigs/ai-conformance, driver_runtime_management is SHOULD in v1.35 and MUST in v1.38, and dra_support, a v1.35 MUST, does not appear in v1.36 through v1.38. A v1.35 listing is read against the v1.35 checklist and nothing else.

What the 24 v1.35 Submissions Report

The v1.35 folder holds 24 submissions and 285 requirement rows. Table 2 aggregates what Kubernetes AI conformance submitters wrote in the status field.

Table 2: Reported status, v1.35 submissions

Row classRowsImplementedBlankN/ANot Implemented
MUST (9 requirements)216216000
SHOULD: driver_runtime_management2322100
SHOULD: gpu_sharing2317510
SHOULD: virtualized_accelerator2314522
SHOULD total69531132

One submitter filed only the nine MUST rows and omitted the three SHOULD requirements, so the SHOULD total is 69 rather than 72. The current script reports a missing requirement row as an error; whether that check existed when that submission merged is not established.

Status variation in v1.35 submissions: MUST rows, 216 of 216 Implemented; SHOULD rows, 69 split into 53 Implemented, 11 blank, 3 N/A and 2 Not Implemented
Status variation sits only in the SHOULD rows.

⚠ COMMON MISTAKE

These counts describe what submitters filed. The folder holds submissions, not every platform that runs AI workloads on Kubernetes, and a platform absent from it has not failed anything. Read the pattern as a record of reported statements, not as a market survey.

The MUST Rows Report No Variance

All 216 MUST rows report Implemented. Three things sit behind that figure, and they should stay separate.

01 — OBSERVED

Every v1.35 submission reports every MUST row it filed as Implemented.

02 — CURRENT VALIDATOR BEHAVIOR (AT c64e5bc)

The script requires a MUST row to be Implemented. The one exception is N/A on cluster_autoscaling, which needs a justification in the notes field and raises a review warning.

03 — NOT ESTABLISHED

The record does not show which version of the script ran against each v1.35 submission, or whether every submission was checked under the current rule. The workflow validates the product directories changed in a pull request, so the rule applied is the one current when that pull request ran.

The result is a uniform reported status. It is not proof that 216 rows were independently tested, and it is not proof that every submission passes today’s script. A column with no variation cannot separate one submission from another either, which is why the MUST rows work as an entry condition and not as a discriminator. In one submission a MUST row reports Implemented while its own notes say the component does not apply on that platform, a small illustration that the status field and the notes can carry different statements.

The rows also state less than they appear to. The gang_scheduling row asks for at least one installable and operable solution. Which solution the operator runs, and how it is sized against the workload’s queue behavior, are separate decisions, covered in GPU scheduling in Kubernetes.

The SHOULD Rows Carry All Status Variation

Every blank, N/A and Not Implemented in the folder sits in a SHOULD row: 16 of the 69. They are three different statements, and a reader who collapses them loses information.

A blank is no statement. The current script skips a SHOULD row whose status and evidence are both empty, so an unanswered row passes. N/A is a claim that the condition does not apply, and the script requires a non-empty justification for it. Not Implemented is an explicit negative. Of the three SHOULD requirements, virtualized_accelerator carries the most variation, with nine of 23 rows not reporting Implemented: five blank, two N/A and two Not Implemented. gpu_sharing follows with six. Both are written as conditional on what the accelerator supports, which is where an N/A is plausible and where a blank is hardest to read.

What a Status Does and Does Not Establish

Table 3 puts the Kubernetes AI conformance program’s evidence beside the claims that evidence cannot carry. The left column states what the record supports. The right column states what it does not.

Table 3: What the record can and cannot support

EvidenceWhat we can sayWhat we cannot say
Checklist (every version)The checklist defines a level, status, evidence and notes field for each requirement, and the submitter supplies the reported valuesThat a status is more than the submitter’s statement unless it is corroborated
A v1.35 submissionThe submitter reports a status and may provide evidence references. In the 24 folders the evidence takes several forms: external links, in-folder files, both, and a handful of Implemented rows with an empty evidence fieldThat the evidence was independently tested, or that the 24 submissions were processed by test-artifact validation
Program rules (verified November 13)At c64e5bc, a MUST row must be Implemented, with the conditional cluster_autoscaling exception. The script does not require an evidence entry for an Implemented row, and it checks web links for reachability, not content. The restriction on N/A for MUST rows was committed on September 24, 2026; an earlier commit, September 18, 2026, had accepted N/A on any MUST row with a justificationThat the 24 v1.35 submissions were validated by this version of the script, or that blank, N/A and Not Implemented SHOULD rows mean the same thing
Test-artifact guidance and validator behaviorTest artifacts are recommended and manual attestation is allowed. The script’s version gate controls only the recommendation warning. Recognized artifacts are checked whenever a submission cites them, and a failing test is an error, as is a skipped test on an Implemented rowThat testing is uniform across accelerator types, since the driver runtime test covers NVIDIA only, or that a given submission cited an artifact
Upstream suiteA test exists for every MUST requirement, per a documentation update dated November 3, 2026That any given submission ran it
The whole patternCounts of what 24 submitters reportedThat every platform passed independent testing, that Implemented proves production capability, or that all SHOULD rows are equally verified

For a v1.35 listing, the available program documentation does not establish that the program independently verified each submission’s evidence. The vendor supplies the submission and evidence; the operator retains responsibility for deciding whether that evidence is sufficient for the workload being accepted. Three parties stay distinct: the vendor’s evidence obligation, the program’s conformance process, and the operator’s acceptance decision. None of this says the program does nothing, and the next section sets out what it does.

How the Program Verifies Claims, by Version

Kubernetes AI conformance does real work on every submission. A submission arrives as a pull request. A validator workflow runs against the directories that pull request changed, and the script checks that statuses are valid values, that MUST rows meet the rule above, that an N/A carries a justification, that in-folder evidence files exist and that web evidence links respond. From v1.37 the documentation recommends test artifacts for requirements that have an automated test. I found no description of a review step beyond the validator workflow, so this post makes no claim about one, in either direction.

v1.35 and Earlier: Documentation and Evidence URLs

The version boundary comes first, because the mechanism changes at it. The program’s README describes certification for versions before v1.37, and for requirements without an automated test, as documentation-backed self-assessment. In plain terms, for v1.35 the record contains documented requirement statuses and may contain submitter-provided evidence references; the available record does not establish that each submission’s evidence was independently tested. That sentence is not a full description of the v1.35 certification process, and nothing here projects the later mechanism backward onto it.

Test Artifacts and Hybrid Verification

Four facts bear on verification, and each stands alone.

01 — UPSTREAM TESTS EXIST

The test/ directory in kubernetes-sigs/ai-conformance holds an automated suite, and a documentation update dated November 3, 2026 states that a test exists for every MUST requirement. The driver runtime test covers NVIDIA only. The submissions validator’s own mapping from requirement to upstream test is still being extended: an open pull request on November 13 adds the mapping for ai_inference.

02 — GUIDANCE RECOMMENDS ARTIFACTS FROM v1.37

The documentation recommends junit.xml, results.json or e2e.log for requirements with an automated test, calls hybrid verification recommended rather than required, and continues to allow manual attestation.

03 — VALIDATOR CHECKS RECOGNIZED ARTIFACTS AT ANY VERSION

At c64e5bc the v1.37 threshold gates only the recommendation warning. When an evidence entry points to a recognized test artifact, the script parses it whatever the version, and a failing test is an error, as is a skipped test on an Implemented row. Artifact validation entered the script on September 8, 2026.

04 — EXECUTION AGAINST A SUBMISSION IS SEPARATE

The first three facts describe tests that exist, guidance that exists and a script that behaves a certain way. None of them establishes that a given submission was run through that workflow.

No sentence in this post should be read as saying the 24 v1.35 submissions went through test-artifact validation. The record read does not show that they did.

What the Documentation Does Not Show

Two of the 24 v1.35 folders contain test-derived files: one holds an e2e.log and a junit_01.xml, and one holds per-test output.md files. The other 22 do not. The presence of those files does not establish that the script recognized or processed them, because its artifact handling applies to the artifact types it names and to evidence entries that point to them. Which script version ran against any v1.35 submission is not established either, since the workflow validates directories changed in a pull request and artifact validation did not exist before September 8, 2026. I did not pull pull-request dates or check-run history for the 24 folders. That is the one check that would move the fourth fact above, and it stays open.

The Acceptance Decision: Where the Operator’s Test Begins

The operator’s decision is narrow and concrete: can the operator accept a v1.35 listing as sufficient evidence for this workload, or must the operator obtain and evaluate additional evidence before recording acceptance? Kubernetes AI conformance answers neither half. The listing supplies inputs to the answer, and Table 4 turns those inputs into a record.

Table 4 is a proposed operator method. It is this post’s analysis and is not program guidance, and no part of the program prescribes it.

Table 4: A proposed acceptance record for a v1.35 listing

Row classWhat the program establishesWhat the operator still owes
MUSTA reported Implemented status, which the current script requires, subject to the conditional cluster_autoscaling exceptionTreat it as an entry condition, not a discriminator. For the conditional rows (cluster_autoscaling, pod_autoscaling), check the platform’s actual configuration for this workload. Where a MUST row carries no evidence reference, obtain one before relying on it
SHOULD ImplementedA reported status and, where the submitter provided one, an evidence referenceRead the reference against the workload’s actual dependency. With no reference, treat the row as an unsupported statement until evidence is obtained
SHOULD blankNo statement. The current script skips a SHOULD row with empty status and evidenceObtain a written answer before recording acceptance for any workload that depends on the capability
SHOULD N/AA claim that the condition does not apply, with a justification the script requiresRead the justification and decide whether the condition really does not apply to this hardware and workload
SHOULD Not ImplementedAn explicit negativeAssess the effect on the workload, then accept the gap, compensate for it or decline
Version bindingA listing for one product and one Kubernetes versionRecord the platform version, the Kubernetes minor version and the submission the acceptance rests on. A v1.35 listing does not carry to another version
Post-upgrade re-checkNothing. A listing is a point-in-time submission, and the workflow validates only directories changed in a pull requestRe-run the acceptance record after an upgrade, against a new listing for the new version or against your own evidence
Boundary between what the Kubernetes AI conformance program establishes and what the operator still owes
The program states and checks; the operator decides and records.

The rows divide work by who can do it. The program can state what a status is and what the script requires. Only the operator knows which SHOULD row the workload depends on, which Kubernetes version will actually run and what an upgrade changes. Placing that mapping inside the Runtime and Cluster Orchestration stage of the AI architecture path keeps the acceptance record attached to the layer that owns the scheduling and operator behavior, and the Governance and Runtime Control stage covers who holds the authority to accept a gap once the record shows one.

Node-level qualification after a change, covered in GPU node requalification, is a different validation. It asks whether evidence about a running node still holds after an in-place change, where a conformance listing is a platform-level statement for one version.

Architect’s Verdict

A Kubernetes AI conformance listing is a record of what a vendor reported against a checklist, filed in a repository with a validator in front of it. That is useful and it is real. It is also a different object from an acceptance record, and the gap between them is where the operator’s work sits.

Kubernetes AI conformance for v1.35 has a quiet problem: the uniformity of the MUST column hides it. When 216 of 216 rows report Implemented, the column stops discriminating, and the variation moves into the SHOULD rows and into the evidence behind each status. For v1.35 the available documentation does not show that anyone independently tested that evidence. The Kubernetes AI conformance README describes the earlier versions as documentation-backed self-assessment, and the tests that exist upstream do not reach back to submissions they have not been shown to have touched.

The burden of proof for a v1.35 claim therefore stays with the operator, who is also the only party that knows what the workload depends on. A blank, an N/A and a Not Implemented are three different statements, an Implemented without evidence is a claim waiting for evidence, and an upgrade starts the record over.

Kubernetes AI conformance tells you where to start asking. Acceptance is the record you write after the answers come back.

Additional Resources

Editorial Integrity & Security Protocol

This technical deep-dive adheres to the Rack2Cloud Deterministic Integrity Standard. All benchmarks and security audits are derived from zero-trust validation protocols within our isolated lab environments. No vendor influence.

Last Validated: October 2026   |   Status: Production Verified
R.M. - Senior Technical Solutions Architect
About The Architect

R.M.

Senior Solutions Architect with 25+ years of experience in HCI, cloud strategy, and data resilience. As the lead behind Rack2Cloud, I focus on lab-verified guidance for complex enterprise transitions. View Credentials →

>_ The Dispatch

Get the Playbooks Vendors Won’t Publish

Choose the architecture problems you care about. Get field-tested playbooks and frameworks delivered to your inbox.

  • > AI Infrastructure & Inference Economics
  • > Cloud Strategy & Hidden Cost Models
  • > Virtualization & Deterministic Migration
  • > Kubernetes, IaC & Modern Infrastructure
  • > Data Protection & Recovery Engineering
[+] Select My Playbooks

Zero spam. Includes The Dispatch weekly drop.

>_ Architectural Guidance

Need Architectural Guidance?

Independent review before major infrastructure decisions.

  • > Validate assumptions
  • > Identify hidden dependencies
  • > Quantify migration risk
  • > Challenge vendor narratives
>_ Request Triage Session

Triage · Advisory · Fractional · Direct Hire