Cycle MCP
Server Details
Manage your Cycle infrastructure from any AI assistant. Deploy and reconfigure containers, VMs, and full stacks; create environments; provision servers and manage clusters; handle DNS records, scoped variables, image sources, and volumes. Troubleshoot with logs, metrics, telemetry, and instance console commands. Authenticates via OAuth with read, write, and exec scopes. Tools outside your granted scopes are hidden, and every change is previewed before you confirm it.
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 45 tools
The observability cluster (capture_stream, get_logs, get_telemetry, query_metrics, diagnose) and the lifecycle cluster (cycle_control_*, reconfigure_*, delete_*) could superficially overlap, but the descriptions draw sharp, explicit boundaries and cross-reference each other's intended use. Each tool targets a distinct resource+action pair with only marginal room for misselection.
The dominant convention is clear snake_case verb_noun (deploy_application, delete_container, reconfigure_virtual_machine, list_servers). Deviations are the cycle_control_* trio (an infix pattern used nowhere else) and the bare verb 'diagnose', but these are few and still readable.
45 tools is heavy by any measure, but the server covers a genuinely broad IaaS surface — containers, VMs, servers, DNS, images, volumes, metrics, and stacks — so many tools legitimately earn their place. It still sits well above the comfortable 3-15 range and could likely consolidate the diagnostic/observability group.
Lifecycle coverage is strong across nearly every resource: create/configure/deploy/control/delete for containers, VMs, servers, environments, stacks, DNS records, images, and variables, plus diagnostics and job tracking. A few gaps are acknowledged in-band (no scoped-variable deletion, no DNS zone deletion, no VM volume-change tool), but they are flagged rather than silently missing.
Publisher details
- Operator
- Petrichor Holdings, Inc. · Publisher source
- Operator website
- https://cycle.io · Publisher source
- Vendor relationship
- First-party · Publisher source
- Documentation
- https://cycle.io/docs/mcp/connecting-to-cycle-mcp
- Privacy policy
- Not provided
- Trust center
- Unknown
- Restrictions
- Requires a paid Cycle plan.
Available Tools
45 toolscapture_streamCapture a Live StreamARead-onlyIdempotentInspect
Watch a live Cycle stream for a few seconds and return what arrived, plus the temporary credentials so the user can keep watching with their own websocket client. Targets:
instance_console (environment + container [+ instance]): the container's live console output — crash messages and startup errors as they happen.
server_console (server): the host's agent console output.
instance_telemetry (environment + container [+ instance]): live per-second JSON resource snapshots for one instance.
server_telemetry (server): live JSON stats for a server.
Use this when snapshot data is not enough: logs come back empty, telemetry lags (snapshots can trail by ~10 minutes), or the problem is happening right now. An empty capture is a valid observation — it means the stream was quiet for the window.
Streams replay recently buffered output when you connect, so a capture is NOT all fresh: frames arriving in roughly the first second are counted as replayed BACKLOG (backlog_bytes) and may predate the capture by a long time; only what arrives after that counts as live output (live_bytes). Console captures insert a marker line between the two; telemetry frames carry [T+offset] arrival prefixes. backlog_bytes>0 with live_bytes=0 means nothing new happened while watching — never treat replayed backlog as proof of what the process is doing right now. A large capture is trimmed to the most recent ~16KB and flagged truncated (with total_bytes = the untrimmed size).
The returned token is short-lived, observation-only, and expires on its own; there is no revoke step. Read-only: nothing can be sent to the stream through this tool.
Inputs: target (required), server, context, instance, +4 more.
check_dns_propagationCheck DNS Resolution and PropagationARead-onlyIdempotentInspect
Answer "why doesn't this domain work yet" by asking DNS directly, from two sides at once: the zone's OWN authoritative nameservers (read from its live NS delegation, so whatever actually answers — one of Cycle's na/eu pools, or an outside provider) and the public recursive resolvers (what a real client sees). Comparing the two separates failures that look identical from a browser: resolved, propagating (nameservers have it, public resolvers not yet — WAIT for the TTL, change nothing), no-address (name exists, no A/AAAA — on Cycle, a LINKED record whose target has not published addresses), nxdomain (never created or deleted), or unknown (nothing reachable — proves nothing either way). The verdict's detail explains each case in context.
It also reports whether Cycle itself holds a record for this name (zone, type, and for LINKED records the container/VM/deployment it targets), which distinguishes "never created in Cycle" from "exists and still spreading".
Pass wait_seconds to keep re-probing until the name resolves everywhere. Read-only: only asks questions of DNS servers. To create or repoint a record, use manage_dns_record.
Inputs: domain (required), context, record_types, wait_seconds, +2 more.
check_server_provisioningCheck Server Provisioning ProgressARead-onlyIdempotentInspect
Track servers coming online after deploy_servers: reports the deployment job's state and every server in the cluster with its current state (new → provisioning → configuring → live). A server is ready once it reaches 'live', meaning CycleOS booted and the server is checking in. Pass wait_seconds to keep polling up to that bound — progress updates stream to the client while it waits — or 0 (the default) for a single snapshot. Provisioning almost always outlasts a single call: bare metal takes many minutes, so the reliable pattern is repeated snapshot calls until ready is true, not one long wait. Read-only.
Inputs: cluster (required), job, context, wait_seconds, +1 more.
configure_serverConfigure a ServerADestructiveIdempotentInspect
Change the host-level configuration of a Cycle server: its nickname, its tags (the labels containers target through constraints.node.tags), what it allows (pool: containers with no tags; services: environment service containers; overcommit: CPU shares beyond the hardware, by overcommit_multiple), its base volume size (the space reserved for images; grows only, never shrinks), whether it accepts SSH and SFTP connections (SFTP is required for container volumes with remote access), whether gateway services may run on it, and the shared file systems it exposes to containers. Shared file systems come in two kinds, each under an identifier: a shared DIRECTORY on the host, and a shared MOUNT that attaches an external file system (NFS, EFS, ...) with a type, mount options, and source. Containers mount an identifier via shared_file_systems on deploy_application or reconfigure_container; this tool is the server half only.
Nickname, tags, and allow apply immediately in one update with no job; tags are a complete replacement set, allow merges the passed flags over the current ones. Cycle applies features and shared file systems as two separate jobs, each replacing that whole group: the tool reads the current values, lays the fields you pass over them, and submits the full result, so anything you don't pass keeps its value. Shared file system directories and mounts are added (or replace an existing identifier); remove drops identifiers. Mount type, options, and source go to the host's mount verbatim, and a source the host cannot reach fails that job. Reconfiguring does not restart the server.
Always call with preview:true first: it returns the server's current tags, allow flags, features and shared file systems, the field-by-field change list, the containers across the hub whose placement constraints reference a tag being removed ('constrained_by'), and for every identifier being removed or replaced the containers that mount it ('mounted_by'). With nothing to change, preview is a read of the server's configuration. Confirm with the user, then call again without preview. Steps run the update (nickname, tags, allow) first, then features, then shared file systems, and stop at the first failure; read 'steps' rather than assuming all-or-nothing.
Inputs: server (required), ssh, sftp, tags, +9 more.
create_environmentCreate an EnvironmentAInspect
Create a new environment on a Cycle cluster and, by default, start it so discovery DNS and the scheduler are running and it is ready to deploy into. The load balancer is only created when the environment's services start with a public container present; deploy_application handles that after deploying public containers.
An environment is a group of containers with a private network between them. The private network is IPv6-only; containers resolve each other by hostname via the discovery service.
legacy_networking enables private IPv4 in the environment. This choice is PERMANENT — it cannot be changed after creation — and should be avoided unless an application truly cannot support IPv6. Prefer enabling the app's IPv6 support instead (e.g. mongod --ipv6).
The cluster is the set of servers the environment schedules onto; find cluster identifiers with list_servers. Creating an environment is a mutation: confirm name, cluster, and legacy_networking with the user before calling.
Inputs: name (required), cluster (required), start, context, +5 more.
cycle_control_containerControl ContainerADestructiveInspect
Start, stop, or restart a container on Cycle. Waits up to wait_seconds for the job to finish and returns the container's final state. Use list_containers first only if unsure what exists.
Inputs: container (required), environment (required), action, context, +2 more.
cycle_control_environmentControl EnvironmentADestructiveIdempotentInspect
Start or stop a Cycle environment. Starting brings up the environment's service containers: discovery (the environment's private DNS), scheduler, and — only once the environment has a public container — the load balancer. Containers in an environment cannot resolve each other by hostname until discovery is running — start the environment BEFORE deploying or setting up multi-container applications in it. Starting an already-live environment is safe and restarts any stopped services. Each service is itself a container and can be started or restarted individually with cycle_control_container using its container id.
Stopping an environment stops its services AND every container in it — treat it as highly disruptive.
Both actions are mutations: confirm with the user before calling. Waits up to wait_seconds for the job and returns the environment's state.
Inputs: environment (required), action, context, wait_seconds, +1 more.
cycle_control_virtual_machineControl Virtual MachineADestructiveInspect
Start, stop, or restart a virtual machine on Cycle. Waits up to wait_seconds for the job to finish and returns the VM's final state. Starting requires a hypervisor-capable server in the cluster (list_servers reports 'virtualization'); the first boot downloads the disk image and can exceed the wait — the job keeps running on Cycle. Log in with the VM's SSH keys or the root password Cycle generated at creation (retrievable for ~10 minutes afterward). stop and restart interrupt the running guest OS.
Inputs: environment (required), virtual_machine (required), action, context, +2 more.
decommission_serverDecommission ServerADestructiveInspect
PERMANENTLY decommission (delete) an infrastructure server from the Cycle hub. This is IRREVERSIBLE through this tool — the server is removed from the cluster and, for provider-managed servers, typically destroyed at the provider. Cycle refuses to decommission a server that still has running instances, and this tool never forces past that: the environments or containers using the server must be deleted (or their instances stopped/migrated) first.
This tool is two-step by design and NOTHING is decommissioned on the first call:
Call without confirm. The server is resolved and the response describes it — hostname, nickname (if set), ID, cluster, provider/model/location, when it was created, its current uptime, and every instance still placed on it with its state and owning environment. Present ALL of those details to the user verbatim.
Only after the user explicitly approves decommissioning that specific server, call again with confirm:true and server set to the exact 24-char hex ID from step 1 (hostnames are not accepted with confirm — the ID binds the action to what the user approved).
Never set confirm:true unless the user has just approved this exact decommission; a general instruction like "scale down the cluster" is not sufficient.
Inputs: server (required), confirm, context, wait_seconds, +1 more.
delete_containerDelete ContainerADestructiveInspect
PERMANENTLY delete a container on Cycle. This is IRREVERSIBLE: it destroys the container, every one of its instances, and any data on stateful local instances.
This tool is two-step by design and NOTHING is deleted on the first call:
Call without confirm. The container is resolved and the response describes exactly what would be destroyed — name, ID, environment, when it was created, and how many instances exist, their state, and which servers they run on. Present ALL of those details to the user verbatim.
Only after the user explicitly approves deleting that specific container, call again with confirm:true and container set to the exact 24-char hex ID from step 1 (names are not accepted with confirm — the ID binds the deletion to what the user approved).
Never set confirm:true unless the user has just approved this exact deletion; a general instruction like "clean up the environment" is not sufficient. Containers with deletion protection (lock) cannot be deleted until unlocked; reconfigure_container with lock:false lifts it, which is itself a change the user must approve.
Inputs: container (required), confirm, context, environment, +2 more.
delete_dns_recordDelete DNS RecordADestructiveInspect
PERMANENTLY delete a single DNS record from a Cycle zone. This is IRREVERSIBLE: the record stops resolving, and for a linked record Cycle also tears down its load-balancer routing and stops maintaining its TLS certificate.
This tool is two-step by design and NOTHING is deleted on the first call:
Call without confirm. The record is resolved and the response describes exactly what would be removed — its name, ID, type, full payload, resolved domain, and zone. Present ALL of those details to the user verbatim.
Only after the user explicitly approves deleting that specific record, call again with confirm:true, zone set to the zone from step 1, and record_id set to the exact 24-char hex ID from step 1 (names are not accepted with confirm — the ID binds the deletion to what the user approved).
Addressing for the preview: pass a full 'domain' (e.g. 'app.example.com' — the covering zone and record name are derived; apex = '@'), or 'zone' plus 'name' (or 'record_id'). When several records share the name, 'type' or 'record_id' disambiguates.
Never set confirm:true unless the user has just approved this exact deletion; a general instruction like "clean up the zone" is not sufficient. To create or repoint records use manage_dns_record; to delete a whole zone, surface that as a gap — this tool only deletes single records.
Inputs: name, type, zone, domain, +5 more.
delete_environmentDelete EnvironmentADestructiveInspect
PERMANENTLY delete an environment on Cycle and EVERYTHING in it: all containers and their instances (including data on stateful instances), all virtual machines and their disks, all scoped variables, and the environment's service containers (discovery, VPN, load balancer). This is IRREVERSIBLE.
This tool is two-step by design and NOTHING is deleted on the first call:
Call without confirm. The environment is resolved and the response inventories exactly what would be destroyed — the environment's name, ID, and creation date, every container with its instance count, instance totals and the servers they run on, every VM, and every scoped variable. Present ALL of those details to the user verbatim.
Only after the user explicitly approves deleting that specific environment and its full contents, call again with confirm:true and environment set to the exact 24-char hex ID from step 1 (names are not accepted with confirm — the ID binds the deletion to what the user approved).
Never set confirm:true unless the user has just approved this exact deletion; a general instruction like "clean things up" is not sufficient. To delete a single container instead, use delete_container.
Inputs: environment (required), confirm, context, wait_seconds, +1 more.
delete_image_sourceDelete an Image Source or Its ImagesADestructiveInspect
PERMANENTLY delete an image source together with every image built from it, or — when image_ids are given — only those images while keeping the source. IRREVERSIBLE.
An image a container is currently running on cannot be deleted; the preview lists such containers as a blocker. Stack builds do not use image sources, so this tool never touches a stack's images — use delete_stack for those.
Two-step, nothing is deleted on the first call:
Call without confirm. The response inventories the source, the images that would go, and any containers on them. Present it to the user verbatim.
Only after the user explicitly approves that specific deletion, call again with confirm:true, the exact 24-char hex source ID from step 1, and the same image_ids (if any).
Inputs: source (required), confirm, context, image_ids, +2 more.
delete_stackDelete StackADestructiveInspect
PERMANENTLY delete a stack on Cycle together with ALL of its builds. This is IRREVERSIBLE.
Cycle refuses to delete a stack while any container deployed from it exists, so the preview reports such containers as a blocker. Teardown order: delete the containers first (delete_environment removes every container in an environment; delete_container removes one), then the stack. Linked DNS records do not block anything and can be deleted at any point, in parallel.
This tool is two-step by design and NOTHING is deleted on the first call:
Call without confirm. The stack is resolved and the response inventories what would be destroyed — the stack's name, ID, identifier, and creation date, its builds — and lists any containers deployed from it that block the deletion. Present ALL of those details to the user verbatim.
Only after the user explicitly approves deleting that specific stack, call again with confirm:true and stack set to the exact 24-char hex ID from step 1 (names are not accepted with confirm — the ID binds the deletion to what the user approved).
Never set confirm:true unless the user has just approved this exact deletion; a general instruction like "clean things up" is not sufficient.
Inputs: stack (required), confirm, context, wait_seconds, +1 more.
delete_virtual_machineDelete Virtual MachineADestructiveInspect
PERMANENTLY delete a virtual machine on Cycle. This is IRREVERSIBLE: it destroys the VM and its local volumes, including the base (boot) volume and everything the guest OS wrote to them. A running VM is powered off, not shut down gracefully.
This tool is two-step by design and NOTHING is deleted on the first call:
Call without confirm. The VM is resolved and the response describes exactly what would be destroyed — name, ID, identifier, state, image, when it was created, and its volumes. Present ALL of those details to the user verbatim.
Only after the user explicitly approves deleting that specific VM, call again with confirm:true and virtual_machine set to the exact 24-char hex ID from step 1 (names are not accepted with confirm — the ID binds the deletion to what the user approved).
Never set confirm:true unless the user has just approved this exact deletion; a general instruction like "clean up the environment" is not sufficient. VMs with deletion protection (lock) cannot be deleted until unlocked; reconfigure_virtual_machine with lock:false lifts it, which is itself a change the user must approve. Attached EXTERNAL (SAN) volumes are detached rather than destroyed, but local volumes are gone for good — if the guest holds data worth keeping, copy it out first (run_vm_command).
Inputs: virtual_machine (required), confirm, context, environment, +2 more.
deploy_applicationDeploy an ApplicationADestructiveInspect
Deploy a multi-container application onto Cycle. You supply the app knowledge (image, command, env, ports, volumes, how many members and how they address each other); the tool turns it into a Cycle stack spec, creates and builds the stack, and deploys it into an environment. For a workload that truly needs a full virtual machine use deploy_virtual_machine.
Modes: by default everything deploys through a stack (containers that version and deploy together). One application is ONE call and one stack: every container it needs — data nodes, UI, sidecars — goes in the same 'containers' list. Containers are created stopped, so "incremental" means starting and checking them one at a time afterwards, not deploying them in separate calls; a stack cannot be extended with more containers later. Separate stacks are for independent applications that release on their own. stack:false creates one-off containers directly in the environment with no stack objects. Every rule below applies to both.
Existing stacks: a call with 'containers' ALWAYS creates a new stack. When the user names a stack that already exists — built by this tool, the dashboard, or from a git repo — pass stack_id instead and leave 'containers' out (or pass the original list only to link domains). It deploys the stack's latest usable build into the environment; build_id picks a specific build, rebuild:true generates a fresh build from the stack's source first. Containers the stack already has in that environment are left untouched unless 'redeploy' says to update them — rebuild:true plus redeploy:{reimage:true} is how a new image tag or commit is rolled out to a running deployment. preview:true reports the stack's recent builds, the containers the chosen build creates, and which existing ones would be updated.
MUST GET RIGHT — Cycle accepts these and the application is then silently unreachable or insecure. Preview checks them and an error finding blocks the deploy:
Listen on ::. The private network is IPv6-ONLY (discovery serves AAAA records) and the load balancer reaches backends over it, so a process on 0.0.0.0 or localhost is unreachable from siblings and from the LB. IPv4-default apps need IPv6 enabled explicitly (mongod --ipv6, HOST=::), and so do client libraries (Node's ioredis needs ?family=6 on the URL).
TLS through the LB needs BOTH "443:" and "80:80" in ports. "443:80" is Cycle notation: LB ingress 443 routes to backend 80 with TLS terminated at the LB.
Secrets never go in env or args — both are stored in plain text in the stack. Sequence: deploy (containers are created stopped) → create scoped variables with manage_scoped_variable and source.secret:true → start with cycle_control_container. First boot reads them (postgres initdb reads POSTGRES_PASSWORD once; redis needs its config file present).
Stateful containers deploy as a SINGLE instance with their own volume. Model a clustered app as N separate single-instance stateful containers (mongo-0, mongo-1, ...), each with its own volume and unique hostname. Containers reach each other by hostname; the environment must be live for discovery to resolve them.
Placement is unconstrained by default — a container may land on ANY server whose pool allows it, so cluster members can spread across providers. Pin hardware with constraints.node.tags.all (every tag present) or .any, and confirm the tag exists with list_servers BEFORE deploying (configure_server sets a server's tags); a tag matching no server leaves the container with no deployment target.
public defaults to "disable". Set it only to expose a container.
Images — each container sets exactly ONE of: image (a Docker Hub target like 'mongo:7'; an existing image source with the same origin is reused), image_source (already on Cycle — prefer it whenever the user has one, it carries their registry credentials and build config), or dockerfile (repo or targz_url for Cycle to build). Registry and git credentials are never accepted directly.
Shared file systems — 'shared_file_systems' mounts a shared directory or shared mount a SERVER exposes (by identifier; see list_servers) at a path in the container, read-only or writable; every container that mounts the same identifier shares the files. The identifier must already exist on a server; preview reports which servers expose it, and when none does, offer to add it with configure_server before deploying.
Backups — 'backups' (stateful containers only) has Cycle run 'command' on the cron 'schedule' inside the container and ship its STDOUT to a backup-capable hub integration ('destination', e.g. Backblaze B2); 'restore_command' reads a backup from STDIN. All four are required; the destination must already be enabled on the hub. Commands may reference env vars (mongodump -u $USER) but the tools they call must exist in the image.
Domains — 'domain' exposes a container through the environment load balancer. A DNS zone covering it must already exist; the tool creates a LINKED record pointing at the container and never overwrites an existing one (conflicts are errors to resolve with the user). Forces public:"enable" and requires ports; TLS on the record follows from a '443:' mapping. Cycle creates the environment load balancer only when the environment's services start with a public container present, so after deploying public containers into an environment without one the tool starts the environment's services itself; if that fails the response carries 'load_balancer_missing'.
'application' hint — pass an app name with NO containers to get recommended per-container config, topology, and caveats, then compose the container list from it. Unknown names return the known names instead of an error.
Workflow: 1) call with preview:true — returns the exact spec that would deploy plus checklist findings, and makes NO changes. 2) Confirm with the user, then call again without preview. Never deploy without explicit confirmation.
Asynchronous and RESUMABLE: containers appear only at the last step, so an early empty list_containers means "still working". Every response carries stack/build/job ids, 'phase', and 'recommended_action'. After a transport failure, repeat the call with the same name/deployment_id and follow 'recommended_action' ('wait', 'resume' with stack_id, or 'nothing_to_do'). A stack_id call is idempotent at every phase.
Inputs: environment (required), name, stack, context, +11 more.
deploy_serversDeploy Servers from an Infrastructure ProviderAInspect
Provision new servers (bare metal or VMs running CycleOS) from a connected infrastructure provider into a cluster. THIS COSTS THE USER REAL MONEY, billed by the provider directly — never call it with confirm=true unless the user has explicitly approved the exact plan and its estimated cost in this conversation. Without confirm, the call is a safe dry run: it validates the model, location, and zone against live provider data and returns the plan with the estimated monthly cost increase at the provider for the user to approve. At most 10 servers per call. Use get_deployable_server_models first to find valid models and locations. Deploying returns a Cycle job; track it and the servers coming online with check_server_provisioning.
Inputs: cluster (required), servers (required), provider (required), confirm, +2 more.
deploy_virtual_machineDeploy a Virtual MachineADestructiveInspect
Deploy a virtual machine onto Cycle. Prefer containers (deploy_application) for ordinary workloads; choose a VM only for hard isolation requirements, a custom OS or kernel (custom modules, non-Linux), or legacy software that cannot be containerized.
Platform rules this tool applies or checks:
The environment's cluster must contain a hypervisor-capable server. list_servers reports 'virtualization' per server; the response notes when no live server in the cluster confirms it. When hardware has to be provisioned for VMs, get_deployable_server_models reports 'hypervisor' per model (and takes hypervisor_only).
Image: exactly one of base_image or image_url. Call with NEITHER to fetch the live base-image catalogue (version identifiers, supported/UEFI flags) without deploying — do that first unless the user named an exact image; prefer versions marked supported. iPXE and external-volume image sources are not exposed here (a 'base' volume backed by a SAN volume is a different thing and IS supported).
Resources are explicit: ram is required, plus exactly one of cores or cpu_pin.
Storage: volumes MUST include the boot volume, identifier 'base'; creates without one are refused. Other volumes attach as RAW BLOCK DEVICES the guest must partition, format, and mount — remind the user.
Access: Cycle generates a root password at create. It is returned here but retrievable for only ~10 minutes, so relay it to the user promptly (afterwards reconfigure_virtual_machine sets a new one). SSH keys attach at provision time: ssh_keys references existing environment-scoped keys, new_ssh_keys creates and attaches them. Serial-over-SSH console access needs no VM networking: get_vm_console_access mints credentials for the user's own interactive session, and run_vm_command runs a single command and returns its output (in-guest setup like partitioning a volume goes through it).
Networking follows the container conventions: IPv6-ONLY private network, hostname defaults to the identifier, public defaults to 'disable', ports map like '443:443'. Point a domain at the VM afterwards with manage_dns_record (records can link to VMs).
Placement: constraints.node.tags.all/.any restricts which tagged servers may host the VM — same tag model as deploy_application; useful when only some servers are hypervisor-capable.
Workflow:
If the user hasn't picked an image, call with no base_image/image_url to list the base images.
Call with preview:true — returns the exact create request (read-only lookups only; nothing is created) to confirm with the user. Never create without explicit confirmation.
Call again without preview. The VM is created and, unless start:false, started. The first boot downloads the disk image and can outlast wait_seconds; the job keeps running on Cycle (check list_virtual_machines or get_jobs).
Retries are safe: identifier (default: slug of name) is the idempotency key — a repeat call refuses to create a duplicate and reports the existing VM. Pass a fresh identifier to deliberately create another alongside it.
Inputs: ram, name, cores, ports, +19 more.
diagnoseTriage a ProblemARead-onlyIdempotentInspect
Triage a "something is wrong" report on Cycle. Give it the environment, container, and/or server the user suspects; it fans out the platform's high-signal diagnostic reads concurrently and returns findings ranked critical > warning > info, each naming the follow-up tool (with arguments) to run next. Always start here when the problem is vague, then drill down with the suggested tools.
Problem-class guide — pass as focus, or omit to run every check the scope allows:
Container or VM unreachable from its URL → focus "unreachable" with environment (+ container). Covers virtual machines as fully as containers — a LINKED record can point at either. Cross-checks three independent layers so a pass at one never masks a failure at another: (1) ingress CONFIG — LINKED records vs the target's public network and port mappings against the LB's actual controller config, DMZ records included; (2) DNS RESOLUTION — each linked domain against its zone's authoritative nameservers AND public resolvers, which is the only way to see an unpropagated or address-less record; (3) an END-TO-END synthetic HTTP GET at each linked domain (max 5, from the MCP server's network) — probe.http.ok means VERIFIED SERVING, and 502-504 usually means the app is bound to localhost or IPv4-only instead of :: . Also covers LB/gateway/discovery service health, instance readiness, and LB destination errors. A target can be fully healthy yet unreachable — config mismatches are the most common cause; every finding carries a machine-readable code and explains itself.
Container stopped, crashing, or restarting → focus "crashloop" with container. Checks state drift, broken instances, restart/healthcheck events, and error-pattern logs.
Out of disk / containers can't write → focus "storage" with server (or container — a "no space left" log traces to its host). Checks storage pool and mount utilization, storage-full events.
CPU/RAM running low → focus "resources" with server or container. Checks load vs cores, RAM headroom, allocation pressure, instance OOM/throttling.
Containers not talking to each other → focus "networking" with environment (+ server for mesh problems). Checks discovery/VPN services, mesh and neighbor events; suggests the neighbor_latency metrics preset.
Stack build stuck or failed, deploy never produced containers → focus "build" with stack (+ build id), or with a container deployed from the stack. Reads the build's state and error and every image build it contains, attaching the tail of each failed build log as evidence.
LB weirdness / 502s → focus "load_balancer" with environment. Checks LB service state, DNS-record-to-container port routing, disconnect reasons, per-destination response codes, plus the synthetic HTTP probe above. LB telemetry lags several minutes and 404s when absent — that never means the LB itself is gone.
A finding of category "platform" means a diagnostic read itself errored or could not be attempted — run the suggested tool manually. healthy=true means no warning-or-worse findings in the window (default: the last hour). Anything that could NOT be verified (an unprobed ingress path, unreachable DNS) is reported as a warning so healthy is never true by omission. Read-only: this never changes anything. For in-container investigation afterwards, use run_instance_command; for a VM guest, run_vm_command; for live output, capture_stream.
Inputs: build, focus, stack, server, +5 more.
get_deployable_server_modelsGet Deployable Server ModelsARead-onlyIdempotentInspect
Discover what infrastructure can be provisioned on this hub. Called with no arguments, it lists the enabled infrastructure-provider integrations. Pass 'providers' to also list the server models each offers — specs, datacenter locations, and estimated pricing — limited to one or two providers per call since some offer hundreds of models; narrow further with category, location, max_monthly_price_usd, and hypervisor_only. category matches each PROVIDER's own naming (values like 'bare-metal', 'general', 'high-frequency', 'high-performance', 'optimized-dedicated', 'vx1' — provider-specific, not a Cycle taxonomy), so list without it first and read the real categories off the results; a filter that matches nothing reports the categories that were actually available. To find hardware that can host virtual machines use hypervisor_only, NOT a category guess. Use it to answer questions like 'what infrastructure providers are enabled on my hub', 'what bare metal servers does offer', 'what servers are available under $50/mo', or 'which models can host virtual machines', and to verify a specific model and location exist before any server deployment is considered. All prices are estimates reported by the provider and are billed by that provider directly to the user's account there, not by Cycle. Read-only: this tool never provisions anything.
Inputs: limit, context, category, location, +5 more.
get_deployment_statusGet Deployment StatusARead-onlyIdempotentInspect
Report where deployments (Cycle stacks and their builds) stand — the reconciliation tool when a deploy_application call was interrupted, timed out, or its response was lost. Read-only.
Without arguments it lists recent stacks, newest first, each with its latest build. Pass 'stack' for one stack's detail including recent builds and their errors. Pass 'environment' to also see which of a stack's containers exist there — containers are created only by the final deploy step, so an empty container list on a live build means "generated but not yet deployed into this environment", not "failed".
Each stack carries a derived 'phase':
generating: the latest build is still compiling/importing (new, building, importing, verifying, saving) — the pipeline is in flight, nothing is wrong.
deploying: the build is being deployed into an environment right now.
generated: the build is live; with 'environment' given, no containers from it exist there yet — the deploy step still needs to run.
deployed: the build is live and its containers exist in the given environment.
failed: the latest build ended with an error (shown on the build).
To deploy a listed stack — reuse it in an environment, or continue an interrupted deployment — call deploy_application with stack_id set to the stack's id: it deploys the latest usable build, or a fresh one with rebuild:true, and picks up from the build's current state. Never resubmit a deployment from scratch after a timeout; check here first.
Inputs: limit, stack, context, environment, +1 more.
get_hubDescribe the Authenticated HubARead-onlyInspect
Describe the hub this session is authenticated to, plus the account's membership role and Cycle capabilities in it. Call it only when the user asks about their hub, account, role, or permissions. Do not call it to pre-check whether another tool is allowed: call that tool directly and report its error if Cycle denies it.
Inputs: context, conversation_id.
get_jobsGet Job StatusARead-onlyIdempotentInspect
Check the status and progress of one or more Cycle jobs by ID. Cycle runs mutating work asynchronously as jobs; tools that submit work (like migrate_instances or cycle_control_container) return job IDs you can track here. Pass wait_seconds to block until every job reaches a terminal state (completed, error, or expired) up to that bound, or 0 to get an immediate snapshot. all_done is true when every requested job has completed successfully.
Inputs: jobs (required), context, wait_seconds, conversation_id.
get_logsSearch Container LogsARead-onlyIdempotentInspect
Search aggregated logs from Cycle containers. First stop for crash loops, application errors, and confirming "out of memory" / "no space left" style failures. Use after diagnose points at a specific container or instance, or directly when the user names one.
Scope with environment for environment-wide logs, add container to narrow, add instance to narrow further — the most specific reference wins. Search is optional; without it the newest lines in the range are returned. Use search_type "regexp" with RE2 syntax for patterns like "(?i)error|panic". context_window returns surrounding lines after each match (lines sharing a context_window ID belong to the same match).
Defaults to the last hour. If nothing comes back, widen the range or loosen the search — a container that just started may also not have shipped logs yet. Read-only.
To wait for a line to APPEAR (readiness/migration-done markers like "database system is ready"), pass search plus wait_seconds: the call polls until the first match or the budget elapses, instead of you sleeping between calls. A no-match result after the wait is not failure — repeat the same call to keep waiting.
Inputs: limit, search, compact, context, +9 more.
get_more_toolsRequest a Missing ToolARead-onlyIdempotentInspect
Call this whenever the user's request cannot be satisfied by the available tools. Describe the missing tool or capability so it can be considered for a future release, then continue helping the user as best you can with the tools that exist.
Inputs: capability (required), context, conversation_id.
get_telemetrySummarize Resource TelemetryARead-onlyIdempotentInspect
Summarized resource telemetry from Cycle, with anomaly flags. Pick a target:
target=instance (needs environment + container, plus instance when there are several): per-instance CPU usage (relative to the host and to the instance's effective CPU allocation) and throttling, memory usage vs limit and OOM fail count, swap, network errors, process count, plus the server it runs on and the container's configured reserve/limit. Use for one hot or crashing container.
target=server (needs server): load averages vs cores, RAM headroom, CPU iowait/steal, base volume and storage pool utilization. Use for "server out of resources / disk" suspicions.
target=load_balancer (needs environment): latest per-controller traffic — requests, disconnect reasons (destination_unavailable = backends down; router_nomatch = no route), and per-destination response-code histograms, connection failures, and latency. Use for 502s and unreachable-URL problems. Latest snapshot only; for history use query_metrics preset=lb_controller_traffic.
Returns min/avg/max/latest summaries rather than raw series. Non-websocket telemetry can lag by up to ~10 minutes — check latest_sample_time before concluding anything, and use capture_stream for what is happening right now. Read-only.
Inputs: target (required), server, context, instance, +5 more.
get_vm_console_accessGet Serial Console Access to a VMADestructiveInspect
Mint serial-over-SSH credentials so the USER can open their own interactive console session on a virtual machine, and return the exact ssh command to run. Use this when a person wants to drive the console themselves — poke around, watch a boot, run an interactive installer or a TUI. To run a specific command and get its output back, use run_vm_command instead; do NOT take these credentials and try to drive an interactive shell yourself.
What comes back: the ssh command, the connection address, the connection secret (used at ssh's own password prompt), and the token's expiry. The credentials reach the VM's serial console through the Cycle gateway — no VM networking required, so this works even with public networking disabled or the guest's network broken.
Logging IN to the guest is separate: past ssh, the console lands at the guest's own login prompt. The response includes the generated root password when it is still retrievable (~10 minutes after creation); after that the user needs their own guest credentials or an attached SSH key.
Relay the credentials to the user plainly so they can paste the command. They are short-lived and they grant root-capable console access — treat them as a secret, do not write them into files, commits, or issues.
action:"revoke" expires ALL serial-over-SSH tokens for the VM, immediately disconnecting every active console session on it (including a session the user is in the middle of, and anyone else's). It is a mutation: confirm with the user before calling it.
Inputs: environment (required), virtual_machine (required), action, context, +1 more.
list_containersList ContainersARead-onlyIdempotentInspect
List containers in the Cycle hub, optionally scoped to one environment. Use to discover what exists, check current state, or disambiguate when multiple containers share a name. Prefer passing environment to narrow results. If has_more is true, call again with page = next_page.
Inputs: page, limit, state, search, +3 more.
list_dns_zonesList DNS Zones and RecordsARead-onlyInspect
List the hub's DNS zones (origin, hosted, state), or the records of one zone when 'zone' is given. Hosted zones are served by Cycle directly; non-hosted zones hold records that configure the load balancer/TLS but require the user to manage the actual DNS externally. Read-only. Use manage_dns_record to create or repoint records.
Inputs: zone, context, conversation_id.
list_environmentsList EnvironmentsARead-onlyIdempotentInspect
List all environments in the authenticated Cycle hub, with their current state. An environment must be 'live' for its containers and services (discovery DNS, load balancer, scheduler) to run — deploying into a non-live environment yields containers with no working networking.
Inputs: context, conversation_id.
list_image_sourcesList Image Sources and ImagesARead-onlyInspect
List the hub's image sources — where container images are pulled or built from (Docker Hub target, private registry, Dockerfile repo) — with per-state image counts and their newest images. Pass 'source' to inspect one source with its full image history. Read-only.
Stacks do NOT use image sources: a stack build produces its own images (source type 'stack-build'), which are owned by the stack and vanish with it. Image sources come from deploy_application with stack:false (one per Docker Hub target, reusing an existing match) or from the dashboard, so a source with no live image is usually left over from a deleted one-off container.
Inputs: images, search, source, context, +1 more.
list_scoped_variablesList Scoped VariablesARead-onlyIdempotentInspect
List an environment's scoped variables — environment-level values/secrets injected into containers at runtime. Shows each variable's scope (global or specific containers), the containers it currently reaches, its delivery method(s) — environment variable, file, and/or internal API unix socket — and whether its value is raw or fetched from a URL at container start. Raw values are omitted unless include_values is true.
Inputs: environment (required), context, include_values, conversation_id.
list_serversList ServersARead-onlyIdempotentInspect
List the physical/virtual servers making up your Cycle infrastructure, grouped by cluster (Cycle uses clusters for physical isolation). Use to see what hardware exists, which cluster it belongs to, its provider and state, and the platform's view of its host agent (online, healthy, shutting_down, last_checkin; 'live' state alone does not mean reachable or healthy). hostname and nickname are matched as case-insensitive substrings, so a partial hostname is enough to find a specific server. cluster and state are exact filters applied by the Cycle API.
Each server also reports constraints: constraints.tags is the list of tags on that server, and constraints.allow.pool is true when the server accepts containers that specify no tags. Placement is driven by these SERVER tags — a container restricts itself to a subset of servers via its own config.deploy.constraints.node.tags (see deploy_application), and a Cycle cluster does NOT narrow placement on its own. Read tags here to confirm a tag exists before referencing it in a container constraint (set them with configure_server); note that if every server has allow.pool true, an unconstrained container can land on any of them.
Each server also reports 'virtualization': true means it can host virtual machines (see deploy_virtual_machine); absent means the capability is unknown (node stats unavailable). 'features' is the host configuration (base volume GB, ssh, sftp, gateway) and 'shared_file_systems' the shared directories and mounts (NFS etc.) the server exposes by identifier — the identifiers a container may mount via shared_file_systems; both are changed with configure_server. 'os' (kernel, CycleOS build), 'uptime', 'versions' (Cycle agent and compute) and 'drivers' are as of the node's last check-in.
EVERY cluster visible to the credential is listed, including clusters that hold no servers at all (count 0, empty servers list) — a cluster exists on Cycle independently of any hardware in it, so an empty cluster here is a real cluster awaiting servers, not a missing one. This is the authoritative list of what clusters exist.
Inputs: state, cluster, context, hostname, +3 more.
list_virtual_machinesList Virtual MachinesARead-onlyIdempotentInspect
List virtual machines on the hub with their current state, image, resources, and assigned public IPs. Filter by environment and/or state. Use this to check on a VM (e.g. whether a deploy or start finished — the disk image download on first boot can take a while) and to find a VM's ID before controlling it. VM names are not guaranteed unique; disambiguate with the identifier or ID. Created VMs live in an environment and share its IPv6-only private network with containers there.
Inputs: state, context, environment, conversation_id.
manage_clusterCreate or Update a ClusterADestructiveInspect
Create or update a cluster — Cycle's unit of physical isolation, grouping servers that share a private network and can host the same environments. Servers in different clusters share no network, which makes separate clusters the right tool for dev/staging/prod separation. Use list_servers to see existing clusters and what they hold.
Creating a cluster is a hub-level change but provisions no infrastructure and costs nothing on its own; servers are added separately with deploy_servers.
Cycle deliberately returns the same 403 permission error for a cluster that does not exist and for one the credential has no ACL access to, so neither this tool nor any other can tell those apart. That means a create may fail because the cluster already exists out of view — the error will say so, and the fix is access to it, not a second create.
update only changes non_essential; Cycle exposes no rename, and monitoring tiers are configured elsewhere.
Called with no action, this tool just ensures the cluster exists: it creates a missing one, and reports an existing one unchanged (action "none") rather than trying to update it. Pass action explicitly when you specifically mean to create or to modify.
Always call with preview:true first — it validates and reports what would change, touching NOTHING. Get explicit user confirmation, then call again without preview.
Inputs: cluster (required), action, context, preview, +2 more.
manage_dns_recordCreate or Update a DNS RecordADestructiveInspect
Create or update (repoint) a single DNS record in a Cycle zone. Use list_dns_zones to inspect zones and records first. This tool cannot delete records — use delete_dns_record for that.
Addressing: pass a full 'domain' (e.g. 'app.example.com' — the covering zone and record name are derived; apex = '@'), or 'zone' plus 'name'. For update, 'record_id' (with 'zone') disambiguates when several records share a name.
Types: a/aaaa (value = IP), cname/alias/ns (value = target domain), mx (value = mail host, priority), srv (value = target, port, priority, weight), txt (value = text), caa (tag + value), linked — a Cycle-managed pointer at a container, tagged deployment, or virtual machine via the 'linked' object; Cycle wires up the IPs, load-balancer routing, and TLS certificates automatically (the environment load balancer must be running for traffic to flow).
Semantics: create NEVER overwrites — an existing record with the same name and type is an error; use action:update to repoint it. update REPLACES the record's whole type payload with what you pass, and records cannot be renamed. In a non-hosted zone, records still configure the load balancer/TLS but the user must manage the zone's public DNS externally.
Always call with preview:true first — it validates and returns a from/to diff, changing NOTHING. Get explicit user confirmation, then call again without preview.
Inputs: type (required), action (required), tag, name, +11 more.
manage_external_volumesManage External VolumesADestructiveInspect
Manage external volumes: storage outside a server's local disks (SAN over iSCSI, Ceph RBD, AWS EBS) that a container mounts via deploy_application volumes.external. A volume belongs to one cluster and location and lists the servers allowed to mount it.
list and describe are reads. scan has an integration report the volumes it exposes to a cluster; they then appear in list with state new/ready. create registers one volume: the named servers fix its cluster and location, the integration authenticates to the storage, and source names the device (lun; image+pool; volume_id, or create_size to allocate a new EBS volume). set_servers replaces the mountable server list. delete is refused while a container uses the volume; delete_source_device also destroys the backing device.
Cycle's catalog decides which source types exist, which are creatable, and which attachment types and modes each supports; it is returned in 'sources' on scan and create. Modes count concurrent attachers (single-instance, single-node, multi-node) and access (writer, read-only); multi-node-writer needs a cluster-aware filesystem.
scan, create, set_servers, delete: preview:true first, confirm with the user, then call again without preview.
Inputs: action (required), mode, name, source, +15 more.
manage_image_sourceEdit an Image SourceADestructiveIdempotentInspect
Edit an image source's name, description, identifier, builder integration, or registry credentials. The origin itself (which registry or repo, which target) cannot be changed — create a new source for that.
Credentials pass through this conversation in plain text, so prefer a webhook (oci-registry) or leave auth to the dashboard when the user has a choice; never invent or reuse a token the user did not supply for this purpose. The response reports the auth mode, never the secret.
Workflow: call with preview:true to see the field-by-field changes, confirm with the user, then call again without preview. An update takes effect on the next import or build; running containers are untouched.
Inputs: source (required), auth, name, context, +5 more.
manage_scoped_variableCreate or Update a Scoped VariableADestructiveInspect
Create or update a scoped variable — an environment-level value or secret injected into containers at runtime. Use list_scoped_variables first to see what exists. This tool cannot delete variables.
A variable has a scope (which containers receive it), access (how it is delivered: env var, file, and/or the in-container internal API — the most secure option), and a source (a raw stored value, or a URL fetched when the container starts, with optional auth for third-party secret services). Any sensitive raw value — a password, API key, token, private key, certificate, or connection string carrying credentials — MUST be created with source.secret:true so Cycle treats it as a secret and this server never returns it.
create never overwrites — an existing variable with the same identifier is an error. update addresses the variable by environment + identifier (or variable_id when identifiers collide), replaces each section you pass (scope, access, source) wholesale, leaves omitted sections unchanged, and renames via new_identifier. Env-variable and file delivery apply when a container (re)starts; running containers keep the old value until restarted.
Always call with preview:true first — it validates and returns the from/to diff plus the containers reached, changing NOTHING. Get explicit user confirmation, then call again without preview.
Inputs: action (required), environment (required), scope, access, +7 more.
migrate_instancesMigrate Container InstancesADestructiveInspect
Migrate a container's or virtual machine's instances between servers on Cycle, or revert a recent migration. Pass exactly one of container or virtual_machine. Cycle backs every VM with a container, so a VM migrates through that container's single instance (select it with all_instances:true or name it in targets); the response reports both the VM and its backing container.
Cycle migrates instances across any infrastructure it manages — between servers, data centers, cloud providers, and on-prem hardware. Not every server is a valid target: containers carry tag restrictions and other constraints, so this tool only accepts destinations Cycle reports as compatible for the container. A migration is reversible: the original instance is retained until Cycle's purge window elapses (roughly 3 hours for stateful instances), during which action:"revert" restores it on its source server. Only retained source instances are revertable; running destination copies are skipped. Load balancer instances cannot be migrated.
Workflow:
Call with preview:true and your selection. It makes NO changes and returns the selected instances — each with its current server (id and name) and whether it is stateful — plus, for migrate, the compatible destination servers. The plan comes from read-only lookups; Cycle does not validate it.
If the destination is unclear, present the compatible servers and let the user choose. With NO compatible servers migration is impossible — tell the user why (tag or infrastructure constraints).
Confirm the specific move with the user, then call again without preview. Never migrate or revert without explicit confirmation.
Select instances with exactly one of: targets (specific instances, each optionally with its own destination so they can spread across servers), source_server ("move this container off nuc-bear"), or all_instances. A top-level destination_server is the default for selected instances without their own and is required with source_server or all_instances.
copy_volumes applies to stateful instances and defaults to true so data is never silently dropped. A VM's local volumes — including its boot disk — are what it moves, so copy_volumes:false lands the VM on empty local storage and is almost never wanted. External (SAN) volumes are attached, not copied, and are unaffected either way.
Asynchronous: submits one job per instance and returns without waiting (wait_seconds gives a short bounded wait for quick moves). Track the job_ids with get_jobs, then call again with preview:true to confirm each instance reports its destination server.
Inputs: environment (required), action, context, preview, +9 more.
query_metricsRun a Metrics AggregationARead-onlyIdempotentInspect
Run a canned aggregation over Cycle's metrics store. Presets:
container_instance_count (scope: container): Hourly instance count for a container; reveals flapping, autoscaling, and unexpected shrinkage.
discovery_resolutions (scope: environment): Hourly internal DNS resolution counts for an environment's discovery service (lookups, cache hits, not-founds). Non-zero not-founds are the smoking gun for containers unable to find each other.
lb_controller_traffic (scope: environment): Hourly load balancer controller metrics for an environment (requests, connections, disconnect reasons, per-destination counters). Historical complement to get_telemetry target=load_balancer.
neighbor_latency (scope: server): Latest server-to-server mesh latency per neighbor; negative latency_ms means the neighbor is unreachable (outage).
server_cpu (scope: server): Hourly CPU usage trend for a server, per CPU state metric.
server_ram (scope: server): Hourly RAM trend for a server (available/free/total KB metrics).
Pass the input matching the preset's scope (server, environment, or container). Metrics data can lag by up to ~10 minutes; each row carries the sample time. No free-form queries — if none of the presets fit, say so rather than improvising. Read-only.
Inputs: preset (required), server, context, container, +3 more.
reconfigure_containerReconfigure a ContainerADestructiveIdempotentInspect
Change an existing Cycle container: its runtime config (start command/args, environment variables, ports, hostname, public network mode, CPU/RAM, automated backups, shared file systems), its instance count, its image, its volumes (extend, read-only), or its metadata (name, identifier, annotations, lock, deprecate). Adding or removing volumes is a redeploy, not a reconfigure. The virtual-machine equivalent is reconfigure_virtual_machine.
Each group reaches Cycle through a different mechanism and differs in disruption; every change in the preview diff is tagged with an 'impact':
'restart' — runtime config. Cycle's reconfigure REPLACES the container's entire config, so this tool fetches the current config, applies only the fields you pass, and submits the whole result; everything you don't pass keeps its value (including deployment constraints, integrations, and devices). Applying RESTARTS every instance; there is no way to change runtime config without a restart. volumes.max_size and volumes.read_only rewrite the volume set through Cycle's volumes.reconfigure task, which also restarts every instance. 'backups' (stateful containers only) merges the passed fields over the current backups integration — destination, command, schedule and restore_command must all be present once merged; backups:{disable:true} removes it. 'shared_file_systems' is the complete replacement set of mounts (keyed by the identifier a server exposes, see list_servers); preview checks that the servers the instances run on expose each identifier and says when to offer configure_server instead.
'scale' — instance count. Instances cannot be changed by reconfiguring; the tool submits Cycle's scale task, which does not rewrite the config. More than 1 instance on a stateful container is allowed but NOT recommended (the tool applies it with a warning note) — prefer separate single-instance containers.
'reimage' — moves the container onto a different image built from the image source it ALREADY uses, keeping its runtime config; instances restart on it. reimage:true imports a fresh image to pick up the latest. image_id reimages onto any live image from that same source, including an older one — that is how you ROLL BACK a bad image: preview with reimage:true, and the response's 'image_options' lists the source's live images newest first with build times and marks the running one; pass the chosen id as image_id (it takes precedence over reimage:true, so nothing is imported). A rollback keeps the CURRENT runtime config, so check the args, env and volume paths still suit the older image and reconfigure them in the same call if not. Switching image sources is a redeploy, not a reimage, and is refused. Stack-deployed containers are refused too — reimage them by building and redeploying the stack. If an import outlives the wait, the response carries the new image_id; call again with it to finish without importing a second copy.
'volume' — volumes.extend grows a local volume's allocation in place with an instance task, no restart; sizes only increase and are capped by the volume's max_size. Passing volumes at all returns the current volumes, each with its max_size and per-instance used/allocated, so a preview with an empty volumes object is a read.
'none' — metadata. Applies immediately: no job, no restart, instances untouched.
Always call with preview:true first — it fetches the current state and returns a field-by-field from/to diff with each change's impact, making NO changes. The diff is computed by this tool, not validated by Cycle; use it to confirm the change matches the user's intent. Get explicit confirmation, then call again without preview.
Changes from several groups are applied in order — metadata, runtime config, volumes, image, instances — and each step is reported in 'steps'. The run stops at the first failed step, so a partial result is possible; read 'steps' rather than assuming all-or-nothing.
Inputs: container (required), environment (required), env, ram, +24 more.
reconfigure_virtual_machineReconfigure a Virtual MachineADestructiveIdempotentInspect
Change an existing Cycle virtual machine: its config (hostname, public network mode, ports, egress, CPU, RAM), its guest root password, its assigned SSH keys, or its metadata (name, identifier, annotations, lock, deprecate). Volumes are NOT handled here — VM volume changes exist on Cycle but have no MCP tool yet; surface that gap rather than improvising. The boot image is fixed at create; there is no VM equivalent of a container reimage. The container equivalent is reconfigure_container.
Each group reaches Cycle through a different mechanism and differs in disruption; every change in the preview diff is tagged with an 'impact':
'restart' — config. Cycle's reconfigure REPLACES the VM's entire config, so this tool fetches the current config, applies only the fields you pass, and submits the whole result; everything you don't pass keeps its value (including deployment constraints, startup/shutdown policies, telemetry, and runtime attachments). Applying RESTARTS the VM — a hard interruption of a running guest OS.
'root-password' — the guest's root password, changed by a Cycle job inside the VM. Neither the preview nor the result echoes it; whoever sets it must record it themselves, since Cycle only makes a VM's root password readable for ~10 minutes after creation.
'none' — metadata and SSH key assignment. Applies immediately: no job, no restart. Cycle stores one flat list of assigned keys; add_ssh_keys/remove_ssh_keys read it, apply your changes, and write it back. Keys are written into the guest at provision time, so a running guest may not honor an added key until it restarts, and removing a key does NOT reliably revoke access for a running guest — to be certain, restart the VM (cycle_control_virtual_machine) and verify from inside the guest.
Always call with preview:true first — it fetches the current state and returns a field-by-field from/to diff with each change's impact, making NO changes. The diff is computed by this tool, not validated by Cycle; use it to confirm the change matches the user's intent. Get explicit confirmation, then call again without preview.
Changes from several groups are applied in order — metadata and SSH keys, then config, then root password — and each step is reported in 'steps'. The run stops at the first failed step, so a partial result is possible; read 'steps' rather than assuming all-or-nothing.
Inputs: environment (required), virtual_machine (required), ram, lock, +19 more.
run_instance_commandRun a Command in a Container InstanceADestructiveInspect
Run a shell command inside a running container instance on Cycle, over the instance's SSH gateway, and return the shell output. Use this for one-time setup that must run inside a container — e.g. initializing a MongoDB replica set with 'mongosh --eval "rs.initiate({...})"'.
The instance must be RUNNING (start the container first). If the container has multiple instances, pass 'instance' (id or hostname); otherwise the sole instance is used. Containers reach each other by hostname over the environment's private network, so commands can reference sibling containers (e.g. mongo-1:27017).
This executes an arbitrary command inside your container — it is powerful and mutating. Always call with preview:true first: it echoes back the exact command and target without making any connection, so the user can confirm it is what they intend (nothing is validated — the command may still fail when run). Confirm with the user, then call again without preview. Never run a command without explicit confirmation.
Short-lived SSH credentials are generated for the run and expired immediately after. The command runs in an interactive shell; make destructive commands idempotent where possible.
Inputs: command (required), container (required), environment (required), context, +4 more.
run_vm_commandRun a Command on a Virtual MachineADestructiveInspect
Run a shell command on a running virtual machine over its serial-over-SSH console, and return the console output. Use this for one-time in-guest setup — e.g. partitioning and formatting an attached data volume, then mounting it, or configuring networking.
The VM must be RUNNING (start it with cycle_control_virtual_machine first). This connects to the guest's SERIAL CONSOLE through the Cycle gateway — it does not use the VM's network — and logs in with the guest's own credentials: username defaults to 'root', and the password defaults to the VM's generated root password when that is still retrievable (~10 minutes after creation). After that window you MUST pass 'password' (and 'username' if not root); this tool never guesses or stores credentials. If nobody has the guest password any more, reconfigure_virtual_machine can set a new one. Because a serial console is a real tty, the guest echoes input, so the returned output includes some command echo — read it as a console transcript, not clean stdout.
This runs an arbitrary command as root inside the guest — it is powerful and mutating. Always call with preview:true first: it echoes the target and command and makes NO connection, so the user can confirm intent. Confirm with the user, then call again without preview. Never run a command without explicit confirmation. Make destructive commands idempotent where possible.
Serial credentials are minted for the run and expired immediately after. For a human who wants to drive their own interactive session instead, use get_vm_console_access — it returns an ssh command they run themselves; this tool is for programmatic one-shot commands.
Inputs: command (required), environment (required), virtual_machine (required), context, +5 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceRemote MCP server that lets AI assistants read tracked competitive intelligence — competitor news, reviews, website changes, social posts and ads — and act on it by managing projects, competitors, battle cards, reports and canvases. Every answer carries a source and a date, and write actions only publish when explicitly shared.MIT
- AlicenseCqualityCmaintenanceCompetitor Monitor AI - MCP server providing AI-powered tools and automation by MEOK AI Labs117 npm46 PyPIMIT
- AlicenseAqualityDmaintenanceEnables brand visibility monitoring across major AI platforms like ChatGPT, Claude, Gemini, and Perplexity. It allows users to track visibility scores, analyze competitor data, and receive actionable insights to improve AI-generated brand recommendations.169 npm1MIT

industrylens-mcpofficial
AlicenseNot gradedqualityCmaintenanceBrowse IndustryLens's published competitive-intelligence reports and head-to-head competitor comparisons from any AI agent — real, source-backed data.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.