Skip to main content
This page explains the Node Pool status fields and how to use them to diagnose a Node Pool that isn’t at its target, whether Nodes are missing or a scale-down is stuck. For the complete field and event schema, see the Node Pool reference.

Node Pool fields

The Node Pool fields show the desired state and status of the Nodes in a Node Pool. To see these fields, run kubectl get nodepool.

Example output

The following is an example output from running kubectl get nodepool.
Example output
The following table outlines each Node Pool’s state:
  • The VALIDATED, CAPACITY, and QUOTA columns summarize the Node Pool’s conditions.
  • In a healthy, fully delivered Node Pool, CURRENT equals TARGET, and both INPROGRESS and QUEUED are 0.
  • PREFILL counts the Nodes marked for prefill and being replaced. It is 0 unless prefill is enabled and one or more Nodes are being replaced. To see the prefill state of an individual Node, check its Prefill condition. See Prefill condition reasons.
  • While a Node Pool is scaling up, the difference between CURRENT and TARGET is split between INPROGRESS (Nodes that are booting) and QUEUED (Nodes that are waiting for capacity). Note that a new Node can take up to 15 minutes to boot before it counts toward CURRENT.

Rack-based Node Pool fields

For rack-based instance types such as GB200 and GB300, the Node Pool also tracks rack counts, where each rack contains 18 Nodes. These fields are populated only for rack-based instance types and appear only in the wide output. To see them, use kubectl get nodepool -o wide:

Node Pool full status

For the full status of a single Node Pool, including its conditions and recent events, use describe:
Example command
Replace [NODE-POOL-NAME] with the name of your Node Pool. Each condition answers one question about the Node Pool. The conditions most useful for diagnosing missing Nodes are the following. A healthy Node Pool shows Validated: Valid, Capacity: Sufficient, Quota: Under, and AtTarget: TargetMet. For the complete list of conditions and every possible status value, see Node Pool conditions.

Common capacity and quota states

The bottom of kubectl describe nodepool [NODE-POOL-NAME] lists recent events. The following events and condition states explain most cases where a Node Pool does not reach its target. Quota events and conditions:

Run a Node Pool health check

When a Node Pool isn’t doing what you expect, collect its counts, conditions, events, and the state of its Nodes before you change anything. The diagnosis steps in the next section refer to these outputs.
Node Pool health check
Replace [NODE-POOL-NAME] with the name of your Node Pool. To inspect one Node, run kubectl describe node [NODE-NAME]. Replace [NODE-NAME] with the name of the Node. The CWActive condition’s message lists the Pods that keep the Node active, and the node.coreweave.cloud/cordonReason annotation records why CoreWeave cordoned a Node. To watch Node Pool status over time instead of polling kubectl, use the Node Pools page in the Cloud Console (https://console.coreweave.com/zones/[ZONE-NAME]/clusters/[CLUSTER-NAME]/node-pools, with your zone and cluster names in the path) or the NodePools and Cluster Autoscaler dashboard in CoreWeave Grafana.

Diagnose a Node Pool that is not at target

Suppose TARGET is 10 but CURRENT is 8. The two missing Nodes are queued, in progress, or nowhere at all, and each case has a different cause and fix. Run kubectl get nodepool, then work through the section that matches what you see. The last two sections cover cases where no Nodes are missing: a pool at target while Pods stay Pending, and a pool above target.

Nodes are queued

If the missing Nodes appear in QUEUED and the CAPACITY column shows QueuedAwaitingCapacity, CKS accepted the request and fills it automatically as capacity becomes available. To learn what this state means and when to contact support, see Common capacity and quota states. Quota also limits how deep the queue can be. Quotas count your whole organization’s Nodes for an instance type, compute class, and zone, so Nodes in one Node Pool consume headroom that another pool might be waiting for. If QUEUED is smaller than you expect (TARGET minus CURRENT minus INPROGRESS), sum the TARGET column across every Node Pool with the same instance type and compute class. Include pools in your organization’s other clusters in the same zone. Then compare the total to your quota before you suspect a capacity or delivery problem. See Resource quotas. A short QUEUED count is the normal result of a quota cap, not an error. When targetNodes exceeds the quota and headroom remains, CKS queues only the headroom and discards the remainder. No warning event fires, but the CWNodeRequestQueued event reports how many Nodes CKS queued, which is the fastest way to confirm a cap. Headroom subtracts both the Nodes your organization already has assigned and the Nodes it already has queued for that instance type, compute class, and zone. A sibling pool with a deep queue leaves you less headroom, not more. Only the request being checked stays out of that total, so CKS doesn’t count it twice. On rack-scale instance types, the cap rounds down to whole NVLink domains. A domain holds 18 Nodes on GB200 and GB300, so headroom of fewer than 18 Nodes queues nothing on those types.

Nodes are in progress

If the missing Nodes appear in INPROGRESS, they’re assigned and booting. Delivering a bare-metal GPU Node takes 5 to 15 minutes from the request to the Node joining the cluster. In the Node Pool’s events, CWNodeAssigned marks the assignment, and CWNodeRegistered marks the Node joining the cluster, which is when CURRENT increases. Replacements follow the same path. If a Node is removed, for example because you deleted an unhealthy Node, CKS queues and delivers a replacement on its own: The events show CWNodeRequestQueued followed by CWNodeAssigned. You don’t need to request the replacement. If INPROGRESS hasn’t moved in well over 30 minutes for a GPU Node Pool, or 15 minutes for a CPU Node Pool, check the events for CWNodeDeliverFail. CKS retries failed deliveries automatically. See Common capacity and quota states.

Nothing is queued or in progress

If CURRENT is below TARGET while QUEUED and INPROGRESS are both 0, read the conditions from the health check:
  • Validated: Invalid: CKS rejected the configuration, most often an instance type that isn’t offered in the zone (the events show CWInstanceTypeNotInZone) or a Node affinity matchFields requirement on a key other than metadata.name (the events show CWNodePoolInvalidNodeAffinity). This check reads matchFields only. A broken matchExpressions block, such as an In operator with an empty value list, leaves Validated at Valid and surfaces on the Capacity condition instead. Applying the manifest still succeeds. These checks run after the API server accepts the Node Pool, so kubectl apply, Helm, and Terraform all report success while the Node Pool sits at Invalid. Check the conditions after every change. To confirm an instance type is offered in a zone, see the Availability matrix.
  • Quota: Over: The organization-wide total of targetNodes for this instance type, compute class, and zone exceeds your quota and no headroom is left, so CKS queued nothing for the request. A request that exceeds the quota while headroom remains behaves differently: CKS caps it to the headroom, queues that many Nodes, and leaves the Quota condition at Under. Seeing Over means the headroom is gone, not that the request was trimmed. See Resource quotas and the quota events table earlier on this page.
  • Quota: NotSet: Your organization has no quota for this instance type, compute class, and zone. CKS queues nothing and emits a CWNoQuota or CWOverQuota event with the message Quota limit is 0. To request a quota, contact support.
  • Capacity: Partial or NoneAvailable: The zone is short of the instance type. The CWInsufficientCapacity event message reports what was assigned, for example Assigned (8 out of 10), while CURRENT reports what has joined. CKS keeps what it assigned and retries the rest automatically. See Common capacity and quota states.
  • Capacity: PartialNodeAffinity or NoneAvailableNodeAffinity: The Node Pool’s affinity constraints ruled out some or all of the Nodes of that instance type in the zone. An affinity that matches nothing lands here rather than on Validated: Invalid, and so do two broken affinities: one CKS can’t interpret, and one that targets a different InfiniBand fabric than the fabric assigned to the cluster. Both of those also emit CWNodePoolInvalidNodeAffinity, so read the event message before you start hunting for zone capacity. See the Capacity condition.
If you have reserved capacity and the Node Pool still won’t fill, the pool’s InfiniBand fabric can be the reason. In zones with more than one InfiniBand fabric, CKS delivers all Nodes of an instance type in a cluster onto the same fabric. Free capacity on a different fabric can’t join the pool. Check which fabric the pool’s Nodes are on:
Show the fabric for each Node in the pool
Replace [NODE-POOL-NAME] with the name of your Node Pool. Build new scripts and dashboards on backend.coreweave.cloud/fabric. The second column covers existing InfiniBand clusters that still carry the older ib.coreweave.cloud/fabric label. CWNodeAssigned events also name the fabric each Node landed on. If your reserved capacity and the pool’s existing Nodes are on different fabrics, contact support to plan the move. For more information about fabric labels, see InfiniBand and RoCE labels.

At target but Pods will not schedule

If CURRENT equals TARGET and the conditions are healthy but Pods stay Pending, the missing capacity is on the Nodes, not the Node Pool. Cordoned Nodes still count toward CURRENT but accept no new Pods. List the pool’s Nodes and look for SchedulingDisabled:
Find cordoned Nodes in the pool
Replace [NODE-POOL-NAME] with the name of your Node Pool. CoreWeave cordons Nodes for health and maintenance reasons. Read the node.coreweave.cloud/cordonReason annotation and see Node cordoning for what to do next. To see what’s waiting, list the Pending Pods with kubectl get pods --all-namespaces --field-selector status.phase=Pending. Compare their GPU requests against what the schedulable Nodes can hold, and either scale the Node Pool up or reduce replicas while CoreWeave replaces the cordoned Nodes.

Current is above target

If CURRENT is above TARGET, a scale-down is pending. CKS removes Nodes according to the Node Pool’s scaling strategy, and a delay of a few minutes after you lower the target is normal. If prefill is enabled, CURRENT also runs above TARGET while CKS provisions replacement Nodes. Check the PREFILL column before you diagnose a stuck scale-down. If the Node Pool stays above target and its events repeat CWNodePoolRemoveNodes with the message No nodes eligible for removal right now, the default IdleOnly strategy found no idle Nodes to remove. Check the CWActive condition on each Node with the health check commands, then run kubectl describe node [NODE-NAME] on an active Node. The CWActive message lists the Pods keeping it active, up to five names followed by a count of the rest. Any Pod in the Running or Pending phase counts as activity unless CKS exempts it. Exemptions include DaemonSet Pods and Pods labeled interruptible. Two cases might surprise you:
  • A Pod stuck in CrashLoopBackOff keeps its Node active even though it does no useful work. Delete the Pod, or scale down the Deployment that recreates it.
  • Idle GPUs don’t make idle Nodes. With IdleOnly, a Node is eligible for removal only when every counted Pod is gone. Workloads spread thinly across many Nodes can block scale-down even when most GPUs sit unused. Consolidate workloads, or switch the strategy to PreferIdle.
Also check spec.minNodes. With autoscaling enabled, the autoscaler never takes the pool below it. If every Node shows CWActive: False and the Node Pool still hasn’t scaled down after about 10 minutes, contact support.

When to contact support

Some states aren’t yours to fix. Contact support when you see any of the following:
  • A CWNodePoolDisabled event. Despite the event message about configuration issues, repeated delivery failures usually cause this state. The disabled object is the Node Pool’s Node Profile, which support re-enables or replaces.
  • QUEUED that doesn’t move and no Nodes reaching INPROGRESS, while Quota is Under.
  • Any condition stuck at InternalError that doesn’t clear on its own.
  • AtTarget: UnderTarget while Capacity is Sufficient and nothing is queued or in progress.
  • Idle Nodes (CWActive: False) that CKS still hasn’t removed about 10 minutes into a scale-down.
Include the Node Pool name, instance type, and zone in your ticket, plus the conditions and recent events from the health check commands. That output usually lets support act without asking you for more information.
Last modified on August 26, 2026