The Kubex
Automation Engine

Policy-driven rightsizing for CPU, memory, and GPU. Admission-time mutation and proactive resize execution, with enterprise-grade safety built into every step.

How it works

Five Steps from Recommendation to Action

The automation engine continuously evaluates workloads and executes rightsizing safely, with no human in the loop required.

01

Pull Recommendations

Pulls ML-driven rightsizing recommendations from the Kubex platform via the Gateway API.

02

Evaluate Policy

Reconciler matches each workload against Proactive, Static, Rollback, GPU, and Pod Affinity policies; a referenced AutomationStrategy defines how automation executes.

03

Run Safety Checks

Multiple guardrails and filters protect every resize attempt, spanning HPA, ResourceQuota, LimitRange, node headroom, workload availability, readiness, and namespace guards.

04

Execute

Uses in-place container resize on supported Kubernetes 1.33+ clusters, with eviction-based fallback when in-place resize is unavailable and eviction is allowed.

05

Monitor & Rollback

Supports rollback monitoring and backoff when a matching rollback policy is configured, so unhealthy changes can be reverted.

HPA Awareness

Blocks CPU changes that conflict with HPA-managed scaling, preserving autoscaler stability.

ResourceQuota Validation

Validates proposed changes against namespace quotas, so automation never pushes a namespace over its ceiling.

LimitRange Enforcement

Checks recommended values fall within LimitRange bounds before applying, preventing admission failures.

Node Capacity Checks

Validates live node headroom exists before triggering any pod eviction or resize.

Workload Availability Protection

Honors PodDisruptionBudgets and maxUnavailable during eviction-based resize, keeping minimum replicas available throughout.

Readiness Validation

Confirms pods are ready before resizing, then re-checks after to catch regressions.

Protected Namespace Controls

Excludes system namespaces via configurable glob patterns (default: kube-*).

Proactive Policies

Apply ML-driven recommendations from the Kubex platform to right-size workloads automatically.

Static Policies

Enforce user-defined static resource requests and limits on target workloads.

Rollback Policies

Monitor resize operations and automatically revert unhealthy changes based on readiness and adoption thresholds.

GPU Policies

Rightsize KAI Scheduler GPU fractions, consolidate GPU workloads at low utilization, and rebalance allocations based on sustained usage.

Pod Affinity Policy

Controls node placement for automated workloads.

Automation Strategies

Referenced by Proactive and Static policies to centrally configure how automation executes: safety guardrails, scheduling, enablement toggles, and resize method selection.

Smart Pause Controls

Pause per pod or workload via annotations for learning periods, canary rollouts, or permanent exclusions.

Enablement Gates

Per-direction flags for upsize-only, downsize-only, or full bi-directional automation, with no separate policy required.

Cluster & Namespace Scope

Namespaced strategies for teams, or ClusterProactivePolicy with label selectors for fleet-wide defaults.

Zero-Downtime Optimization

In-place container resize on Kubernetes 1.33+, with eviction-based fallback when in-place resize is unavailable and eviction is allowed.

Rollback Protection

When a matching rollback policy is configured, resizes are monitored with backoff so unhealthy changes can be reverted.

Admission-Time Mutation

Webhook applies recommendations at pod creation, so new pods start right-sized immediately.

Continuous Reconciliation

Controller loop evaluates all eligible workloads on configurable rescan intervals, adapting to fresh ML recommendations.

KAI GPU Fraction Rightsizing

Automatically adjusts KAI Scheduler GPU fractions based on observed usage. Upsizes when demand grows, scales back when it drops.

Sharing-Aware GPU Observability

Workload-level visibility into compute and memory consumption relative to allocated fractions, beyond what DCGM exporters see.

Active Rebalancing

Moves shared GPU requests as demand shifts, turning GPU sharing into a continuous loop instead of a one-time config.

Fair-Use & Noisy-Neighbor Protection

Policy-based allocation adjustment that keeps shared GPUs safe to densify. (This one is really a guardrail. You could place it in the Guardrails section instead for reinforcement.)

KAI-Aware Bin Packing & Node Consolidation

Identifies underutilized GPU nodes and packs shared workloads to shrink the GPU footprint.

Hardware Partitioning Support

MIG, time-slicing, and MPS.

GPU Optimization

Rightsizes GPU requests & limits via NVIDIA KAI Scheduler, with MIG, time-slicing, and MPS supported.

GitOps Friendly

All configuration lives in CRDs. Layer policies via GitOps or kubectl alongside Helm-managed defaults.

RBAC Integrated

Least-privilege Kubernetes RBAC. Namespace teams manage their own strategies without cluster-wide access.

Broad Workload Coverage

Deployments, StatefulSets, DaemonSets, CronJobs, Rollouts, Jobs, and StrimziPodSets.

# Add the Kubex Helm repo
helm repo add kubex https://densify-dev.github.io/helm-charts
helm repo update

# Install CRDs first
helm install kubex-crds kubex/kubex-crds \
  --namespace kubex --create-namespace

# Install the automation engine
helm install kubex-automation-engine kubex/kubex-automation-engine \
  --namespace kubex \
  --set global.kubexUrl="https://your-tenant.kubex.ai" \
  --set global.kubexApiToken="<your-token>"

# Verify health
kubectl get globalconfiguration global-config -o yaml
kubectl get events -A --field-selector reason=PrecheckFailed

apiVersion: rightsizing.kubex.ai/v1alpha1
kind: ProactivePolicy
metadata:
  name: team-a-proactive
  namespace: team-a
spec:
  scope:
    labelSelector:
      matchLabels:
        app.kubernetes.io/part-of: storefront
    workloadTypes:
      - Deployment
      - StatefulSet
  automationStrategyRef:
    name: team-a-balanced
  safetyChecks:
    maxAnalysisAgeDays: 3

apiVersion: rightsizing.kubex.ai/v1alpha1
kind: AutomationStrategy
metadata:
  name: team-a-balanced
  namespace: team-a
spec:
  enablement:
    cpu:
      requests:
        downsize: true
        upsize: true
    memory:
      requests:
        downsize: true
        upsize: true
  inPlaceResize:
    enabled: true
    containerRestart: false
  podEviction:
    enabled: true
    retryPodDisruptionBudget: true

Reduce Costs

Eliminate over-provisioned CPU and memory, the most common source of wasted cluster spend.

Increase Efficiency

Higher cluster density through tighter resource allocation: more workloads per node, fewer idle resources.

Boost Productivity

Remove manual rightsizing from engineering workflows, so teams focus on features, not spreadsheets.

Maintain Reliability

Multiple safety checks and policy-driven rollback mean optimization never compromises availability.

Maximize GPU Yield

Run more inference on the GPUs you already have.

Ready to automate Kubernetes and GPU optimization?

Deploy the Kubex Automation Engine in minutes with a single Helm chart.

The Kubex Automation Engine