# Rockslab Cloud — MCP for agents > Rockslab Cloud — the customer plane of bedrock. Every tool acts inside ONE organization, as the person whose personal key you connected with, with their role; rockslab_get_me says which organization and which role. Inviting people, billing and kubeconfigs stay with the person. Reads change nothing, but each costs agent tokens: poll every 30–60 seconds, not in a tight loop. Verbs that build, install, sync or claim something are LONG: they return a workflowId (and runId); rockslab_list_operations finds the operation (run-…) and rockslab_get_operation follows it — status queued means it waits for a free slot and starts by itself. Verbs marked destructive require confirm: true and do not undo. Answers leave out every field at its zero value: a boolean that is missing is false, a missing number is 0, a missing string or list is empty — never "unknown". ## Connect The MCP endpoint is this host's /mcp (Streamable HTTP). Authenticate with a personal Rockslab API token: the person mints it in the cabinet under Credentials › Rockslab API and sends it as "Authorization: Bearer brk_…". The key acts as that person, with their role, in one organization; rockslab_get_me says which. The skills below are also MCP resources (skill:///SKILL.md). ## Agent tokens Every call a personal key makes — through this MCP server or straight against the API — costs agent tokens by its class, from one budget per person per organization shared by all of their keys there: mcp.tokens_per_hour, 2000 an hour unless Rockslab set another (about 2000 reads, or 40 operations, or 4 heavy builds). The same call is also spent from the organization's own budget, org.tokens_per_hour (5000 an hour by default), which all of its agents share (people in the console spend no tokens — they are paced): a call goes through only when both budgets have room, and the refusal names the one that had none. When the organization's concurrent-jobs slots (jobs.concurrent) are full, a new operation is QUEUED, not refused: it starts by itself when one finishes, and rockslab_get_operation shows its queuePosition. rockslab_get_my_token_usage shows what your budget was spent on. | class | what | default price | |---|---|---| | free | removing, stopping, cancelling, revoking — never refused; MCP's own messages (initialize, tools/list, ping, resources) | 0 | | read | anything that changes nothing | 1 | | change | a write that starts no operation: a rename, labels, settings, messages, keys | 5 | | operation | starts a job run (returns an operation to follow) | 50 | | heavy | provisions machines somebody pays for: build a cluster, add or scale a pool, change machine types, upgrade nodes, deploy a bundle or the platform, build a node image | 500 | A call the budget cannot pay for is refused before it runs and costs nothing; the refusal says the call's class and price, how many tokens are left and when enough will be back. A call that was let through and then refused by the tool for your reason — invalid arguments, no permission, not found, a precondition not met, nothing in stock — costs an attempt fee of 10% of its price by default (at least 1: a heavy attempt 50, an operation 5), and the tool's error ends with "This attempt cost N agent tokens." — retrying the same call unchanged spends your budget, so fix the cause first. A failure that is ours (an internal error, a timeout, a service down) is given back in full, and so is a refusal over one of the organization's limits (its error carries a "limit:" line): that line is the platform's, not your mistake. ## Skills Read the one for a task before starting it. - [build-a-cluster](skills/build-a-cluster/SKILL.md): Build a Kubernetes cluster in the customer's cloud account with Rockslab Cloud — readiness, shapes, the build call, polling the operation, and how a finished cluster is reached. - [connect-a-cloud](skills/connect-a-cloud/SKILL.md): Connect a customer's cloud account to Rockslab Cloud (Hetzner today) — what to ask the person for, which tool stores it, how to check the token is good, and what to do when it is not. - [deploy-an-app](skills/deploy-an-app/SKILL.md): Put an app on clusters as a deployment — which app, which version, which clusters (by label or by list) — preview it, roll it out, upgrade, pause, leave a cluster out or delete it, and read each cluster's state. - [documents](skills/documents/SKILL.md): What a Rockslab Cloud document is — apiVersion, kind, metadata, spec, status — how to read one, and why spec and status must never be confused. - [domains-and-buckets](skills/domains-and-buckets/SKILL.md): Claim a DNS zone and create object-storage buckets for the customer — the DNS credential, picking a zone from what the token can see, verification, and a bucket's lifecycle and configuration (versioning, expiry, object lock, access). - [grow-a-cluster](skills/grow-a-cluster/SKILL.md): Change a running cluster's size and shape — resize, add or remove node pools, autoscaling and its ceilings, a three-machine control plane, machine types, node-image upgrades, platform services and the cluster's domain. - [hetzner-door](skills/hetzner-door/SKILL.md): How an agent reaches the customer's own Hetzner project — the hcloud-mcp door installed in their cluster (mcp.), how a token for it is issued, what it can do, and why Rockslab Cloud itself never proxies the cloud. - [install-an-app](skills/install-an-app/SKILL.md): Install, remove or act on a catalogue app on one of the customer's clusters — reading the shelf, what "brings what it stands on" means, and how to follow the operation. - [kubectl-access](skills/kubectl-access/SKILL.md): How a person (or their agent) reaches a cluster's Kubernetes API with kubectl — their own kubeconfig with no secret in it (rockslab_get_cluster_signin), signing in through the platform's identity server with kubelogin, what each role may do, the device-code flow for a host with no browser, the owners' and admins' long-lived admin kubeconfig for CI/CD (rockslab_get_cluster_kubeconfig, rotate, revoke), and the owners' break-glass. - [limits](skills/limits/SKILL.md): What an agent's call costs in agent tokens, the two hourly budgets it spends (the person's and the organization's), why a call is refused for want of tokens and what to do then, and the organization's other limits beside them. - [read-an-operation](skills/read-an-operation/SKILL.md): Follow a long-running operation in Rockslab Cloud — polling, reading steps and events, telling a failure from a warning, and when to retry or cancel. - [schedule-a-cluster](skills/schedule-a-cluster/SKILL.md): Run a cluster only when it is needed — put it on a weekly or until schedule, what a down keeps and what an up does when machines run out, and how to take it off. - [test-the-platform](skills/test-the-platform/SKILL.md): Check that Rockslab Cloud works for this organization through MCP, end to end — connect, a read-only sweep, one operation from start to finish, how agent tokens and refusals behave, and leaving the organization exactly as it was. ## Tools Each is an MCP tool on this server; its input schema says the fields, and [the bracket] its cost class. - rockslab_get_me [read]: Who this token is and which organization it may act in: the memberships list has one entry for a token, and its orgId is what every other tool takes. - rockslab_get_organization [read]: The organization in one read: its projects, its cloud accounts with token health, resource counts per account, profile, subscription and readiness. - rockslab_get_attention [read]: What needs a person in this organization right now — failed operations, invalid cloud tokens, platform messages, autoscaling that cannot give pods room (Hetzner refused, types out of stock, a pool at its ceiling; rockslab_get_install on that node-autoscaler install names the pool and numbers). - rockslab_get_spire_status [read]: Workload identity (SPIRE) on your platforms as each platform's SPIRE server last reported it (read every 15 minutes): trust domain, clusters, agents and how many are live, CA expiry and whether the next CA is ready. - rockslab_list_activity [read]: The organization's recent activity: who did what, including what this token did. - rockslab_list_operator_grants [read]: Who at Rockslab can read this organization's data right now: each live grant's operator name, the reason they gave and when it ends. - rockslab_list_members [read]: People in the organization and their roles. - rockslab_get_limits [read]: Quotas in force for the organization: each value, what is used against it, its source (default, plan, internal, org, scaled or auto — skill limits says what each means) and raise, the way to more (plan, billing = rockslab_request_limit_increase, internal_set); the last 20 increase requests with their answers; and poolSize, the nodes one pool may hold. - rockslab_get_my_token_usage [read]: What an agent budget spent its agent tokens on — this key's, or with organization the organization's: totals, per procedure (calls, tokens, refused, cost class) and per hour, plus the budget now — tokens spent in the last hour and the hourly allowance. - rockslab_list_charges [read]: The organization's charges — what has been billed and for which infrastructure. - rockslab_get_billing_summary [read]: The organization's money at a glance: what is due now and since when (days late, the last payment error, when access would be suspended), the next invoice's estimate line by line and what it will be charged to, the default card, card or bank transfer, and the next billing run. - rockslab_list_payment_methods [read]: The organization's stored cards (brand, last four, expiry, which one invoices charge). - rockslab_get_invoice [read]: One invoice: its lines, totals, payer, the card or method the last payment went through and how it went, credit notes (refunds) and its story — issued, emailed, paid, a failed payment and why. - rockslab_get_org_history [read]: The organization day by day (UTC): clusters, cloud accounts, deployments, machines with their vCPU, memory and list price per month, volumes, load balancers and addresses with theirs; and the clusters made in the window. - rockslab_connect_cloud [operation]: Connect a cloud: creates a cloud account and stores its credential in one step. - rockslab_create_account [change]: Create a cloud account record without a credential (attach one with rockslab_set_credential). - rockslab_list_credentials [read]: Credentials the organization holds — as references (where each is stored and what it is for), never the secret values. - rockslab_set_credential [operation]: Store or replace a credential for a catalogue entry on an account. - rockslab_sync_account_inventory [operation]: Ask the platform to read the account's cloud again — servers, volumes, networks. - rockslab_list_servers [read]: Servers the platform knows in the organization's clouds, from the last inventory. - rockslab_list_resources [read]: Cloud resources by kind, as the last inventory saw them. - rockslab_get_availability [read]: Which server types are available in which regions of a cloud right now — read before building a cluster. - rockslab_rename_account [change]: Rename a cloud account. - rockslab_reconnect_account [change]: Resume tracking a disconnected cloud account: the platform reads it again. - rockslab_disconnect_account (destructive: needs confirm: true) [free]: Pause tracking a cloud account: the platform stops reading it; what runs there stays. - rockslab_archive_account (destructive: needs confirm: true) [free]: Delete a cloud connection: gone from every surface now, restorable until its purge date. - rockslab_list_network_allocations [read]: The address blocks handed to the organization's accounts and clusters. - rockslab_preview_network_plan [read]: Judge a new cluster's own Hetzner network (its range is its block) before rockslab_build_cluster: refusals empty = free, a refusal's fix is the block to ask for; capacity.maxNodes is the tighter of its address slots and Hetzner's 100 servers+balancers per network (byNetwork says which). - rockslab_set_network_defaults [change]: How addresses are carved for new accounts and clusters. - rockslab_update_credential [change]: Change what a credential is for and where it applies — not its secret (rockslab_set_credential with credentialId replaces that). - rockslab_attach_credential [change]: Make a cloud account use an existing credential of the organization. - rockslab_delete_credential (destructive: needs confirm: true) [free]: Stop holding a credential: nothing uses it again (an attached one is detached) and the secret is destroyed after the recovery window. - rockslab_list_infrastructures [read]: The organization's infrastructure records as billing sees them. - rockslab_create_project [change]: Create a project — a group of accounts with its own labels and credentials. - rockslab_rename_project [change]: Rename a project. - rockslab_delete_project (destructive: needs confirm: true) [free]: Delete an empty project. - rockslab_list_clusters [read]: The organization's clusters: state, role, account, doors (a kubectl door = takes people's sign-in), delivery push | flux; on flux, fluxConfigState/Detail is its Flux's last word on the config, fluxConnection whether it pulls, accessState/Detail on people's rights (failed = every kubectl call refused). - rockslab_get_cluster_signin [read]: A person's OWN kubeconfig for a cluster, no credential in it: API server, CA, and kubelogin (kubectl oidc-login) against the platform's identity server — browser sign-in, or the -device context for device code. - rockslab_get_cluster_kubeconfig [read]: Your PERSONAL cluster-admin kubeconfig for a cluster, for CI/CD: a ServiceAccount of yours on the cluster with a token that does not expire (same token on every call until rotate). - rockslab_list_cluster_admin_kubeconfigs [read]: Who holds a personal admin kubeconfig on a cluster — people and Rockslab engineers, when issued and last rotated; revoking=true means its holder lost the right and it is being removed. - rockslab_get_cluster_history [read]: One cluster day by day (UTC): machines (per pool too), vCPU, memory, their list price per month, and its volumes, load balancers and addresses with theirs. - rockslab_get_bundle_shapes [read]: What a cluster can be built on. - rockslab_check_cluster_readiness [read]: Whether the organization is ready to build a cluster, and what is missing if not (credential, domain, limits). - rockslab_build_cluster [heavy]: Build a new cluster in a cloud account. - rockslab_scale_cluster [heavy]: Resize a cluster's node pool. - rockslab_scale_control_plane [heavy]: Grow a cluster's control plane from one machine to three. - rockslab_change_machine_type [heavy]: Change the machine type of a pool or of the control plane on a running cluster. - rockslab_destroy_cluster (destructive: needs confirm: true) [free]: Destroy a cluster and everything the platform built for it in the cloud. - rockslab_take_down_cluster (destructive: needs confirm: true) [free]: Take a cluster down now (a scheduled down, once): machines stop billing; addresses, volumes, network, names stay. - rockslab_bring_up_cluster [heavy]: Bring a down cluster up now — its machines built again from its own record, on the same addresses, its platform and certificates put back. - rockslab_add_pool [heavy]: Add a node pool to a running cluster. - rockslab_set_pool_labels [operation]: Change one node pool's Kubernetes node labels on a running cluster: recorded for every machine that joins the pool, and set on its running nodes. - rockslab_remove_pool (destructive: needs confirm: true) [free]: Remove a node pool; its machines and the autoscaler's go. - rockslab_remove_cluster_nodes (destructive: needs confirm: true) [free]: Remove selected workers after a PDB-respecting drain. - rockslab_replace_cluster_node (destructive: needs confirm: true) [heavy]: Replace one fixed worker: create a Ready replacement, then drain and remove the selected node. - rockslab_release_cluster_hold [operation]: Check and release: when operationHoldReleasable, ask whether the operation holding the cluster's machines has stopped, and free them once it has. - rockslab_collect_cluster_nodes [operation]: Collect nodes: read the cluster's account afresh, tie each machine placed in a cluster to it by label so its pools count it, and move older label sets to labels v3. - rockslab_set_pool_autoscaling [operation]: Switch autoscaling on or off for one node pool, with its ceiling and what it may buy; a cluster without the node-autoscaler gets it installed by the same call. - rockslab_set_cluster_autoscaling [operation]: Not needed: a pool's rockslab_set_pool_autoscaling is enough (it installs the node-autoscaler and turns this on). - rockslab_set_cluster_schedule [change]: Put a cluster on a schedule. - rockslab_clear_cluster_schedule [free]: Make a cluster permanent: remove automatic deletion or weekly scheduling. - rockslab_upgrade_cluster [heavy]: Move a cluster to a newer node image; one the account lacks is built first (~10 min). - rockslab_sync_cluster_bundle [operation]: Reconnect a member cluster to the organization's platform: re-apply its Argo CD registration, project, ingest grant and remote write, then check each. - rockslab_verify_cluster [operation]: Check a cluster now: its API, its platform services, its place in the organization's fleet; the answer is an operation. - rockslab_set_cluster_domain [operation]: Give a cluster its platform domain — the addresses its own services (Grafana, the public door) are published under. - rockslab_install_cluster_platform [heavy]: Install, or apply again, the platform services on a cluster — what a build does at its end. - rockslab_list_platform_candidates [read]: The organization's clusters and whether each could become its platform (rockslab_install_platform_on_cluster): refusal empty = it may, else the sentence why not (a platform already runs, push delivery, on a schedule, no domain …). - rockslab_cancel_queued_platform_install [free]: Take back a platform install that waits for its cluster to be up, or dismiss one that was dropped (its droppedReason). - rockslab_list_sops_keys [read]: The sops App's keys: each platform's SOPS age recipient (age1…) to encrypt the organization's Git secrets to, and the Secret a Flux Kustomization in flux-system names as decryption.secretRef on every cluster of that platform running sops. - rockslab_install_platform_on_cluster [heavy]: Make an existing cluster the organization's platform and install the platform on it. - rockslab_get_platform_components [read]: A cluster's composition (the cabinet's Apps: the bundle's switches, each Component's): the base (locked), the agents and, on the platform cluster, the platform's own components — with what switching each off takes with it (takesWith), what switching it on needs (needs), whether it deletes a data volume (deletesData), and why a row is locked (lockedReason). - rockslab_set_platform_components [heavy]: Change a running cluster's own switches over the organization's defaults. - rockslab_get_org_platform_components [read]: The organization's default composition (Apps › Rockslab bundle): what its clusters carry unless one says otherwise — the base (locked), the agents, the platform's own components — with the tier's default (defaultTicked), takesWith, needs, and differsOn (clusters whose own switch differs). - rockslab_get_registry_cache [read]: The organization's registry cache (zot, one per platform): installed, its private endpoint (http://:5000, the private network only, no credentials), the registries it mirrors, its bucket and bucketStatus, and per cluster the mirrors' state — applied, applying, outside_network (another Hetzner network: no mirror, with the reason) or failed — with detail. - rockslab_retry_registry_cache [operation]: Try every cluster whose mirrors failed (rockslab_get_registry_cache) again now, not after the unattended pass's six-hour wait. - rockslab_set_org_platform_components [heavy]: Change the organization's defaults; each cluster following a changed one gets it in an operation (off removed, deletesData with its volume; on installed), one that cannot keeps its own and says why. - rockslab_remove_cluster_platform (destructive: needs confirm: true) [free]: Remove the platform services from a cluster, deleting their objects there. - rockslab_set_platform_member [operation]: Make a cluster a member of one of the organization's platforms (or move it to another), or take it out. - rockslab_list_node_images [read]: The node images this account already holds on the platform's current image line, newest first, with how many clusters use each. - rockslab_preview_image_cleanup [read]: Every node image the account holds and whether it could go: retireable = unused and superseded by a newer copy of the same image; otherwise the reason it stays (machines boot it, a cluster records it, an autoscaler would launch it, newest copy, not provably ours). - rockslab_remove_unused_images (destructive: needs confirm: true) [free]: Remove unused node images (snapshots) from an account: lifts their deletion protection and deletes them. - rockslab_clean_up_leftovers (destructive: needs confirm: true) [free]: Delete now what this account's removed clusters left at Hetzner, as the cleanup after a removal would: only what is proven the cluster's. - rockslab_list_app_deployments [read]: The organization's app deployments: which app, which version, which clusters, and each one's state there. - rockslab_get_app_deployment [read]: One app deployment in full: its clusters with the version installed and the state on each, and what is running for it. - rockslab_preview_app_deployment [read]: Which clusters a deployment would reach and what would happen on each, without changing anything. - rockslab_create_app_deployment [operation]: Deploy an app onto clusters by label or by list. - rockslab_update_app_deployment [operation]: Replace a deployment with what is sent: empty fields are defaults, so send every field of rockslab_get_app_deployment back with the change. - rockslab_set_app_deployment_cluster_settings [operation]: Give one cluster its own settings over the deployment's and re-apply the app there only. - rockslab_upgrade_app_deployment [operation]: Roll the organization's release out to every cluster that is behind; on a pinned deployment this MOVES the pin. - rockslab_pause_app_deployment [free]: Stop a deployment's rollout after the cluster it is on; nothing new joins until resumed. - rockslab_resume_app_deployment [operation]: Run the deployment's rollout again at its version: resumes a paused one, and is the retry after a failed rollout. - rockslab_exclude_app_deployment_cluster (destructive: needs confirm: true) [free]: Take the app off one cluster and keep it off, even while its labels still match; rockslab_update_app_deployment brings it back (deploy-an-app says how). - rockslab_reinstall_app_deployment_cluster [operation]: Apply the deployment's app again on one of its clusters, at its version and settings, even when it is already there; nothing else changes. - rockslab_delete_app_deployment (destructive: needs confirm: true) [free]: Remove the app from every cluster of the deployment, then forget the deployment. - rockslab_list_labels [read]: The labels on one subject: an organization, project, account, cluster, bucket, credential, or an inventory resource or server. - rockslab_list_labels_by_kind [read]: Every account's (or every cluster's own) labels at once — the pairs a member's scope may select on (cluster:env=dev, account:team=data). - rockslab_set_labels [change]: Set the labels of one subject (the kinds rockslab_list_labels reads). - rockslab_list_annotations [read]: Free-form notes on a subject (owner, ticket, cost centre) — not matched by anything. - rockslab_set_annotations [change]: Set the free-form notes on a subject. - rockslab_list_catalog [read]: The shelf this organization sees: clouds it can connect, apps it can install on a cluster, with their ids, requirements and what each provides. - rockslab_install_app [operation]: Install an app from the catalogue on a cluster; what the app stands on is brought along. - rockslab_remove_app (destructive: needs confirm: true) [free]: Remove an installed app from a cluster, deleting its objects there. - rockslab_set_service_settings [operation]: Change a component's or an app's settings on one cluster (one no app deployment owns: the cabinet's settings page of its card on that cluster's Apps) and re-apply it there. - rockslab_run_catalog_action [operation]: Run an action a catalogue entry declares (e.g. - rockslab_set_domain_key [operation]: Bind a Cloudflare domain to another DNS key; refused unless Cloudflare says the key sees the zone. - rockslab_list_cluster_domains [read]: The domains each cluster's workloads publish under besides its primary one. - rockslab_attach_cluster_domain [operation]: Let a cluster's workloads publish names under one more of the organization's domains: its external-dns is applied again with that zone. - rockslab_detach_cluster_domain (destructive: needs confirm: true) [operation]: Stop a cluster's workloads publishing under a domain: its external-dns is applied again without the zone, then the cluster's own records in that zone are removed. - rockslab_list_zone_candidates [read]: The DNS zones a credential can see — pick one to add as a domain. - rockslab_add_domain [operation]: Claim a DNS zone for the organization so clusters can be named under it. - rockslab_list_domains [read]: Domains the organization has claimed and whether each is verified. - rockslab_remove_domain (destructive: needs confirm: true) [free]: Release a claimed domain. - rockslab_retry_domain [operation]: Run a domain's verification and record writing again — after fixing its key or its records. - rockslab_create_bucket [operation]: Create an object-storage bucket in a cloud account. - rockslab_list_bucket_objects [read]: Read a managed bucket’s object metadata (keys, sizes, modification dates), optionally including stored versions and deletion markers. - rockslab_list_buckets [read]: Buckets the organization holds: each one's state, credential, options, and generation beside observedGeneration — behind means a configure not applied yet. - rockslab_set_bucket_credential [change]: Point a bucket at the key pair it is used with. - rockslab_configure_bucket [operation]: Change how a bucket is configured — versioning, expiry, the default retention of a locked bucket, who may read or write it — and start the job that applies it. - rockslab_delete_bucket (destructive: needs confirm: true) [free]: Delete a bucket, empty-only by default. - rockslab_list_operations [read]: Recent operations in the organization — builds, installs, syncs — with status and timing. - rockslab_get_operation [read]: One operation: status, steps and their details. - rockslab_get_operation_events [read]: The event trail of one operation — what happened, in order, with the platform's own sentences. - rockslab_retry_operation [operation]: Retry a failed operation from where it stopped. - rockslab_cancel_operation (destructive: needs confirm: true) [free]: Cancel a running operation (what it already did stays), or take a queued one out of the line (nothing had started). - rockslab_acknowledge_operations [change]: Mark failed operations as seen so they leave the attention list. - rockslab_list_installs [read]: What is installed where: every app and platform service on every cluster, with its version and state. - rockslab_get_install [read]: One installed app or service on one cluster: version, state, what it waits for. - rockslab_list_releases [read]: The delivery history: every install, upgrade and removal, with its version and outcome. - rockslab_list_messages [read]: Messages from the platform to this organization — maintenance, incidents, changes. - rockslab_set_service_active [change]: Switch one of the organization's capabilities on or off. - rockslab_request_limit_increase [change]: Ask for a higher platform limit; a person at Rockslab decides. - rockslab_create_support_request [change]: Write to Rockslab support on the organization's behalf. - rockslab_list_support_requests [read]: The organization's support requests: open or closed, whose turn it is (awaiting customer = Rockslab answered), the last message. - rockslab_get_support_request [read]: One support request with its whole conversation. - rockslab_reply_support_request [change]: Write into an open support request's conversation on the organization's behalf; it hands the turn to Rockslab. - rockslab_set_support_request_closed [change]: Close a support request that is settled, or reopen a closed one. - rockslab_list_available_plans [read]: The plans the organization could be on, with their limits and prices. - rockslab_list_document_kinds [read]: The kinds of documents the platform keeps (Cluster, Account, Credential, …) and their schemas. - rockslab_list_documents [read]: The organization's documents of one kind: every object as apiVersion/kind/metadata/spec/status. - rockslab_get_document [read]: One document in full — spec is what was asked for, status is what the platform observed.