One endpoint.
Every MCP server your platform runs.

apiVersion: muster.giantswarm.io/v1alpha1
kind: Workflow
metadata:
  name: pod-triage
  namespace: muster
spec:
  description: Find the pods of a workload that are not running and gather their evidence
  args:
    namespace: { type: string, required: true }
    selector:  { type: string, required: true }
  steps:
    - id: pods
      tool: x_kubernetes_list
      args: { kind: Pod, namespace: "{{ .input.namespace }}", labelSelector: "{{ .input.selector }}" }
    - id: events
      tool: x_kubernetes_list
      args: { kind: Event, namespace: "{{ .input.namespace }}" }
      condition:
        template: "{{ gt (len .results.pods.items) 0 }}"
    - id: logs
      forEach:
        items: "{{ .results.pods.items }}"
        as: pod
        steps:
          - id: tail
            tool: x_kubernetes_logs
            args: { name: "{{ .vars.pod.metadata.name }}", namespace: "{{ .input.namespace }}", tailLines: 50 }
            allowFailure: true
    - id: signals
      parallel:
        - id: restarts
          tool: x_prometheus_query
          args: { query: 'increase(kube_pod_container_status_restarts_total{namespace="{{ .input.namespace }}"}[1h])' }
        - id: alerts
          tool: x_prometheus_alerts
          args: { namespace: "{{ .input.namespace }}" }
  onFailure:
    - id: note
      tool: x_slack_post
      args: { channel: "#oncall", text: "pod-triage failed for {{ .input.namespace }}/{{ .input.selector }}" }
  output:
    pods:     "{{ .results.pods.items }}"
    restarts: "{{ .results.restarts.data.result }}"
    alerts:   "{{ len .results.alerts.alerts }}"

• Templates

  Step arguments are Go templates with sprig, over .input, .results and .vars. Every step's result is referenceable by every later step; a reference to an undefined key fails the step instead of passing an empty string on.

• Conditions

  A step is gated by a boolean template, by a tool call checked against expect, or by an earlier step's result. Malformed conditions are rejected at kubectl apply time by CEL and by core_workflow_validate.

• forEach and parallel

  Fan out over clusters, namespaces or pods with forEach, each iteration addressable afterwards; run independent steps concurrently with parallel and pick their results up after the group.

• Failure handling

  allowFailure records a failure and continues, the error available to later conditions. When a step fails for real, the workflow's onFailure handlers run as best-effort rollback.

• Shaped output

  An output template returns a small, structured document instead of every step's payload. JSON types are preserved: len stays a number, an array stays an array, a version string stays "1.20".

• A durable record

  Every run is a WorkflowExecution with per-step status, inputs, results and timing, listed with core_workflow_execution_list, and an OpenTelemetry trace with one span per workflow and per step.

Workflows compose: one workflow calls another's workflow_<name> tool, a toolset selects them with workflow:<name>, and an agent finds them by intent through filter_tools. Create workflows · Workflow reference

$ muster auth status

muster: authenticated
  Endpoint: https://muster.example.com
  Identity: dana@example.com
  Expires:  in 29 minutes · session 30 days

MCP Servers:
  mcp-kubernetes    Connected  [SSO: Forwarded]
  mcp-prometheus    Connected  [SSO: Forwarded]
  remote-cluster    Connected  [SSO: Exchanged]
  github            Not authenticated   Run: muster auth login --server github

• One login, one session

  The CLI, the IDE bridge and any client that implements the MCP authorization flow log in through the browser at Dex. Tokens live on disk with mode 0600, never in logs. Access tokens last 30 minutes and are capped to the provider's; the refresh token rolls for 30 days, aligned with Dex.

• Identity travels downstream

  Servers that trust the same Dex receive the person's ID token with the audiences they require. Servers on another cluster get an RFC 8693 token exchange at their own IdP. Servers with their own OAuth get a browser login once per person, and AWS-hosted servers a SigV4 signature.

• Hardened by default

  PKCE on every flow, state validation, AES-256-GCM encryption of stored tokens, rate limits on the registration, authorization and token endpoints, SSRF and DNS-rebinding guards on client metadata and redirect URIs.

• Standard endpoints

  Protected-resource metadata under /.well-known (RFC 9728), client ID metadata documents, dynamic client registration where the deployment allows it. Any MCP client that speaks the authorization spec connects without a bridge.

• Toolsets, per request

  X-muster-Toolset: preset:read-only, workflow:pod-triage declares the tools a request may see and call. Built-in and operator-defined presets, selectors by server, workflow, tool or label. Evaluated on every request; a toolset never widens the catalogue.

• Who called what

  Every tool call carries the person's identity into OpenTelemetry traces, Prometheus metrics and structured logs. Sessions, grants and OAuth state move to Valkey for more than one replica, and muster waits for it rather than splitting sessions.

Protect the endpoint with Dex · Authenticate the CLI · Toolsets · Why token forwarding

• Getting started

  A working muster and your first aggregated tools, step by step.

• How-to guides

  Connect a client, authenticate, register a server, integrate with Kubernetes, build a workflow, fix a problem.

• Reference

  Tool arguments, configuration keys, custom resource fields, events, HTTP endpoints and every CLI flag.

• Explanation

  How aggregation, sessions, workflows and observability work, and the decision records that say why.

• Operations

  Install muster for a team and keep it secure: Dex, Valkey, token lifecycle, upgrades.

• Contributing

  Development setup, the conventions the linters enforce and the behavioural scenario suite.