KubeStellar Console

kubestellar-kc-agent · kubestellar/console · ★ 109 · last commit 2026-05-26

Primitive shape 1 total

MCP tools 1

Summary

KubeStellar Console — Summary

KubeStellar Console is an AI-powered multi-cluster Kubernetes management dashboard with guided install missions for 250+ CNCF projects. It ships as a hosted web app at console.kubestellar.io, a self-hosted Go binary (start.sh), and a local agent bridge (kc-agent) that connects the browser to the user's kubeconfig contexts and AI providers (Claude, OpenAI, Gemini). The project has a .claude/ directory with settings.json (git/build permissions) and CLAUDE.md + AGENTS.md for contributing agents, extensive Playwright visual regression testing requirements, and an MCP bridge in pkg/mcp/ for Kubernetes management.

KubeStellar Console does not fit neatly into any seed archetype. It is most similar to agent-os (ships a management dashboard + agent configuration conventions) but differs: it is a full production Kubernetes management UI with AI features built in, not a Claude Code methodology package. The kc-agent MCP bridge makes it comparable to ccmemory (both MCP-bridged) but for Kubernetes control rather than memory management.

Overview

KubeStellar Console — Overview

Origin

KubeStellar is a CNCF-adjacent project. The console is a community-built management UI for KubeStellar (multi-cluster Kubernetes orchestration). Maintained by Andy Anderson, Chuck Anderson, and contributors; part of the broader KubeStellar ecosystem.

Philosophy

From the README:

"AI-powered multi-cluster Kubernetes dashboard with guided install missions for 250+ CNCF projects."

"The fastest way to evaluate the console is the hosted version — no Kubernetes cluster, no install, no configuration. Demo data is built in."

The project is Kubernetes-operator-first: real cluster management is the primary use case, AI features are additive (not core). The kc-agent local bridge is the AI enablement layer — it forwards browser requests to kubeconfig contexts and AI providers.

AI Features

From CLAUDE.md:

"For AI/Frontend Testing: Chrome DevTools MCP (for interactive testing)"

The project uses Claude Code (with Chrome DevTools MCP) for its own UI testing workflow.

Kagenti Integration

Reference to Kagenti backend in Helm chart docs — separate K8s-native agent runtime that can connect to the console. Positions the console as a frontend for multiple agent backends.

Key Design Decisions

Hosted demo at console.kubestellar.io for zero-install evaluation
kc-agent runs locally at 127.0.0.1:8585 as a bridge daemon
start.sh installs both console binary AND pre-built kc-agent
KC_AGENT_TOKEN shared secret for local security
React + TypeScript frontend, Go backend

Architecture

KubeStellar Console — Architecture

Distribution

Self-hosted: curl -sSL https://raw.githubusercontent.com/kubestellar/console/main/start.sh | bash
In-cluster (Helm): deploy.sh (or deploy/helm/kubestellar-console/)
Hosted demo: console.kubestellar.io (no install)
macOS (kc-agent only): brew tap kubestellar/tap && brew install kc-agent

Directory Structure

cmd/
  console/        # Console server entry point (Go)
  kc-agent/       # Local agent bridge (Go)
pkg/
  agent/          # AI providers (Claude, OpenAI, Gemini)
  api/            # HTTP/WS server + handlers
  client/         # Client code
  compliance/
  fileutil/
  k8s/            # Kubernetes interaction
  kagent/         # Kagenti backend integration
  kagenti_provider/
  mcp/            # MCP bridge to Kubernetes
  models/
  notifications/
  store/          # SQLite database layer
  stellar/
web/src/
  components/cards/  # Dashboard card components
  hooks/             # Data fetching hooks (useCached*)
  lib/               # Utilities, card registry, demo data
deploy/helm/
.claude/
  settings.json    # Claude Code permissions (git/build)
CLAUDE.md          # Contributing agent guide
AGENTS.md          # Agent instructions

Required Runtime

Go 1.25+ (for building from source)
Node.js / npm (for web frontend)
Kubernetes cluster (for real usage; not needed for hosted demo)
kubectl / kubeconfig (for kc-agent)
AI provider API key (optional, for AI features)

Install Complexity

One-liner (start.sh downloads pre-built binaries). Multi-step for from-source builds or cluster deployment.

Ports

Console: localhost:8080
kc-agent: 127.0.0.1:8585
Dev frontend: localhost:5174 (Vite)

Components

KubeStellar Console — Components

Console Server (Go)

HTTP/WS server (pkg/api/)
Dashboard card components (React frontend)
AI provider adapters (pkg/agent/ — Claude, OpenAI, Gemini)
SQLite store (pkg/store/)
Kubernetes bridge (pkg/k8s/)
MCP bridge to Kubernetes (pkg/mcp/)
Notification system

kc-agent (Go daemon)

Local HTTP/WS daemon at 127.0.0.1:8585
Bridges browser → kubeconfig contexts
Bridges browser → AI providers
KC_AGENT_TOKEN Bearer token auth
Homebrew formula available for macOS

MCP Integration

pkg/mcp/ — MCP bridge to Kubernetes
Enables MCP-protocol connections to Kubernetes resources

Frontend (React + TypeScript)

web/src/components/cards/ — Dashboard card components
web/src/hooks/ — Data fetching hooks (useCached* pattern)
web/src/lib/ — Utilities, card registry, demo data
Playwright E2E + visual regression tests in web/e2e/

Claude Code Config (`.claude/`)

settings.json — Permissions: allow git, npm, go commands; deny rm -rf /, force push main
CLAUDE.md — Contributing agent guide with mandatory testing requirements, visual verification protocol

Scripts

start.sh — Download + start console + kc-agent
deploy.sh — Kubernetes/Helm deployment
start-dev.sh — Dev mode (no OAuth, mock user)
startup-oauth.sh — OAuth mode

Kagenti Backend

pkg/kagenti_provider/ — Integration with Kagenti (K8s-native agent runtime)
Helm chart supports connecting to in-cluster Kagenti backend

Cron Scan

cron_scan_log.md — Periodic scan log (present at repo root)

Prompts

KubeStellar Console — Prompts

Verbatim Excerpt 1: CLAUDE.md Mandatory Testing Requirements

## ⚠️ MANDATORY Testing Requirements

**ALL UI and API work MUST be tested before marking complete.** Do not just write code and assume it works. Use one or more of these tools:

### For UI/Frontend Testing
1. **Playwright** (preferred for comprehensive E2E tests)
2. **Chrome DevTools MCP** (for interactive testing)
   - `mcp__chrome-devtools__navigate_page` - Load pages
   - `mcp__chrome-devtools__take_snapshot` - Verify DOM elements
   - `mcp__chrome-devtools__click` / `mcp__chrome-devtools__fill` - Interact
   - `mcp__chrome-devtools__take_screenshot` - Capture visual state

### For API/WebSocket Testing
1. **curl** - Test REST API endpoints
2. **websocat** - Test WebSocket connections

Technique: Iron-Law mandatory testing requirements. Names specific MCP tool identifiers (mcp__chrome-devtools__navigate_page). Binary prohibition: "Do not just write code and assume it works."

Verbatim Excerpt 2: CLAUDE.md Visual Verification Protocol

### Definition of done
Do NOT report a UI task as complete until:
- All visual checklist items are confirmed in screenshots
- Playwright visual test passes without `--update-snapshots`
- Test + baselines are committed in the PR

Technique: Explicit definition-of-done checklist. Binary gate: task is not "done" until three conditions met. Prohibits claiming completion without screenshot evidence.

Verbatim Excerpt 3: .claude/settings.json Permissions

{
  "permissions": {
    "allow": [
      "Bash(npm run build)",
      "Bash(git worktree*)",
      "Bash(curl*)"
    ],
    "deny": [
      "Bash(rm -rf /)",
      "Bash(git push --force origin main)",
      "Bash(git push --force origin master)"
    ]
  }
}

Technique: Declarative allow/deny permissions for Claude Code. Explicit force-push prohibition on main/master. Git worktree enabled. This is security hardening via settings.json.

Uniqueness

KubeStellar Console — Uniqueness

Differs From Seeds

KubeStellar Console does not fit any seed archetype cleanly. It is closest to ccmemory (both bridge external services to AI agents via MCP) but for Kubernetes management rather than memory. It resembles agent-os in providing a management interface + agent configuration (.claude/ settings), but agent-os is a methodology for Claude Code, while KubeStellar is a production Kubernetes management application. The CLAUDE.md mandatory testing protocol (visual verification with Playwright + Chrome DevTools MCP named tool identifiers) is the most sophisticated CI/testing governance in the corpus — specifically naming mcp__chrome-devtools__navigate_page etc. as required testing tools.

Positioning

A production Kubernetes management dashboard with AI features bolted on — not an AI agent framework. The value is in managing 250+ CNCF project installs via guided missions, not in agent orchestration.

Observable Failure Modes

Wrong archetype: This is a K8s management app, not a sandbox or agent framework — it should not appear in this batch alongside sandboxes
Requires cluster: Full value requires live Kubernetes cluster; hosted demo is read-only
kc-agent only on macOS/Linux/WSL2: Windows PowerShell not supported natively
GitHub OAuth complexity: Two separate GitHub credentials for different features, confusing setup
AI features secondary: AI is an add-on, not the core product — most value is in the dashboard/missions

What Makes It Interesting

The CLAUDE.md contribution guide has the most prescriptive testing protocol in the corpus — mandatory Playwright visual regression tests with named Chrome DevTools MCP tool calls, a definition-of-done checklist, and explicit prohibition on reporting tasks complete without screenshot evidence. This is the most Claude-Code-aware CLAUDE.md seen in batch 30.

Workflow

KubeStellar Console — Workflow

Evaluation Workflow (No Install)

Visit console.kubestellar.io — browse demo data, missions, cards

Self-Hosted Workflow

Phase	Artifact	Description
Install	Console binary + kc-agent	`curl ... start.sh
Start	Console at localhost:8080	Serves AI-powered dashboard
Cluster Connect	kc-agent at 127.0.0.1:8585	Bridges browser to kubeconfig
AI Config	Provider API key	Settings UI or `.env`
Use	Multi-cluster dashboard	Manage K8s via AI-guided missions

Development Workflow (CLAUDE.md)

From CLAUDE.md:

"ALL UI and API work MUST be tested before marking complete. Do not just write code and assume it works."

Phase	Tool	Description
Start app	`./start-dev.sh`	No OAuth, mock user
UI test	Playwright or Chrome DevTools MCP	Visual verification
API test	curl (REST) + websocat (WebSocket)	Endpoint validation
Visual regression	`npm run test:visual:update`	Generate baselines
Submit	`git push && PR`	CI validates; no local build

Visual Verification Protocol (CLAUDE.md)

Extract visual checklist from issue (numbered visible outcomes)
Implement
Screenshot every affected page via CDP or Playwright
Verify all checklist items visible in screenshot
Write/update Playwright test in web/e2e/visual/
Generate baselines: npm run test:visual:update
Commit test + baselines

Approval Gates

Visual verification protocol (mandatory for UI changes)
CI validation (no local build/lint allowed)
Playwright visual test must pass before PR

Memory Context

KubeStellar Console — Memory & Context

State Storage

SQLite (pkg/store/) — persistent state for console settings, user data, GitHub tokens
~/.kc/settings.json — kc-agent persisted settings (e.g., FeedbackGitHubToken on first admin save)
Session state — kc-agent maintains active kubeconfig context connections

Memory Type

SQLite (structured relational data) + file-based settings.

Cross-Session Handoff

Yes — SQLite state persists across console restarts. kc-agent token (KC_AGENT_TOKEN) can be made stable across restarts by setting env var.

`useCached*` Pattern

Frontend uses useCached* hooks for data fetching — client-side caching of Kubernetes resource data, reducing API calls.

Demo Data

web/src/lib/ contains demo data for the hosted version. The hosted version intentionally does not talk to live clusters.

AI Context

kc-agent bridges AI provider API calls from the browser. No built-in context/prompt compaction — delegated to the AI provider.

cron_scan_log.md

A cron scan log file at repo root suggests scheduled automated scanning of some kind (content not fetched, but presence indicates background monitoring).

Compaction

Not handled at the application level.

Orchestration

KubeStellar Console — Orchestration

Multi-Agent Support

Not in the traditional sense. The console has AI provider adapters (Claude, OpenAI, Gemini) for UI features, but no multi-agent orchestration framework.

Orchestration Pattern

None (for the console itself). The project uses Playwright + Chrome DevTools MCP for testing, not for production orchestration.

Isolation Mechanism

None for the console. Kubernetes namespaces provide isolation for managed clusters; the console itself has no agent isolation.

kc-agent as Bridge

kc-agent at 127.0.0.1:8585 acts as an HTTP/WS bridge:

Browser → kc-agent → kubeconfig contexts (cluster API calls)
Browser → kc-agent → AI provider API (Claude, OpenAI, Gemini)

MCP Integration

pkg/mcp/ provides an MCP bridge to Kubernetes — agents can manage K8s resources via MCP protocol through kc-agent.

Kagenti Integration

pkg/kagenti_provider/ supports connecting to Kagenti (in-cluster K8s-native agent runtime). This enables console-as-frontend for backend agent systems.

Execution Mode

Event-driven — both console and kc-agent are persistent daemons, respond to browser/API requests.

Crash Recovery

Standard Go server restarts. No checkpoint/replay capability.

Git Worktree

settings.json has "Bash(git worktree*)" — worktree usage is permitted for Claude Code development.

Ui Cli Surface

KubeStellar Console — UI / CLI Surface

CLI Binaries

kc-agent: Local daemon, bin/kc-agent or brew install kc-agent
- Runs at 127.0.0.1:8585
- Flags: KC_AGENT_TOKEN env var for auth
- Not interactive — persistent daemon

Local Web Dashboard

Exists: Yes (primary product)
Type: web-dashboard
Port: 8080 (console), 5174 (dev Vite frontend)
Tech stack: React + TypeScript frontend, Go backend
Features:
- Multi-cluster Kubernetes management
- AI-guided install missions (250+ CNCF projects)
- Dashboard cards (cluster metrics, workloads, etc.)
- AI chat features (via kc-agent + AI provider)
- Nightly E2E status widgets
- Community activity leaderboard
- GitHub issue filing (/issue page)
- Settings UI (admin role required)

Hosted Demo

console.kubestellar.io — zero-install evaluation with demo data
No cluster connection, no API keys required
Cannot reach local kc-agent

Observability

GitHub Actions CI (CI-validated builds)
Playwright visual regression tests
OpenSSF Scorecard badge
MTTR tracking badge

IDE Integration

None — Claude Code is used for development (.claude/ config), not shipped for end users.

Cross-Tool Portability

Low for the console itself (K8s management application). Medium for kc-agent (connects to any AI provider via standard API).

Related frameworks

same archetype · same primary tool · same memory type

MemPalace ★ 53k

A10 Memory engine

Verbatim local-first AI memory with 96.6% R@5 retrieval on LongMemEval using zero API calls — structured into a palace hierarchy…

Beads (Yegge) ★ 24k

A10 Memory engine

Dolt-powered distributed graph issue tracker where AI agents track tasks with hierarchical IDs and dependency edges, claim work…

deepagents (LangChain) ★ 23k

A10 Memory engine

Opinionated Python agent harness on top of LangGraph with sub-agents, filesystem, memory, and context compaction bundled in

agentmemory ★ 18k

A10 Memory engine

Persistent, searchable memory for AI coding agents that captures every tool interaction, compresses it via LLM, and injects…

Open Multi-Agent ★ 6.3k

A10 Memory engine

Give a natural-language goal to a coordinator agent and get a dynamically decomposed, parallelized task DAG executed by…

Basic Memory ★ 3.1k

A10 Memory engine

Gives AI agents a persistent, human-readable knowledge graph of project decisions, observations, and relations stored as plain…

Distribution

Type: standalone-repo
License: Apache-2.0
Install: one-liner

Surfaces

CLI binary: kc-agent
CLI subcmds: 0
Local UI: web-dashboard
UI port: 8080
Tech stack: React + TypeScript frontend, Go backend, SQLite store

Components

Commands: 0
Skills: 0
Subagents: 0
Hooks: 0
MCP servers: 1
Scripts: 4
Templates: 0

Workflow

Phases: 4
Approval gates: 3
Spec format: none
Spec storage: none
Delta or full: none

Orchestration

Multi-agent: No
Pattern: none
Max concurrent: 1
Isolation: none
Consensus: none
Prompt chaining: No

Multi-model

Multi-model: Yes
BYOK: Yes
Modal: text+vision

Execution

Mode: event-driven
Crash recovery: No
Compaction: No
Session handoff: Yes
Streaming: Yes

Memory

Type: sqlite
Persistence: global
Search: none
State files: 2 files

Quality

TDD: Yes
TDD mechanism: persona-instruction
Validators: 2
Self-review: none

Git / Observability

Auto commit: No
Auto PR: No
Auto merge: No
Worktree/feat: Yes
Audit log: Yes
Audit format: structured-md
Replay: No

Tools

Primary: Claude Code
Targets: 4
Portability: low

Signals

Stars: 109
Last commit: 2026-05-26
Maintainer: active
Quality score: 5.6/10

Summary

KubeStellar Console — Summary

Overview

KubeStellar Console — Overview

Origin

Philosophy

AI Features

Kagenti Integration

Key Design Decisions

Architecture

KubeStellar Console — Architecture

Distribution

Directory Structure

Required Runtime

Install Complexity

Ports

Components

KubeStellar Console — Components

Console Server (Go)

kc-agent (Go daemon)

MCP Integration

Frontend (React + TypeScript)

Claude Code Config (.claude/)

Scripts

Kagenti Backend

Cron Scan

Prompts

KubeStellar Console — Prompts

Verbatim Excerpt 1: CLAUDE.md Mandatory Testing Requirements

Verbatim Excerpt 2: CLAUDE.md Visual Verification Protocol

Verbatim Excerpt 3: .claude/settings.json Permissions

Uniqueness

KubeStellar Console — Uniqueness

Differs From Seeds

Positioning

Observable Failure Modes

What Makes It Interesting

Workflow

KubeStellar Console — Workflow

Evaluation Workflow (No Install)

Self-Hosted Workflow

Development Workflow (CLAUDE.md)

Visual Verification Protocol (CLAUDE.md)

Approval Gates

Memory Context

KubeStellar Console — Memory & Context

State Storage

Memory Type

Cross-Session Handoff

useCached* Pattern

Demo Data

AI Context

cron_scan_log.md

Compaction

Orchestration

KubeStellar Console — Orchestration

Multi-Agent Support

Orchestration Pattern

Isolation Mechanism

kc-agent as Bridge

MCP Integration

Kagenti Integration

Execution Mode

Crash Recovery

Git Worktree

Ui Cli Surface

KubeStellar Console — UI / CLI Surface

CLI Binaries

Local Web Dashboard

Hosted Demo

Observability

IDE Integration

Cross-Tool Portability

Related frameworks

Claude Code Config (`.claude/`)

`useCached*` Pattern