Kubernetes

Complete Platform Agent Swarm — A coordinated multi-agent system for Kubernetes and OpenShift platform operations. Includes Orchestrator (Jarvis), Cluster Op...

Security Scan

The skill claims to be a coordinated Kubernetes/OpenShift agent swarm and contains many helper scripts and docs, but the package metadata, runtime instructions, and install behavior are inconsistent and present supply-chain and operational risks that need review before installing.

Purpose & Capability

The skill's name/description (cluster/Swarm orchestration) matches the included scripts and docs, but registry metadata claims 'no required env vars / binaries' while SKILL.md declares KUBECONFIG, kubectl/oc/helm/jq/curl/git, and many optional cloud/API tokens. The package is described as 'instruction-only' yet the archive contains dozens of executable scripts. This mismatch between declared requirements and actual runtime needs is an incoherence the user should resolve.

Instruction Scope

SKILL.md and per-skill SKILL.md files instruct running many bash scripts that perform cluster reads and writes (deploy, promote, delete, etc.), and they require access to KUBECONFIG and optional cloud/provider tokens. The docs explicitly warn that some scripts are destructive and that human approval is a procedural control (not enforced technically). Several internal documents call out that many scripts lack consistent output sanitization and must be audited. The instructions therefore reach well beyond a narrow, read-only helper and permit potentially destructive actions and credential use — appropriate for the stated purpose but risky without strict operational controls.

Install Mechanism

There is no formal install spec in the registry entry, but SKILL.md and README instruct using 'npx skills add' or cloning a third-party GitHub repo (https://github.com/kcns008/cluster-agent-swarm-skills). 'npx skills add' will fetch and execute code remotely (supply-chain risk). The repo contains many executable scripts that will be written to disk and run; while the docs recommend pinning commits and auditing, the default install path remains high-risk if users follow the easy 'npx' flow or floating branches.

Credentials

The environment variables and tokens referenced in SKILL.md (KUBECONFIG, AWS/Azure/GCP creds when managing those clouds, ARGOCD/Vault/GITHUB tokens) are proportionate to the skill's stated capabilities. However the registry metadata failing to declare these requirements is inconsistent. Also many of these credentials are highly sensitive; the docs correctly recommend least privilege, but users must ensure only minimal-scoped service accounts and not owner/root credentials are provided.

Persistence & Privilege

Agents persist state to repository files (WORKING.md, LOGS.md, MEMORY.md) and the docs state the swarm will commit changes to those files. Persistence increases blast radius if the skill or its repo is compromised. 'always' is false (good), and autonomous model invocation is allowed (normal), but the claimed human-approval requirement is only procedural in the skill — your platform must enforce technical gates before production changes. Writing/committing files and executing scripts combined with broad credential access increases risk.

What to consider before installing

This package appears to implement the multi-agent Kubernetes swarm it claims, but there are clear inconsistencies and supply-chain risks you should address before installing: 1) Do not run the one-liner 'npx skills add <repo>' in production — it pulls and executes third-party scripts. Prefer manual git clone and pin to a verified commit hash. 2) Audit every script you plan to use (especially any with 'delete', 'cleanup', 'promote', or 'deploy' behavior) and confirm they sanitize outputs and handle secrets safely. 3) Never provide owner/root cloud credentials or a cluster-admin kubeconfig; create minimal, time-bound service accounts and restrict KUBECONFIG scope. 4) Ensure your platform enforces a technical approval/guardrail for any operation that modifies production (do not rely on the skill's procedural warnings). 5) Limit repository write/commit permissions for the agent and isolate the skill in a non-production environment for testing. 6) Verify commit signatures and checksums where possible and maintain an offline pinned copy for production. If you want, I can: list the highest-risk scripts by filename for targeted review, or generate a short checklist of approval-gate controls your platform should implement before enabling this skill.

Cluster Agent Swarm — Complete Platform Operations

Runtime Requirements

This skill package provides Kubernetes/OpenShift cluster management capabilities. Credentials are modular - only configure what you need for your specific use case.

Always Required

Requirement	Description	Environment Variable
Kubeconfig	Valid kubeconfig with cluster access	KUBECONFIG or ~/.kube/config
kubectl	Kubernetes CLI	Must be in PATH

Conditional - Enable Only As Needed

Platform	Enable If...	Credentials
AWS/EKS/ROSA	Managing AWS-hosted Kubernetes	AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
Azure/ARO	Managing Azure-hosted Kubernetes	AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID
GCP/GKE	Managing GCP-hosted Kubernetes	GOOGLE_APPLICATION_CREDENTIALS
ArgoCD	Using GitOps agent	ARGOCD_AUTH_TOKEN, ARGOCD_SERVER
Vault	Using secrets management	VAULT_TOKEN
GitHub	Pushing to git repositories	GITHUB_TOKEN

Session Setup

Before using the agents, you MUST set up a session context:

# Set up session context for your environment
bash skills/orchestrator/scripts/setup-session.sh <environment> [context-name]

# Environments: dev, qa, staging, prod
# Note: prod requires human approval for all modifications

Security Considerations

• Agents operate with least privilege by default
• All credential access is logged
• Production modifications require human approval
• Secrets are never logged or stored in code

---

Security Assessment - Read Before Installing

Source Verification

• This skill pulls code from a third-party GitHub repository
• Verify the source URL before installing: https://github.com/kcns008/cluster-agent-swarm-skills
• Pin to a specific version - never use main branch in production:

  git clone https://github.com/kcns008/cluster-agent-swarm-skills.git
  cd cluster-agent-swarm-skills
  git fetch --tags
  git checkout v1.0.0  # Use verified release tag or commit hash
  

Third-Party Script Execution Warning

• This is a scripted skill - it will write executable bash scripts to disk
• Scripts perform cluster operations including: deployments, scaling, scanning, configuration
• Some scripts can be destructive - review before running:
  • Scripts with -delete, -cleanup in name may remove resources
  • Scripts with -promote, -deploy modify cluster state
• Always test in non-production first

Install Mechanism

• Installing via npx skills add downloads and executes code from GitHub
• The skill cannot verify integrity of external scripts
• Audit all scripts locally before running in production
• Consider maintaining a verified, offline copy of trusted scripts
• ALWAYS PIN TO VERIFIED COMMIT HASH for production - NEVER use floating URLs like tree/main or untagged branches
• Use manual git clone with verified checkout for highest security

Persistence & Blast Radius

• Agents maintain persistent state across sessions via:
  • WORKING.md - session progress tracking
  • LOGS.md - action audit trail
  • MEMORY.md - long-term learnings
• Agents are configured to commit changes to these files as part of normal operation
• This persistence increases blast radius if misused - limit repository write access if concerned

Human Approval Enforcement

• The skill documentation claims human approval required for production changes
• This is a procedural control, NOT a technical enforcement
• Your platform MUST enforce an approval gate before allowing production operations
• Do not rely on agent self-restriction for production safety

Principle of Least Privilege - Required

• DO NOT provide owner/root-level cloud credentials
• Create dedicated, minimal-permission service accounts for:
  • Kubernetes namespace-level access (not cluster-admin)
  • AWS IAM roles with limited EKS permissions
  • Azure service principals with limited subscription access
  • GCP service accounts with limited project permissions
• Never provide production credentials until you have audited the code in non-production

Sandbox Before Production

1. Run this skill in an isolated/non-production environment first
2. Manually step through scripts to understand their behavior
3. Pay special attention to:
   • *-cleanup.sh scripts - may delete resources
   • *-promote.sh scripts - may promote artifacts
   • *-delete.sh scripts - explicitly destructive
4. Verify no unexpected network calls to external endpoints

Supply Chain Tools

• Scripts may download binaries (syft, cosign, trivy, etc.)
• Only allow downloads from trusted release sources (official GitHub releases, package managers)
• Consider curating offline toolchains if your environment requires it

Additional Documentation

• OPERATIONAL_RISKS.md - Complete documentation of operational risks, inconsistencies, and mitigations
• SECURITY.md - Security policy, external dependencies, and verification requirements

---

This is the complete cluster-agent-swarm skill package. When you add this skill, you get access to ALL 7 specialized agents working together as a coordinated swarm.

Installation

Security Warning - Read Before Installing

⚠️ CRITICAL SECURITY WARNING

The installation commands below use GitHub URLs that fetch and execute code on your system. This is a supply chain risk - you must verify the repository and commit before use.

For production deployments:

1. ALWAYS pin to a specific, verified commit hash
2. Review the commit: git show <commit-hash>
3. Verify GPG signatures if available: git verify-commit <commit-hash>
4. Use the manual clone method below for highest security

NEVER use floating URLs (tree/main, main branch) in production.

Install All Skills (Development Only)

⚠️ NOT FOR PRODUCTION: Uses floating URL without commit pinning.

npx skills add https://github.com/kcns008/cluster-agent-swarm-skills

Install All Skills (Production - Pinned)

✅ RECOMMENDED: Pins to verified commit hash.

npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e

Verification steps:

# Verify the commit before installing
git clone https://github.com/kcns008/cluster-agent-swarm-skills
cd cluster-agent-swarm-skills
git checkout 91c362dba2911f7523f179e7dcc374cf4335814e
git show --stat  # Review what changed
# Then install using the pinned URL above

Install Individual Skills

⚠️ ALWAYS PIN TO VERIFIED COMMIT - Do not use tree/main in production.

# Orchestrator - Jarvis (task routing, coordination)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/orchestrator

# Cluster Ops - Atlas (cluster lifecycle, nodes, upgrades)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/cluster-ops

# GitOps - Flow (ArgoCD, Helm, Kustomize)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/gitops

# Security - Shield (RBAC, policies, CVEs)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/security

# Observability - Pulse (metrics, alerts, incidents)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/observability

# Artifacts - Cache (registries, SBOM, promotions)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/artifacts

# Developer Experience - Desk (namespaces, onboarding)
npx skills add https://github.com/kcns008/cluster-agent-swarm-skills/tree/91c362dba2911f7523f179e7dcc374cf4335814e/skills/developer-experience

Manual Installation (Highest Security)

✅ MOST SECURE: No remote code execution, full audit trail.

# Clone and verify
git clone https://github.com/kcns008/cluster-agent-swarm-skills
cd cluster-agent-swarm-skills

# Checkout verified commit
git checkout 91c362dba2911f7523f179e7dcc374cf4335814e

# Verify (optional, if GPG signed)
git verify-commit 91c362dba2911f7523f179e7dcc374cf4335814e

# Review scripts BEFORE copying
# ls skills/*/scripts/
# cat skills/*/scripts/*.sh

# Copy manually reviewed scripts
cp -r skills/orchestrator ~/.claude/skills/
cp -r skills/cluster-ops ~/.claude/skills/
# ... add other skills as needed

---

The Swarm — Agent Roster

Agent	Code Name	Session Key	Domain
Orchestrator	Jarvis	agent:platform:orchestrator	Task routing, coordination, standups
Cluster Ops	Atlas	agent:platform:cluster-ops	Cluster lifecycle, nodes, upgrades
GitOps	Flow	agent:platform:gitops	ArgoCD, Helm, Kustomize, deploys
Security	Shield	agent:platform:security	RBAC, policies, secrets, scanning
Observability	Pulse	agent:platform:observability	Metrics, logs, alerts, incidents
Artifacts	Cache	agent:platform:artifacts	Registries, SBOM, promotion, CVEs
Developer Experience	Desk	agent:platform:developer-experience	Namespaces, onboarding, support

---

Agent Capabilities Summary

What Agents CAN Do

• Read cluster state (kubectl get, kubectl describe, oc get)
• Deploy via GitOps (argocd app sync, Flux reconciliation)
• Create documentation and reports
• Investigate and triage incidents
• Provision standard resources (namespaces, quotas, RBAC)
• Run health checks and audits
• Scan images and generate SBOMs
• Query metrics and logs
• Execute pre-approved runbooks

What Agents CANNOT Do (Human-in-the-Loop Required)

• Delete production resources (kubectl delete in prod)
• Modify cluster-wide policies (NetworkPolicy, OPA, Kyverno cluster policies)
• Make direct changes to secrets without rotation workflow
• Modify network routes or service mesh configuration
• Scale beyond defined resource limits
• Perform irreversible cluster upgrades
• Approve production deployments (can prepare, human approves)
• Change RBAC at cluster-admin level

---

Communication Patterns

@Mentions

Agents communicate via @mentions in shared task comments:

@Shield Please review the RBAC for payment-service v3.2 before I sync.
@Pulse Is the CPU spike related to the deployment or external traffic?
@Atlas The staging cluster needs 2 more worker nodes.

Thread Subscriptions

• Commenting on a task → auto-subscribe
• Being @mentioned → auto-subscribe
• Being assigned → auto-subscribe
• Once subscribed → receive ALL future comments on heartbeat

Escalation Path

1. Agent detects issue
2. Agent attempts resolution within guardrails
3. If blocked → @mention another agent or escalate to human
4. P1 incidents → all relevant agents auto-notified

---

Heartbeat Schedule

Agents wake on staggered 5-minute intervals:

*/5  * * * *  Atlas   (Cluster Ops - needs fast response for incidents)
*/5  * * * *  Pulse   (Observability - needs fast response for alerts)
*/5  * * * *  Shield  (Security - fast response for CVEs and threats)
*/10 * * * *  Flow    (GitOps - deployments can wait a few minutes)
*/10 * * * *  Cache   (Artifacts - promotions are scheduled)
*/15 * * * *  Desk    (DevEx - developer requests aren't usually urgent)
*/15 * * * *  Orchestrator (Coordination - overview and standups)

---

Key Principles

• Roles over genericism — Each agent has a defined SOUL with exactly who they are
• Files over mental notes — Only files persist between sessions
• Staggered schedules — Don't wake all agents at once
• Shared context — One source of truth for tasks and communication
• Heartbeat, not always-on — Balance responsiveness with cost
• Human-in-the-loop — Critical actions require approval
• Guardrails over freedom — Define what agents can and cannot do
• Audit everything — Every action logged to activity feed
• Reliability first — System stability always wins over new features
• Security by default — Deny access, approve by exception

---

Detailed Agent Capabilities

Orchestrator (Jarvis)

• Task routing: determining which agent should handle which request
• Workflow orchestration: coordinating multi-agent operations
• Daily standups: compiling swarm-wide status reports
• Priority management: determining urgency and sequencing of work
• Cross-agent communication: facilitating collaboration
• Accountability: tracking what was promised vs what was delivered

Cluster Ops (Atlas)

• OpenShift/Kubernetes cluster operations (upgrades, scaling, patching)
• Node pool management and autoscaling
• Resource quota management and capacity planning
• Network troubleshooting (OVN-Kubernetes, Cilium, Calico)
• Storage class management and PVC/CSI issues
• etcd backup, restore, and health monitoring
• Multi-platform expertise (OCP, EKS, AKS, GKE, ROSA, ARO)

GitOps (Flow)

• ArgoCD application management (sync, rollback, sync waves, hooks)
• Helm chart development, debugging, and templating
• Kustomize overlays and patch generation
• ApplicationSet templates for multi-cluster deployments
• Deployment strategy management (canary, blue-green, rolling)
• Git repository management and branching strategies
• Drift detection and remediation
• Secrets management integration (Vault, Sealed Secrets, External Secrets)

Security (Shield)

• RBAC audit and management
• NetworkPolicy review and enforcement
• Security policy validation (OPA, Kyverno)
• Vulnerability scanning (image scanning, CVE triage)
• Secret rotation workflows
• Security incident investigation
• Compliance reporting

Observability (Pulse)

• Prometheus/Grafana metric queries
• Log aggregation and search (Loki, Elasticsearch)
• Alert triage and investigation
• SLO tracking and error budget monitoring
• Incident response coordination
• Dashboards and visualization
• Telemetry pipeline troubleshooting

Artifacts (Cache)

• Container registry management
• Image scanning and CVE analysis
• SBOM generation and tracking
• Artifact promotion workflows
• Version management
• Registry caching and proxying

Developer Experience (Desk)

• Namespace provisioning
• Resource quota and limit range management
• Developer onboarding
• Template generation
• Developer support and troubleshooting
• Documentation generation

---

File Structure

cluster-agent-swarm-skills/
├── SKILL.md                    # This file - combined swarm
├── AGENTS.md                   # Swarm configuration and protocols
├── skills/
│   ├── orchestrator/           # Jarvis - task routing
│   │   └── SKILL.md
│   ├── cluster-ops/            # Atlas - cluster operations
│   │   └── SKILL.md
│   ├── gitops/                 # Flow - GitOps
│   │   └── SKILL.md
│   ├── security/               # Shield - security
│   │   └── SKILL.md
│   ├── observability/          # Pulse - monitoring
│   │   └── SKILL.md
│   ├── artifacts/              # Cache - artifacts
│   │   └── SKILL.md
│   └── developer-experience/   # Desk - DevEx
│       └── SKILL.md

├── scripts/                    # Shared scripts
└── references/                 # Shared documentation

---

Reference Documentation

For detailed capabilities of each agent, refer to individual SKILL.md files:

• skills/orchestrator/SKILL.md - Full Orchestrator documentation
• skills/cluster-ops/SKILL.md - Full Cluster Ops documentation
• skills/gitops/SKILL.md - Full GitOps documentation
• skills/security/SKILL.md - Full Security documentation
• skills/observability/SKILL.md - Full Observability documentation
• skills/artifacts/SKILL.md - Full Artifacts documentation
• skills/developer-experience/SKILL.md - Full Developer Experience documentation