Concept · Spec complete

Know before you deploy.

A complete concept for deterministic and AI-assisted Kubernetes validation: scheduling simulation, capacity reasoning, and CI checks before deployment.

Discuss the concept Read the architecture

The kubectl gap

kubectl apply --dry-run kubectl apply --dry-run validates YAML syntax. It tells you nothing about whether your cluster can actually run the workload.

Will the deployment fit? Are there enough resources? Will it trigger autoscaling? Will pod anti-affinity rules prevent scheduling? Will it evict existing workloads?

Today, you deploy and find out. PRELUDE lets you know before.

Three layers of validation

Deterministic Engine

Pure computation. Parses manifests, calculates resource requirements, simulates the Kubernetes scheduler. No AI needed — this is math. Request/limit analysis, node affinity matching, topology spread constraints, PVC binding validation.

AI Reasoning

Two specialized agents. The Architecture Agent evaluates deployment patterns, identifies anti-patterns, and suggests improvements. The Capacity Agent predicts scaling behavior, estimates costs, and models growth scenarios. Agents communicate via A2A Protocol.

Integration

REST API for CI/CD pipelines. CLI tool for developers. ArgoCD PreSync hook for GitOps workflows. MCP server for AI-assisted operations.

How it fits together

The deterministic engine provides the foundation — reliable, fast, no external API calls needed. AI reasoning sits on top as an optional enhancement, providing pattern analysis and capacity predictions. Integration points connect PRELUDE to your existing CI/CD pipeline.

Simple to use

A single command validates your deployment against your actual cluster state.

terminal

# Validate a deployment against your cluster
prelude validate deployment.yaml --cluster prod-gke

# Output
✓ Manifest parsed (Deployment: api-server, 3 replicas)
✓ Resource requirements: 1.5 CPU, 3Gi memory (total)
✓ Scheduling simulation: all 3 replicas schedulable
✓ Node pool: e2-standard-4 has capacity (62% utilized → 74%)
⚠ Warning: No PodDisruptionBudget defined
⚠ Warning: Memory request/limit ratio is 1:4 (burst risk)

# With AI reasoning enabled
prelude validate deployment.yaml --cluster prod-gke --ai

✓ Deterministic validation passed
✓ AI Architecture Agent: deployment pattern is sound
⚠ AI Capacity Agent: at current growth rate (12%/mo),
  node pool will need scaling in ~18 days
  Recommendation: increase node pool max from 5 to 8

Capabilities

Ten capabilities across three layers of validation.

Manifest parsing

Deterministic

Deployments, StatefulSets, DaemonSets, Jobs, CronJobs.

Resource calculation

Deterministic

CPU, memory, GPU, ephemeral storage across all replicas.

Scheduling simulation

Deterministic

Node affinity, anti-affinity, taints, tolerations, topology spread.

PVC binding validation

Deterministic

StorageClass availability, capacity, access modes.

Conflict detection

Deterministic

Port conflicts, resource name collisions, quota violations.

Pattern analysis

Deployment anti-patterns, best practice recommendations.

Capacity prediction

Growth modeling, scaling timeline, cost estimation.

Risk assessment

Eviction probability, OOM risk, scheduling failure scenarios.

CI/CD integration

Integration

REST API, CLI exit codes, ArgoCD PreSync hook.

MCP server

Integration

AI-assisted operations through Model Context Protocol.

Filling the validation gap

PRELUDE operates where existing tools stop — beyond syntax, into actual cluster capacity.

	PRELUDE	kubectl dry-run	Datree/Checkov	Kubecost
Syntax validation	true	true	true	false
Policy validation	Planned	false	true	false
Capacity simulation	true	false	false	Partial (cost)
Scheduling simulation	true	false	false	false
AI recommendations	Yes (optional)	false	false	false
Cost prediction	true	false	false	true
CI/CD integration	true	Manual	true	true
Open-source	Yes (AGPL)	Built-in	Mixed	Partial

Tech stack

Built on proven foundations, designed for extensibility.

Technology	Role
Python	Core runtime
FastAPI	REST API
LangGraph	AI agent orchestration
A2A Protocol	Agent-to-agent communication
MCP	Model Context Protocol integration
GKE	Primary target (Autopilot + Standard)

Where we are

PRELUDE currently exists as a complete specification and architecture, not a released product. The deterministic engine — manifest parsing, resource calculation, scheduling simulation — is the proposed foundation. Optional AI reasoning layers build on top.

We're building in the open. The architecture is documented, the approach is transparent, and the code will be AGPL-licensed.

Explore the specification.

PRELUDE is a documented concept, not a released repository. Talk to us about the architecture or follow related work in Field Notes.

Discuss PRELUDE Field Notes