# Cloud World Model (remote · www.cloudworldmodel.ai) Simulate cloud architectures before provisioning. 9 free demo tools; an API key unlocks all 62. - Trust score: 63/100 (medium) - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-09-29 ## Components - remote · `www.cloudworldmodel.ai`: 63/100 (this document), [markdown](https://verifymcp.io/servers/ai-cloudworldmodel-cloud-world-model/www.md), [page](https://verifymcp.io/servers/ai-cloudworldmodel-cloud-world-model/www) ## Channel facts - Endpoint: `https://www.cloudworldmodel.ai/mcp` - Transports: `streamable-http` - Auth: `none` - Version: `1.1.0` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-09-29. - **Endpoint Security**: 63/100 - The endpoint's TLS certificate is valid, in date, and uses a strong key. - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (simulation.inject_failure). - HTTPS is enforced; there's no plaintext access path. - The HSTS (Strict-Transport-Security) header is present. - DNSSEC check failed: this domain isn't protected by DNSSEC. - **Transport & Reachability**: 100/100 - Verified streamable-http transport via a live MCP handshake. - **Schema Quality & AI Usability**: 55/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 6202 tokens (~689/item across 9 items; 9 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 0/100 - Stability not yet verified: not enough scan history yet (needs a 30-day window). - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (100% of tools); any adoption earns full credit. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - All 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation. - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. **Unverified: 1 category.** A category scored 0 because we could not verify it: authentication we do not have, an unreachable endpoint, or not enough scan history. We only credit what we can confirm. ## Install ### How do I install the Cloud World Model MCP server? Cloud World Model is a hosted endpoint at https://www.cloudworldmodel.ai/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add --transport http ai-cloudworldmodel-cloud-world-model 'https://www.cloudworldmodel.ai/mcp' ``` ### Cursor ```json { "mcpServers": { "ai-cloudworldmodel-cloud-world-model": { "url": "https://www.cloudworldmodel.ai/mcp" } } } ``` ### VS Code ```json { "servers": { "ai-cloudworldmodel-cloud-world-model": { "type": "http", "url": "https://www.cloudworldmodel.ai/mcp" } } } ``` ### Codex ```toml [mcp_servers.ai-cloudworldmodel-cloud-world-model] url = "https://www.cloudworldmodel.ai/mcp" ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "ai-cloudworldmodel-cloud-world-model": { "type": "remote", "url": "https://www.cloudworldmodel.ai/mcp", "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add ai-cloudworldmodel-cloud-world-model --url 'https://www.cloudworldmodel.ai/mcp' --transport streamable-http ``` ### Hermes ```yaml mcp_servers: ai-cloudworldmodel-cloud-world-model: url: "https://www.cloudworldmodel.ai/mcp" ``` ### Netclaw ```json { "McpServers": { "ai-cloudworldmodel-cloud-world-model": { "Transport": "http", "Url": "https://www.cloudworldmodel.ai/mcp" } } } ``` ### Vellum ```bash assistant mcp add ai-cloudworldmodel-cloud-world-model -t streamable-http -u 'https://www.cloudworldmodel.ai/mcp' ``` ### Other ```json { "mcpServers": { "ai-cloudworldmodel-cloud-world-model": { "type": "http", "url": "https://www.cloudworldmodel.ai/mcp" } } } ``` The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs. ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-09-29 (score 63) First indexed and scored. ## MCP tools (9) ### `simulation.inject_failure` (~798 tokens) Inject Failure Fail one compute/Kubernetes node or database in a temporary anonymous demo simulation (marked critical, not removed). Targeted database quick failures are bounded and reversible; with no serving database at positive load, simulation.step reports 100% errors, zero goodput and errorBreakdown.dbFailure: 100. simulation.recover_resource can restore the database early. An AWS Aurora writer with characteristics.auroraStandbyResourceId pointing to a healthy related replicaOf database has an opt-in modeled failover: the first step is unavailable, the second shows the standby serving without a residual writer-outage penalty. MultiAz or an unrelated second database alone does not establish a standby. Read metrics.databases[].auroraFailover and the promotion event for the failed and standby IDs and success, plus errorRate and throughput. Each quick step is one modeled simulation second, so second-step promotion is one second after injection. Chaos database_crash samples every 10 seconds and defaults to a 30-second promotion and a 1800-second sole-writer restart after its injection duration; compare matching phases, not equal step indices or wall-clock times. These are deterministic assumptions, not observed AWS behavior. No API key required for this temporary anonymous demo operation. Exact targeting: pass resourceName (human-readable name, e.g. 'app-server-01'; exact match preferred, an unambiguous prefix is accepted) or resourceId to fail a specific resource — including an individual named instance, not only a group. If resourceName matches multiple resources the call fails with a 400 listing every matching candidate by name — retry with one exact name (or its resourceId) from that list. The database must be healthy; an already failed database returns a 400 describing its current status. When neither parameter is supplied, a RANDOM healthy compute/Kubernetes node is selected (not a database) — this path is non-deterministic and NOT suitable for controlled scenarios or repla… Input parameters: - `resourceId` (string): Optional: ID of the resource to fail. Takes precedence over resourceName. - `resourceName` (string): Optional: name of the resource to fail (exact match preferred; unambiguous prefix accepted). Ambiguous names return a 400 with a candidate list. - `simulationId` (string): Simulation ID returned by simulation.create. Preserve Mcp-Session-Id to omit this field and use the session's current simulation; if your connector starts a fresh MCP session for each call (for examp… Output parameters: - `event` (object): Failure event that was logged - `previousHealth` (string): The resource's health status immediately before the failure was applied - `resolvedResourceId` (string): ID of the resource that was failed (targeted or randomly selected) - `resolvedResourceName` (string): Name of the resource that was failed - `resources` (array): Updated resource list after failure injection ### `simulation.recover_resource` (~326 tokens) Recover Failed Resource Recover one reversible failed resource in a temporary anonymous demo simulation. No API key required for this temporary anonymous demo operation. Lower traffic to a serviceable level first, then provide resourceId or resourceName from simulation.create, simulation.step, or simulation.metrics. This deactivates applicable instance_down/database_overload failures for only the selected resource and returns recoveryProgress with parked, cooling_down, or healthy state plus cooldown counters. It cannot restore an instance_kill because that failure permanently removes the resource. The likely next tool is simulation.step; keep stepping and inspect the targeted resource until recoveryProgress.state is healthy. Pass simulationId from simulation.create when using a fresh MCP session; a preserved session may omit it. Authenticate with an API key to unlock all 62 tools and unlimited simulations. Input parameters: - `resourceId` (string): ID of the failed resource to recover - `resourceName` (string): Exact case-insensitive name of the failed resource to recover - `simulationId` (string): Simulation ID returned by simulation.create. Preserve Mcp-Session-Id to omit this field and use the session's current simulation; if your connector starts a fresh MCP session for each call (for examp… Output parameters: - `deactivatedFailureIds` (array) - `previousHealth` (string) - `recoveryProgress` (object) - `recoveryState` (string) - `resolvedResourceId` (string) - `resolvedResourceName` (string) - `simulationId` (string) - `simulationIdSource` (string) - `stepsToHealthy` (number) - `stepsToHealthyIsLowerBound` (boolean) ### `simulation.delete` (~254 tokens) Delete Simulation Permanently delete an owned temporary anonymous demo simulation and its metrics, events, failures, and capability. This is the explicit way to free a simulation slot; deletion is irreversible, while the existing demo TTL remains the safety net for abandoned simulations. Prerequisite: a simulationId from simulation.create, or an active simulation in the preserved MCP session. The likely next tool is simulation.create to use the freed slot. A successful response is { deleted: true, id }; failed ownership checks do not delete or revoke anything. Authenticate with an API key to unlock all 62 tools and persistent simulation management. Input parameters: - `simulationId` (string): Simulation ID returned by simulation.create. Preserve Mcp-Session-Id to omit this field and use the session's current simulation; if your connector starts a fresh MCP session for each call (for examp… Output parameters: - `deleted` (boolean): True when the simulation was deleted - `id` (string): ID of the deleted simulation - `simulationId` (string): ID used for the deletion - `simulationIdSource` (string) ### `scenario.list` (~268 tokens) List Scenarios List the built-in demo scenarios as compact catalog cards — stable IDs, title/name, description, difficulty, tags, category, duration, provider summary, resource/connection counts, named active/optional traffic phases, and retry-workload disclosure. Use it as the first call when you want a ready-made architecture instead of designing one; the cards intentionally omit resource, connection, traffic-pattern, and failure-injection graphs. Anonymous discovery includes only scenarios with at most 10 resources so every listed card is demo-creatable. No prerequisites. Optionally narrow discovery with provider, category, and/or difficulty filters; omit them to receive the complete demo-creatable catalog. Pass a returned id as scenarioId to simulation.create for server-side expansion, or pass it to scenario.get when you need to inspect the full graph. Larger scenarios require an authenticated session. Returns named activeFailurePhases and optionalFailurePhases with type, resource/zone target, severity, and step range. No API key required. The likely next tool is scenario.get. Input parameters: - `category` (string): Only scenarios in this category, such as scaling, failure, reliability, networking, or cost - `difficulty` (string): Only scenarios at this difficulty level - `provider` (string): Only scenarios that include resources from this cloud provider Output parameters: - `scenarios` (array): Available demo scenarios ### `scenario.get` (~172 tokens) Get Scenario Hydrate one built-in scenario from the live Cloud World Model scenario library. Prerequisite: a scenario id returned by scenario.list. Returns the complete selected scenario graph, including resources and connections plus optional seed, resilienceConfig, protectedResilienceConfig, traffic/failure presets, named traffic-phase summaries, activeFailurePhases and optionalFailurePhases (type, resource/zone target, severity, step range), retry-workload disclosure, and real-world incident metadata. The response includes both title and name for compatibility; pass resources and connections, and optionally seed/resilienceConfig, to simulation.create when you need to edit or inspect the graph. For the shorter handoff, pass the id as scenarioId instead. The likely next tool is simulation.create. Input parameters: - `scenarioId` (string, required): Scenario identifier returned by scenario.list Output parameters: - `activeFailurePhases` (array) - `activeTrafficPhases` (array) - `category` (string) - `connections` (array): Full connection graph; pass to simulation.create - `defaultFailureInjections` (array) - `defaultTrafficPatterns` (array) - `description` (string) - `difficulty` (string) - `duration` (string) - `id` (string): Stable scenario identifier - `message` (string): Error or guidance message - `name` (string): Scenario display name; equivalent to title - `optionalFailurePhases` (array) - `optionalTrafficPhases` (array) - `primaryPurpose` (string): Primary purpose of the scenario; absent means legacy purpose not specified - `protectedResilienceConfig` (object) - `realWorldIncident` (object) - `resilienceConfig` (object) - `resources` (array): Full resource graph; pass to simulation.create - `retryTrafficDisclosure` (object) - `seed` (integer) - `status` (string): Result status; not_found when the requested scenario does not exist - `tags` (array) - `title` (string): Scenario title ### `simulation.create` (~2567 tokens) Create Simulation Create a temporary anonymous demo cloud simulation from a list of resources and connections (max 2 active simulations per client, up to 10 resources; the returned simulationId is a short-lived unguessable capability that survives MCP transport teardown, but it is cleaned up when the demo lifetime expires or the simulation is deleted). No API key required for this temporary anonymous demo operation. Built-in scenario workflow: call `scenario.list` and pass a returned card's `id` as `scenarioId` to `simulation.create` for server-side graph expansion. For full control, call `scenario.get` and pass its hydrated `resources` and `connections` arrays instead. These are two alternatives — do not send `scenarioId` with `resources` or `connections`. For the catalog EKS Spot Interruption Migration scenario, you may set `scenarioOverrides: { eksSpotInterruption: { startupSeconds } }` with an integer startupSeconds from 0 through 3600 to test a different readiness deadline without copying the graph; this override requires scenarioId and is mutually exclusive with resources and connections. `scenario.list` returns graph-free cards with bounded active/optional traffic-phase and retry-workload summaries; it is not a source of resource, connection, traffic-pattern, or failure-injection graphs. Scenario traffic and failure presets are not applied automatically. Use it to start any simulation workflow — either with hydrated resources and connections from scenario.get or your own architecture. Do not use it to modify an existing simulation (use simulation.inject_traffic to change load). For the exact owned typical fit, set appWeight:'typical', location.regionKey:'us-east-2' on all four AWS nodes, one ALB with serviceFamily:'alb' and loadBalancerScheme:'internal', two m5.large compute apps with workload:'crud-typical', appRuntime:'node', appWorkerCount:2, appDbPoolSize:250, one db.r5.large MySQL with workloadDatabaseEngine:'mysql', workloadDatabaseVersion:'8.0', maxConnections:500, ALB… Input parameters: - `appWeight` (string): Immutable root-level workload weight; defaults to typical with appWeightDefaulted=true. Lean is measured only for the eligible owned graph; heavy is an unsupported assumption. predictionEvidence repo… - `autoscaleTargetCpuPercent` (number): Grok-compatible alias for the CPU HPA scale-out target; if multiple target names are sent they must match. - `autoscalingTargetCpu` (number): Canonical CPU HPA scale-out target percent. CWM synthesizes unrelated autoscaling defaults. - `connections` (array): Directed connections between resources. For a built-in scenario, pass the hydrated connections from scenario.get; scenario.list cards are graph-free. Directed edges should describe traffic flow betwe… - `description` (string): Optional description of the simulation's purpose - `ecsCpuTargetTracking` (boolean): Opt into CPU-only ECS Fargate target tracking. - `maxInstances` (integer): Hard ceiling on the autoscaled compute fleet size, stored as autoscalingConfig.maxInstances. If omitted, the provider default applies (AWS 50, GCP 15, Azure/OCI/DigitalOcean 10) — which may be much l… - `minInstances` (integer): Floor on the autoscaled compute fleet size, stored as autoscalingConfig.minInstances. - `name` (string, required): Human-readable name for the simulation - `resilienceConfig` (object): Optional retry/cascade resilience model returned by scenario.get - `resources` (array): List of cloud resources composing this simulation. For a built-in scenario, pass the hydrated resources from scenario.get; scenario.list cards are graph-free. (max 10 in demo mode; mutually exclusive… - `responseMode` (string): Response detail level. 'compact' (default) returns id, name, status, traffic, and a per-resource summary (id, name, status, cpuPercent) — keeps the response small for agent loops. 'full' returns the… - `scaleInCooldownSeconds` (integer): ECS CPU target-tracking scale-in cooldown in simulated seconds. - `scaleOutCooldownSeconds` (integer): ECS CPU target-tracking scale-out cooldown in simulated seconds. - `scaleOutCpuPercent` (number): Grok-compatible alias for the CPU HPA scale-out target; if multiple target names are sent they must match. - `scaleOutCpuThreshold` (number): Equivalent alias for autoscalingTargetCpu; if both are sent they must match. - `scenarioId` (string): Live scenario identifier from scenario.list; mutually exclusive with resources and connections - `seed` (integer): Deterministic RNG seed for reproducible replays - `simulationSecondsPerStep` (number): Simulated seconds per step for ECS cooldowns (default 1). - `traffic` (number): Initial traffic in requests per second (RPS) Output parameters: - `appWeight` (string) - `appWeightDefaulted` (boolean) - `autoscalingConfig` (object): Effective simulation scaling config; full response also contains the ECS resource's linked CPU-only target-tracking policy. - `calibrationEvidence` (object): Owned-versus-modeled evidence and latency boundary. - `effectiveConfigHash` (string): Versioned prediction hash over replay startup inputs, engine version, and calibration identity; see replayIdentity.effectiveConfigHash for the original replay-only hash. - `effectiveMaxInstances` (number): The fleet-size ceiling the engine will enforce (autoscalingConfig.maxInstances, or the provider default when unset) - `effectiveMinInstances` (number): The fleet-size floor the engine will enforce (autoscalingConfig.minInstances, or the provider default when unset) - `engineVersion` (string): Simulation engine version used for this prediction. - `hpaAudit` (object): CPU HPA create-time audit: whether a target arrived, its accepted field, the persisted thresholds, and the provider-default explanation when omitted. - `id` (string): Unique simulation ID — use with simulation.step, simulation.metrics, etc. - `name` (string): Simulation name - `normalizedConfig` (object): Engine-resolved billing parameters for every resource: cost multipliers, hourly rates, autoscale thresholds (scaleOut/scaleIn CPU %), GPU SKU, per-node token throughput, billing floor, connection lim… - `predictionEffectiveConfigHash` (string): Versioned prediction hash over replay startup inputs, engine version, and calibration identity. - `predictionEvidence` - `replayIdentity` (object) - `resources` (array): Per-resource summary (compact mode) or full resource states (full mode) - `scenarioAttribution` (object): Trusted server-side attribution copied from the live scenario catalog; absent for explicit resource-graph creates - `scenarioHash` (string): Canonical SHA-256 of the persisted scenario graph and attached traffic-pattern order - `status` (string): Current simulation status - `traffic` (number): Current traffic in RPS ### `simulation.step` (~751 tokens) Simulate Step Advance a temporary anonymous demo simulation by one time step and return updated metrics — CPU, latency, throughput, error rate, cost (max 20 persisted steps per demo). Concurrent simulation.step calls on one simulation either serialize as distinct consecutive steps (in the browser Workspace queue) or receive HTTP 409 simulation_step_in_progress without advancing or consuming a demo credit. Wait for the running call to finish, then retry only rejected calls; distinct simulations can run concurrently. After a timeout, inspect simulation.metrics before retrying an uncertain result. Use it to observe how the architecture behaves over time, typically right after simulation.create or simulation.inject_traffic. Do not use it to read current state without advancing time — that is simulation.metrics. Pass the simulationId returned by simulation.create when your connector opens a fresh MCP session; preserve Mcp-Session-Id to use the omitted-ID current-simulation default. The likely next tool is simulation.step again (to keep observing) or simulation.inject_traffic (to change load first). Responses are compact by default: principal metrics plus per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, and recoveryBlockedReason when provided) and this step's events. Seeded characteristics.eksSpotInterruption telemetry retains its additive migrationEvaluation beside the interruption lifecycle: use its recorded/derived/unavailable field provenance, frozen deadline verdict/counts/reasons, and simulation-clock milestones rather than final service health. The distinct eksSpotMigration contract remains separately reported when configured. Compact responses also include errorBreakdown when the engine provides it. A critical resource with isRoutable: true is degraded but still serving; availabilityState: unavailable and isRoutable: false identify a failed or parked node. Pass responseMode: 'full' to get the complete simulation state instead. During… Input parameters: - `responseMode` (string): Response detail level. 'compact' (default) returns only principal metrics, errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable,… - `simulationId` (string): Simulation ID returned by simulation.create. Preserve Mcp-Session-Id to omit this field and use the session's current simulation; if your connector starts a fresh MCP session for each call (for examp… Output parameters: - `appWeight` (string) - `appWeightDefaulted` (boolean) - `auroraFailovers` (array): Compact per-writer Aurora failover state; promoting has no serving writer, serving means the explicitly related standby took over. - `calibrationEvidence` (object): Owned-versus-modeled evidence and latency boundary. - `costPerHour` (number): Estimated cost in USD/hr - `costPerMillionTokens` (number|null): Self-hosted inference cost in USD per million tokens (null when no tokens are being processed) — present only on GPU inference simulations - `currentStep` (number): New simulation time step index - `effectiveConfigHash` (string): Versioned prediction hash over replay startup inputs, engine version, and calibration identity; see replayIdentity.effectiveConfigHash for the original replay-only hash. - `eksSpotInterruptions` (array): Seeded EKS interruption telemetry, including the authoritative additive migrationEvaluation when recorded. - `engineVersion` (string): Simulation engine version used for this prediction. - `errorBreakdown` (object): Validated additive error contributors in percentage-point units; separates pool/DB, compute, capacity, CPU, storage, runtime-memory, and queue absorption effects - `errorRate` (number): Error rate (%) - `events` (array): Events generated during this step - `goodputProvenance`: Provenance for the modeled goodput field - `goodputRps` (number): Modeled successful requests per second; a post-step point rate sourced from metrics.throughput - `goodputSemantics` (string): Goodput is a point rate, not an interval total - `goodputWindow`: Interval goodput aggregate when every point has persisted simulation-clock bounds; otherwise status=unavailable. Never derive this from retrieval time or currentStep. - `gpuUtilization` (number): GPU utilization (%) — present only on simulations with a GPU inference kubernetes resource - `idleGpuCostPerHour` (number): USD/hr of GPU spend funding idle/standby capacity (HA overhead) — present only on GPU inference simulations - `idleGpuFraction` (number): Share (0-1) of the GPU bill that is idle/standby capacity — present only on GPU inference simulations; values above 0.5 mean over half the GPU spend is HA overhead - `latencyBasis` (string): General modeled latency path/boundary; see latencyP99Basis for P99-specific provenance. - `latencyP50` (number): 50th-percentile latency in ms - `latencyP95` (number): 95th-percentile latency in ms - `latencyP99` (number): Modeled 99th-percentile latency in ms; interpret with latencyP99Basis and predictionEvidence.latencyP99. - `latencyP99Basis` (string): Percentile-specific P99 basis: owned fit, scaled-from-fit (not directly measured), or uncalibrated generic model. - `metricId` (string): Storage-assigned persisted metric ID when available - `metrics` (object): Full-mode backend metric record; migrationEvaluation is exact-typed when a seeded interruption is present. - `modeledShedRps` (number): Aggregate modeled requests per second shed by bounded capacity - `offeredRps` (number): Aggregate offered requests per second represented by metrics.offeredRps provenance - `predictionEffectiveConfigHash` (string): Versioned prediction hash over replay startup inputs, engine version, and calibration identity. - `predictionEvidence` - `replayIdentity` (object) - `resilienceDiagnostics` (object): Bounded resilience diagnostics summary (compact mode). Absent when the resilience model did not run. Use simulation.compare_resilience for full per-path detail. - `resources` (array): Per-resource status summary (compact mode) - `retryAmplificationFactor` (number|null): Retry amplification factor for this step (attemptedRps / originalRps). Values > 1.0 = amplification risk. null = model ran but no traffic. Absent = resilience model disabled. - `scenarioHash` (string): Canonical SHA-256 of the persisted scenario graph and attached traffic-pattern order - `simulationId` (string): ID of the stepped simulation - `throughput` (number): Effective requests per second - `tokensPerSecond` (number): Inference throughput in tokens/second — present only on GPU inference simulations - `traffic` (number): Current traffic level in RPS ### `simulation.metrics` (~649 tokens) Get Simulation Metrics Read the latest metrics and resource states for a temporary anonymous demo simulation: latency, CPU, throughput, error rate, cost per hour, and per-resource health. Use it to inspect current state and metrics history without advancing time; do not use it to move the simulation forward — that is simulation.step. Responses are compact by default: principal current metrics plus explicit modeled goodputRps (a post-step point rate sourced from throughput, with provenance), goodputWindow (recorded only from persisted simulation-clock bounds, otherwise unavailable with provenance; never derive it from retrieval time or currentStep), errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutable, and recoveryBlockedReason when provided), seeded EKS Spot checkpoint history and migrationEvaluationComplete/provenance when present, and the last 10 metrics-history entries. Pass responseMode: 'full' to get the complete simulation state, normalizedConfig, and full metrics history instead. During recovery, each resource may include recoveryProgress.state (parked, cooling_down, or healthy) with parkWindow and cooldown counters; poll simulation.step until healthy, then use simulation.metrics to inspect the resulting state and metrics. GPU / inference workflow: when the simulation includes a kubernetes resource with characteristics.inferenceMode: true, the response also includes top-level gpuUtilization (%), tokensPerSecond, costPerMillionTokens (USD/M tokens), idleGpuCostPerHour (USD/hr of standby GPU spend), and idleGpuFraction (0-1 idle HA overhead share) from the latest step, and each history entry carries the same inference fields. Pass the simulationId returned by simulation.create when your connector opens a fresh MCP session; preserve Mcp-Session-Id to use the omitted-ID current-simulation default. A fresh session has no current-simulation pointer. At least one simulation.step is needed for meaningful metrics. Read-o… Input parameters: - `responseMode` (string): Response detail level. 'compact' (default) returns principal current metrics, errorBreakdown when available, per-resource status (id, name, status, cpuPercent, routedRps, availabilityState, isRoutabl… - `simulationId` (string): Simulation ID returned by simulation.create. Preserve Mcp-Session-Id to omit this field and use the session's current simulation; if your connector starts a fresh MCP session for each call (for examp… Output parameters: - `appWeight` (string) - `appWeightDefaulted` (boolean) - `auroraFailovers` (array): Latest compact per-writer Aurora failover state, with failed and standby IDs and phase. - `calibrationEvidence` (object): Owned-versus-modeled evidence and latency boundary. - `costPerHour` (number): Latest estimated cost in USD/hr - `costPerMillionTokens` (number|null): Latest self-hosted inference cost in USD per million tokens (null when no tokens are being processed) — present only on GPU inference simulations - `currentStep` (number): Current simulation time step - `effectiveConfigHash` (string): Versioned prediction hash over replay startup inputs, engine version, and calibration identity. - `eksSpotInterruptions` (array): Latest seeded EKS interruption telemetry, including additive migrationEvaluation/provenance when recorded. - `engineVersion` (string): Simulation engine version used for this prediction. - `errorBreakdown` (object): Validated additive error contributors from the latest metrics entry, in percentage-point units - `errorRate` (number): Latest error rate (%) - `goodputProvenance`: Provenance for the modeled goodput field - `goodputRps` (number): Modeled successful requests per second; a post-step point rate sourced from metrics.throughput - `goodputSemantics` (string): Goodput is a point rate, not an interval total - `goodputWindow`: Interval goodput aggregate when every point has persisted simulation-clock bounds; otherwise status=unavailable. Never derive this from retrieval time or currentStep. - `gpuUtilization` (number): Latest GPU utilization (%) — present only on GPU inference simulations - `idleGpuCostPerHour` (number): Latest USD/hr of GPU spend funding idle/standby capacity (HA overhead) — present only on GPU inference simulations - `idleGpuFraction` (number): Latest share (0-1) of the GPU bill that is idle/standby capacity — present only on GPU inference simulations - `latencyBasis` (string): Latest general modeled latency path/boundary; see latencyP99Basis for P99-specific provenance. - `latencyP50` (number): Latest 50th-percentile latency in ms - `latencyP95` (number): Latest 95th-percentile latency in ms - `latencyP99` (number): Latest modeled 99th-percentile latency in ms; interpret with latencyP99Basis and predictionEvidence.latencyP99. - `latencyP99Basis` (string): Latest percentile-specific P99 basis: owned fit, scaled-from-fit (not directly measured), or uncalibrated generic model. - `metricId` (string): Storage-assigned ID of the latest persisted metric - `metrics` (array): Metrics history — bounded to the last 10 entries in compact mode, full history in full mode - `metricsHistoryLength` (number): Total number of metrics-history entries (compact mode returns only the last 10) - `modeledShedRps` (number): Latest aggregate modeled shed requests per second - `offeredRps` (number): Latest aggregate offered requests per second - `predictionEffectiveConfigHash` (string): Versioned prediction hash over replay startup inputs, engine version, and calibration identity. - `predictionEvidence` - `replayIdentity` (object) - `resilienceDiagnostics` (object): Bounded resilience diagnostics from the latest step (compact mode). Absent when the resilience model did not run. - `resources` (array): Per-resource status summary (compact mode) - `retryAmplificationFactor` (number|null): Latest retry amplification factor (attemptedRps / originalRps). Values > 1.0 = amplification risk. null = model ran but no traffic. Absent = resilience model disabled. - `scenarioHash` (string): Canonical replay scenario graph hash. - `simulation` (object): Complete simulation state (full mode only; absent in compact mode and when status is not_found/access_denied) - `simulationId` (string): ID of the queried simulation - `throughput` (number): Latest effective requests per second - `tokensPerSecond` (number): Latest inference throughput in tokens/second — present only on GPU inference simulations - `traffic` (number): Current traffic level in RPS ### `simulation.inject_traffic` (~318 tokens) Inject Traffic Change the traffic load on a demo simulation. Omit traffic to trigger a random 2×–5× spike (sends random: true internally); provide traffic to set an absolute RPS level (capped at 10000 RPS in demo mode). Use it to stress-test the architecture before stepping; the change only affects metrics after the next simulation.step. Do not use it to read metrics (simulation.metrics) or advance time (simulation.step). Pass the simulationId returned by simulation.create when your connector opens a fresh MCP session; preserve Mcp-Session-Id to use the omitted-ID current-simulation default. Returns the updated simulation with its new traffic level; the likely next tool is simulation.step. Input parameters: - `simulationId` (string): Simulation ID returned by simulation.create. Preserve Mcp-Session-Id to omit this field and use the session's current simulation; if your connector starts a fresh MCP session for each call (for examp… - `traffic` (number): Absolute traffic level in RPS to set. Omit to trigger a random spike instead. Server-capped at 10000 RPS in demo mode. Output parameters: - `id` (string): Simulation ID - `status` (string): Updated simulation status - `traffic` (number): New traffic level in RPS after injection ## Diagnostics Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/ai-cloudworldmodel-cloud-world-model/www#diagnostics ## Score history - 2026-09-29: 63 ## Common questions ### What is the Cloud World Model MCP server? Cloud World Model is an MCP server listed in the public MCP registry as ai.cloudworldmodel/cloud-world-model. Simulate cloud architectures before provisioning. 9 free demo tools; an API key unlocks all 62. This page covers its hosted endpoint (https://www.cloudworldmodel.ai/mcp). ### Is the Cloud World Model MCP server safe to use? Cloud World Model scores 63 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the Cloud World Model MCP server expose? Cloud World Model exposes 9 tools: simulation.inject_failure, simulation.recover_resource, simulation.delete, scenario.list, scenario.get, and 4 more. Their descriptions and schemas cost roughly 6,103 tokens of context every time the server is loaded. ### Does the Cloud World Model MCP server require authentication? No. We connected to Cloud World Model without credentials and it answered, so anything it exposes is reachable by anyone who knows the address. ### Is the Cloud World Model MCP server still maintained? Cloud World Model is still listed as active in the MCP registry. We last reached this channel on 29 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ## Links - Remote endpoint: https://www.cloudworldmodel.ai/mcp - Website: https://www.cloudworldmodel.ai/ - Changelog RSS feed: https://verifymcp.io/servers/ai-cloudworldmodel-cloud-world-model/www.xml - Changelog JSON feed: https://verifymcp.io/servers/ai-cloudworldmodel-cloud-world-model/www.json - HTML version of this page: https://verifymcp.io/servers/ai-cloudworldmodel-cloud-world-model/www